LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
lar_content::EventSlicingTool Class Reference

EventSlicingTool class. More...

#include "EventSlicingTool.h"

Inheritance diagram for lar_content::EventSlicingTool:
lar_content::EventSlicingBaseTool

Public Member Functions

 EventSlicingTool ()
 Default constructor. More...
 
void RunSlicing (const pandora::Algorithm *const pAlgorithm, const HitTypeToNameMap &caloHitListNames, const HitTypeToNameMap &clusterListNames, 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< PointKDNode2DPointKDNode2DList
 
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 HitTypeToNameMap &caloHitListNames, 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, 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, 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 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, 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 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 PointKDNode2DMatchClusterToSlice (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 34 of file EventSlicingTool.h.

Member Typedef Documentation

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

Definition at line 69 of file EventSlicingTool.h.

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

Definition at line 55 of file EventSlicingTool.h.

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

Definition at line 169 of file EventSlicingTool.h.

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

Definition at line 225 of file EventSlicingTool.h.

Definition at line 226 of file EventSlicingTool.h.

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

Definition at line 224 of file EventSlicingTool.h.

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

Definition at line 228 of file EventSlicingTool.h.

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

Definition at line 229 of file EventSlicingTool.h.

Constructor & Destructor Documentation

lar_content::EventSlicingTool::EventSlicingTool ( )

Default constructor.

Definition at line 30 of file EventSlicingTool.cc.

30  :
42  m_maxHitSeparationSquared(25.f * 25.f),
44  m_nConeFitLayers(20),
45  m_nConeFits(5),
47  m_maxConeLength(126.f),
53 {
54 }
unsigned int m_nConeFits
The number of cone fits to perform, spread roughly uniformly along the shower length.
unsigned int m_min3DHitsToSeedNewSlice
The minimum number of hits in a 3D cluster to seed a new slice.
float m_maxHitSeparationSquared
Proximity association: max distance allowed between the closest pair of hits.
unsigned int m_nConeFitLayers
The number of layers over which to sum fitted direction to obtain cone fit.
float m_coneTanHalfAngle2
The cone tan half angle to use when calculating bounded cluster fractions 2.
float m_maxVertexTransverseDistance
Pointing association check: max transverse distance cut.
float m_coneBoundedFraction2
The minimum cluster bounded fraction for association 2.
unsigned int m_minHitsPer3DCluster
The minimum number of hits in a 3D cluster to warrant consideration in slicing.
float m_coneTanHalfAngle1
The cone tan half angle to use when calculating bounded cluster fractions 1.
float m_maxVertexLongitudinalDistance
Pointing association check: max longitudinal distance cut.
TFile f
Definition: plotHisto.C:6
bool m_useProximityAssociation
Whether to use proximity association.
float m_maxClosestApproach
Pointing association: max distance of closest approach between straight line fits.
bool m_usePointingAssociation
Whether to use pointing association.
float m_coneLengthMultiplier
The cone length multiplier to use when calculating bounded cluster fractions.
float m_maxInterceptDistance
Pointing association: max distance from cluster vertex to point of closest approach.
float m_minVertexLongitudinalDistance
Pointing association check: min longitudinal distance cut.
bool m_use3DProjectionsInHitPickUp
Whether to include 3D cluster projections when assigning remaining clusters to slices.
float m_maxConeLength
The maximum allowed cone length to use when calculating bounded cluster fractions.
bool m_useShowerConeAssociation
Whether to use shower cone association.
float m_vertexAngularAllowance
Pointing association check: pointing angular allowance in degrees.
float m_coneBoundedFraction1
The minimum cluster bounded fraction for association 1.
unsigned int m_halfWindowLayers
The number of layers to use for half-window of sliding fit.

Member Function Documentation

void lar_content::EventSlicingTool::AssignRemainingHitsToSlices ( const pandora::ClusterList &  remainingClusters,
const ClusterToSliceIndexMap clusterToSliceIndexMap,
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
remainingClustersthe list of 2D clusters with hits yet to be assigned to slices
clusterToSliceIndexMapthe mapping from 3D clusters to index in the slice list
sliceListthe list containing slices to be populated with 2D hits

Definition at line 530 of file EventSlicingTool.cc.

References lar_content::KDTreeLinkerAlgo< DATA, DIM >::build(), lar_content::KDTreeNodeInfoT< DATA, DIM >::data, lar_content::fill_and_bound_2d_kd_tree(), lar_content::LArClusterHelper::GetClusterHitType(), GetKDTreeEntries2D(), GetKDTreeEntries3D(), lar_content::Slice::m_caloHitListU, lar_content::Slice::m_caloHitListV, lar_content::Slice::m_caloHitListW, m_use3DProjectionsInHitPickUp, MatchClusterToSlice(), lar_content::LArClusterHelper::SortByNHits(), and SortPoints().

Referenced by RunSlicing().

532 {
533  PointToSliceIndexMap pointToSliceIndexMap;
534 
535  try
536  {
537  PointList pointsU, pointsV, pointsW;
538  this->GetKDTreeEntries2D(sliceList, pointsU, pointsV, pointsW, pointToSliceIndexMap);
539 
541  this->GetKDTreeEntries3D(clusterToSliceIndexMap, pointsU, pointsV, pointsW, pointToSliceIndexMap);
542 
543  pointsU.sort(EventSlicingTool::SortPoints);
544  pointsV.sort(EventSlicingTool::SortPoints);
545  pointsW.sort(EventSlicingTool::SortPoints);
546 
547  PointKDNode2DList kDNode2DListU, kDNode2DListV, kDNode2DListW;
548  KDTreeBox boundingRegionU = fill_and_bound_2d_kd_tree(pointsU, kDNode2DListU);
549  KDTreeBox boundingRegionV = fill_and_bound_2d_kd_tree(pointsV, kDNode2DListV);
550  KDTreeBox boundingRegionW = fill_and_bound_2d_kd_tree(pointsW, kDNode2DListW);
551 
552  PointKDTree2D kdTreeU, kdTreeV, kdTreeW;
553  kdTreeU.build(kDNode2DListU, boundingRegionU);
554  kdTreeV.build(kDNode2DListV, boundingRegionV);
555  kdTreeW.build(kDNode2DListW, boundingRegionW);
556 
557  ClusterVector sortedRemainingClusters(remainingClusters.begin(), remainingClusters.end());
558  std::sort(sortedRemainingClusters.begin(), sortedRemainingClusters.end(), LArClusterHelper::SortByNHits);
559 
560  for (const Cluster *const pCluster2D : sortedRemainingClusters)
561  {
562  const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster2D));
563 
564  if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
565  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
566 
567  PointKDTree2D &kdTree((TPC_VIEW_U == hitType) ? kdTreeU : (TPC_VIEW_V == hitType) ? kdTreeV : kdTreeW);
568  const PointKDNode2D *pBestResultPoint(this->MatchClusterToSlice(pCluster2D, kdTree));
569 
570  if (!pBestResultPoint)
571  continue;
572 
573  Slice &slice(sliceList.at(pointToSliceIndexMap.at(pBestResultPoint->data)));
574  CaloHitList &targetList((TPC_VIEW_U == hitType) ? slice.m_caloHitListU
575  : (TPC_VIEW_V == hitType) ? slice.m_caloHitListV
576  : slice.m_caloHitListW);
577 
578  pCluster2D->GetOrderedCaloHitList().FillCaloHitList(targetList);
579  targetList.insert(targetList.end(), pCluster2D->GetIsolatedCaloHitList().begin(), pCluster2D->GetIsolatedCaloHitList().end());
580  }
581  }
582  catch (...)
583  {
584  std::cout << "EventSlicingTool::AssignRemainingHitsToSlices - exception " << std::endl;
585  for (const auto &pointMap : pointToSliceIndexMap)
586  delete pointMap.first;
587  throw;
588  }
589 
590  for (const auto &pointMap : pointToSliceIndexMap)
591  delete pointMap.first;
592 }
KDTreeLinkerAlgo< const pandora::CartesianVector *, 2 > PointKDTree2D
static bool SortByNHits(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
Sort clusters by number of hits, then layer span, then inner layer, then position, then pulse-height.
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
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 clust...
std::unordered_map< const pandora::CartesianVector *, unsigned int > PointToSliceIndexMap
KDTreeNodeInfoT< const pandora::CartesianVector *, 2 > PointKDNode2D
static bool SortPoints(const pandora::CartesianVector *const pLhs, const pandora::CartesianVector *const pRhs)
Sort points (use Z, followed by X, followed by Y)
void GetKDTreeEntries2D(const 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 remai...
std::list< const pandora::CartesianVector * > PointList
HitType
Definition: HitType.h:12
std::vector< PointKDNode2D > PointKDNode2DList
KDTreeBox fill_and_bound_2d_kd_tree(const MANAGED_CONTAINER< const T * > &points, std::vector< KDTreeNodeInfoT< const T *, 2 >> &nodes)
fill_and_bound_2d_kd_tree
bool m_use3DProjectionsInHitPickUp
Whether to include 3D cluster projections when assigning remaining clusters to slices.
std::vector< art::Ptr< recob::Cluster > > ClusterVector
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...
KDTreeBoxT< 2 > KDTreeBox
bool lar_content::EventSlicingTool::CheckClosestApproach ( const LArPointingCluster cluster1,
const LArPointingCluster cluster2 
) const
private

Check closest approach metrics for a pair of pointing clusters.

Parameters
cluster1the first pointing cluster
cluster2the second pointing cluster
Returns
whether the pointing clusters are declared to be in the same slice

Definition at line 346 of file EventSlicingTool.cc.

References lar_content::LArPointingCluster::GetInnerVertex(), and lar_content::LArPointingCluster::GetOuterVertex().

Referenced by PassPointing().

347 {
348  return (this->CheckClosestApproach(cluster1.GetInnerVertex(), cluster2.GetInnerVertex()) ||
349  this->CheckClosestApproach(cluster1.GetOuterVertex(), cluster2.GetInnerVertex()) ||
350  this->CheckClosestApproach(cluster1.GetInnerVertex(), cluster2.GetOuterVertex()) ||
351  this->CheckClosestApproach(cluster1.GetOuterVertex(), cluster2.GetOuterVertex()));
352 }
bool CheckClosestApproach(const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
Check closest approach metrics for a pair of pointing clusters.
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
vertex1the first pointing cluster vertex
vertex2the second pointing cluster vertex
Returns
whether the pointing clusters are declared to be in the same slice

Definition at line 356 of file EventSlicingTool.cc.

References f, lar_content::LArPointingCluster::Vertex::GetDirection(), lar_content::LArPointingClusterHelper::GetIntersection(), lar_content::LArPointingCluster::Vertex::GetPosition(), m_maxClosestApproach, and m_maxInterceptDistance.

357 {
358  CartesianVector intersectionPoint(0.f, 0.f, 0.f);
359  float displacement1(std::numeric_limits<float>::max()), displacement2(std::numeric_limits<float>::max());
360 
361  try
362  {
363  LArPointingClusterHelper::GetIntersection(vertex1, vertex2, intersectionPoint, displacement1, displacement2);
364  }
365  catch (const StatusCodeException &)
366  {
367  return false;
368  }
369 
370  const CartesianVector approach1(vertex1.GetPosition() + vertex1.GetDirection() * displacement1);
371  const CartesianVector approach2(vertex2.GetPosition() + vertex2.GetDirection() * displacement2);
372  const float closestApproach((approach1 - approach2).GetMagnitude());
373 
374  return ((closestApproach < m_maxClosestApproach) && (std::fabs(displacement1) < m_maxInterceptDistance) &&
375  (std::fabs(displacement2) < m_maxInterceptDistance));
376 }
static void GetIntersection(const LArPointingCluster::Vertex &firstVertex, const LArPointingCluster::Vertex &secondVertex, pandora::CartesianVector &intersectPosition, float &firstDisplacement, float &secondDisplacement)
Get intersection of two vertices.
TFile f
Definition: plotHisto.C:6
float m_maxClosestApproach
Pointing association: max distance of closest approach between straight line fits.
float m_maxInterceptDistance
Pointing association: max distance from cluster vertex to point of closest approach.
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
pClusterInSlicethe address of the cluster already in a slice
candidateClustersthe list of candidate clusters
trackFitResultsthe map of sliding fit results for track candidate clusters
showerConeFitResultsthe map of sliding const fit results for shower candidate clusters
clusterSlicethe cluster slice
usedClustersthe list of clusters already added to slices

Definition at line 228 of file EventSlicingTool.cc.

References m_usePointingAssociation, m_useProximityAssociation, m_useShowerConeAssociation, PassPointing(), PassProximity(), and PassShowerCone().

Referenced by GetClusterSliceList().

231 {
232  ClusterVector addedClusters;
233 
234  for (const Cluster *const pCandidateCluster : candidateClusters)
235  {
236  if (usedClusters.count(pCandidateCluster) || (pClusterInSlice == pCandidateCluster))
237  continue;
238 
239  if ((m_usePointingAssociation && this->PassPointing(pClusterInSlice, pCandidateCluster, trackFitResults)) ||
240  (m_useProximityAssociation && this->PassProximity(pClusterInSlice, pCandidateCluster)) ||
242  (this->PassShowerCone(pClusterInSlice, pCandidateCluster, showerConeFitResults) ||
243  this->PassShowerCone(pCandidateCluster, pClusterInSlice, showerConeFitResults))))
244  {
245  addedClusters.push_back(pCandidateCluster);
246  (void)usedClusters.insert(pCandidateCluster);
247  }
248  }
249 
250  clusterSlice.insert(clusterSlice.end(), addedClusters.begin(), addedClusters.end());
251 
252  for (const Cluster *const pAddedCluster : addedClusters)
253  this->CollectAssociatedClusters(pAddedCluster, candidateClusters, trackFitResults, showerConeFitResults, clusterSlice, usedClusters);
254 }
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 clust...
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 ...
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.
bool m_useProximityAssociation
Whether to use proximity association.
bool m_usePointingAssociation
Whether to use pointing association.
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. ...
std::vector< art::Ptr< recob::Cluster > > ClusterVector
bool m_useShowerConeAssociation
Whether to use shower cone association.
void lar_content::EventSlicingTool::CopyAllHitsToSingleSlice ( const pandora::Algorithm *const  pAlgorithm,
const HitTypeToNameMap caloHitListNames,
SliceList sliceList 
) const
private

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

Parameters
pAlgorithmthe address of the calling algorithm
caloHitListNamesthe hit type to calo hit list name map
sliceListthe slice list to receive the single new slice

Definition at line 96 of file EventSlicingTool.cc.

References lar_content::Slice::m_caloHitListU.

Referenced by RunSlicing().

97 {
98  if (!sliceList.empty())
99  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
100 
101  const CaloHitList *pCaloHitListU(nullptr);
102  PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=,
103  PandoraContentApi::GetList(*pAlgorithm, caloHitListNames.at(TPC_VIEW_U), pCaloHitListU));
104 
105  const CaloHitList *pCaloHitListV(nullptr);
106  PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=,
107  PandoraContentApi::GetList(*pAlgorithm, caloHitListNames.at(TPC_VIEW_V), pCaloHitListV));
108 
109  const CaloHitList *pCaloHitListW(nullptr);
110  PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=,
111  PandoraContentApi::GetList(*pAlgorithm, caloHitListNames.at(TPC_VIEW_W), pCaloHitListW));
112 
113  if (pCaloHitListU || pCaloHitListV || pCaloHitListW)
114  {
115  sliceList.push_back(Slice());
116  Slice &slice(sliceList.at(0));
117 
118  if (pCaloHitListU)
119  slice.m_caloHitListU = *pCaloHitListU;
120  if (pCaloHitListV)
121  slice.m_caloHitListV = *pCaloHitListV;
122  if (pCaloHitListW)
123  slice.m_caloHitListW = *pCaloHitListW;
124  }
125 }
void lar_content::EventSlicingTool::CopyPfoHitsToSlices ( const ClusterToSliceIndexMap clusterToSliceIndexMap,
const ClusterToPfoMap clusterToPfoMap,
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
clusterToSliceIndexMapthe mapping from 3D clusters to index in the slice list
clusterToPfoMapthe mapping from 3D clusters to parent pfos
sliceListthe list containing slices to be populated with 2D hits
assignedClustersto receive the list of 2D clusters with hits assigned to slices

Definition at line 446 of file EventSlicingTool.cc.

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

Referenced by RunSlicing().

448 {
449  ClusterList clusterList;
450  for (const auto &mapEntry : clusterToSliceIndexMap)
451  clusterList.push_back(mapEntry.first);
452  clusterList.sort(LArClusterHelper::SortByNHits);
453 
454  for (const Cluster *const pCluster3D : clusterList)
455  {
456  const unsigned int index(clusterToSliceIndexMap.at(pCluster3D));
457 
458  const Pfo *const pPfo(clusterToPfoMap.at(pCluster3D));
459  Slice &slice(sliceList.at(index));
460 
461  ClusterList clusters2D;
462  LArPfoHelper::GetTwoDClusterList(pPfo, clusters2D);
463 
464  for (const Cluster *const pCluster2D : clusters2D)
465  {
466  const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster2D));
467 
468  if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
469  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
470 
471  CaloHitList &targetList((TPC_VIEW_U == hitType) ? slice.m_caloHitListU
472  : (TPC_VIEW_V == hitType) ? slice.m_caloHitListV
473  : slice.m_caloHitListW);
474 
475  pCluster2D->GetOrderedCaloHitList().FillCaloHitList(targetList);
476  targetList.insert(targetList.end(), pCluster2D->GetIsolatedCaloHitList().begin(), pCluster2D->GetIsolatedCaloHitList().end());
477 
478  if (!assignedClusters.insert(pCluster2D).second)
479  throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
480  }
481  }
482 }
static bool SortByNHits(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
Sort clusters by number of hits, then layer span, then inner layer, then position, then pulse-height.
static void GetTwoDClusterList(const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
Get the list of 2D clusters from an input pfo.
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
HitType
Definition: HitType.h:12
void lar_content::EventSlicingTool::CreateSlices ( const ClusterSliceList clusterSliceList,
SliceList sliceList,
ClusterToSliceIndexMap clusterToSliceIndexMap 
) const
private

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

Parameters
clusterSliceListthe list of 3D clusters, divided into slices (one 3D cluster list per slice)
sliceListthe slice list to receive the new slices
clusterToSliceIndexMapto receive the mapping from 3D clusters to index in the slice list

Definition at line 424 of file EventSlicingTool.cc.

References lar_content::LArClusterHelper::GetClusterHitType().

Referenced by RunSlicing().

425 {
426  unsigned int index(0);
427 
428  for (const ClusterVector &clusterList : clusterSliceList)
429  {
430  for (const Cluster *const pCluster3D : clusterList)
431  {
432  if (TPC_3D != LArClusterHelper::GetClusterHitType(pCluster3D))
433  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
434 
435  if (!clusterToSliceIndexMap.insert(ClusterToSliceIndexMap::value_type(pCluster3D, index)).second)
436  throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
437  }
438 
439  sliceList.push_back(Slice());
440  ++index;
441  }
442 }
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
std::vector< art::Ptr< recob::Cluster > > ClusterVector
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
trackClusters3Dthe list of 3D track clusters
showerClusters3Dthe list of 3D shower clusters
clusterSliceListto receive the list of 3D clusters, divided into slices (one 3D cluster list per slice)

Definition at line 166 of file EventSlicingTool.cc.

References CollectAssociatedClusters(), lar_content::LArGeometryHelper::GetWirePitch(), m_halfWindowLayers, m_min3DHitsToSeedNewSlice, and lar_content::LArClusterHelper::SortByNHits().

Referenced by RunSlicing().

167 {
168  const float pitchU{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_U)};
169  const float pitchV{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_V)};
170  const float pitchW{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_W)};
171  const float pitchMax{std::max({pitchU, pitchV, pitchW})};
172  const float layerPitch(pitchMax);
173 
174  ThreeDSlidingFitResultMap trackFitResults;
175 
176  for (const Cluster *const pCluster3D : trackClusters3D)
177  {
178  try
179  {
180  trackFitResults.insert(
181  ThreeDSlidingFitResultMap::value_type(pCluster3D, ThreeDSlidingFitResult(pCluster3D, m_halfWindowLayers, layerPitch)));
182  }
183  catch (StatusCodeException &)
184  {
185  std::cout << "EventSlicingTool: ThreeDSlidingFitResult failure for track cluster." << std::endl;
186  }
187  }
188 
189  ThreeDSlidingConeFitResultMap showerConeFitResults;
190 
191  for (const Cluster *const pCluster3D : showerClusters3D)
192  {
193  try
194  {
195  showerConeFitResults.insert(
196  ThreeDSlidingConeFitResultMap::value_type(pCluster3D, ThreeDSlidingConeFitResult(pCluster3D, m_halfWindowLayers, layerPitch)));
197  }
198  catch (StatusCodeException &)
199  {
200  std::cout << "EventSlicingTool: ThreeDSlidingConeFitResult failure for shower cluster." << std::endl;
201  }
202  }
203 
204  ClusterVector sortedClusters3D(trackClusters3D.begin(), trackClusters3D.end());
205  sortedClusters3D.insert(sortedClusters3D.end(), showerClusters3D.begin(), showerClusters3D.end());
206  std::sort(sortedClusters3D.begin(), sortedClusters3D.end(), LArClusterHelper::SortByNHits);
207 
208  ClusterSet usedClusters;
209 
210  for (const Cluster *const pCluster3D : sortedClusters3D)
211  {
212  if (usedClusters.count(pCluster3D))
213  continue;
214 
215  if (pCluster3D->GetNCaloHits() < m_min3DHitsToSeedNewSlice)
216  continue;
217 
218  clusterSliceList.push_back(ClusterVector(1, pCluster3D));
219  usedClusters.insert(pCluster3D);
220 
221  ClusterVector &clusterSlice(clusterSliceList.back());
222  this->CollectAssociatedClusters(pCluster3D, sortedClusters3D, trackFitResults, showerConeFitResults, clusterSlice, usedClusters);
223  }
224 }
static bool SortByNHits(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
Sort clusters by number of hits, then layer span, then inner layer, then position, then pulse-height.
unsigned int m_min3DHitsToSeedNewSlice
The minimum number of hits in a 3D cluster to seed a new slice.
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.
std::unordered_map< const pandora::Cluster *, ThreeDSlidingFitResult > ThreeDSlidingFitResultMap
static float GetWirePitch(const pandora::Pandora &pandora, const pandora::HitType view, const float maxWirePitchDiscrepancy=0.01)
Return the wire pitch.
std::unordered_map< const pandora::Cluster *, ThreeDSlidingConeFitResult > ThreeDSlidingConeFitResultMap
std::vector< art::Ptr< recob::Cluster > > ClusterVector
unsigned int m_halfWindowLayers
The number of layers to use for half-window of sliding fit.
void lar_content::EventSlicingTool::GetKDTreeEntries2D ( const 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
sliceListthe slice list
pointsUto receive the points in the u view
pointsVto receive the points in the v view
pointsWto receive the points in the w view
pointToSliceIndexMapto receive the mapping from points to slice index

Definition at line 596 of file EventSlicingTool.cc.

Referenced by AssignRemainingHitsToSlices().

598 {
599  unsigned int sliceIndex(0);
600 
601  for (const Slice &slice : sliceList)
602  {
603  for (const CaloHit *const pCaloHit : slice.m_caloHitListU)
604  {
605  const CartesianVector *const pPoint(new CartesianVector(pCaloHit->GetPositionVector()));
606  pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pPoint, sliceIndex));
607  pointsU.push_back(pPoint);
608  }
609 
610  for (const CaloHit *const pCaloHit : slice.m_caloHitListV)
611  {
612  const CartesianVector *const pPoint(new CartesianVector(pCaloHit->GetPositionVector()));
613  pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pPoint, sliceIndex));
614  pointsV.push_back(pPoint);
615  }
616 
617  for (const CaloHit *const pCaloHit : slice.m_caloHitListW)
618  {
619  const CartesianVector *const pPoint(new CartesianVector(pCaloHit->GetPositionVector()));
620  pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pPoint, sliceIndex));
621  pointsW.push_back(pPoint);
622  }
623 
624  ++sliceIndex;
625  }
626 }
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
clusterToSliceIndexMapthe 3D cluster to slice index map
pointsUto receive the points in the u view
pointsVto receive the points in the v view
pointsWto receive the points in the w view
pointToSliceIndexMapto receive the mapping from points to slice index

Definition at line 630 of file EventSlicingTool.cc.

References lar_content::LArGeometryHelper::ProjectPosition(), and lar_content::LArClusterHelper::SortByNHits().

Referenced by AssignRemainingHitsToSlices().

632 {
633  ClusterList clusterList;
634  for (const auto &mapEntry : clusterToSliceIndexMap)
635  clusterList.push_back(mapEntry.first);
636  clusterList.sort(LArClusterHelper::SortByNHits);
637 
638  for (const Cluster *const pCluster3D : clusterList)
639  {
640  const unsigned int sliceIndex(clusterToSliceIndexMap.at(pCluster3D));
641 
642  CaloHitList caloHitList;
643  pCluster3D->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
644 
645  for (const CaloHit *const pCaloHit3D : caloHitList)
646  {
647  if (TPC_3D != pCaloHit3D->GetHitType())
648  throw StatusCodeException(STATUS_CODE_FAILURE);
649 
650  const CartesianVector &position3D(pCaloHit3D->GetPositionVector());
651 
652  const CartesianVector *const pProjectionU(
653  new CartesianVector(LArGeometryHelper::ProjectPosition(this->GetPandora(), position3D, TPC_VIEW_U)));
654  const CartesianVector *const pProjectionV(
655  new CartesianVector(LArGeometryHelper::ProjectPosition(this->GetPandora(), position3D, TPC_VIEW_V)));
656  const CartesianVector *const pProjectionW(
657  new CartesianVector(LArGeometryHelper::ProjectPosition(this->GetPandora(), position3D, TPC_VIEW_W)));
658 
659  pointsU.push_back(pProjectionU);
660  pointsV.push_back(pProjectionV);
661  pointsW.push_back(pProjectionW);
662 
663  pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pProjectionU, sliceIndex));
664  pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pProjectionV, sliceIndex));
665  pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pProjectionW, sliceIndex));
666  }
667  }
668 }
static bool SortByNHits(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
Sort clusters by number of hits, then layer span, then inner layer, then position, then pulse-height.
static pandora::CartesianVector ProjectPosition(const pandora::Pandora &pandora, const pandora::CartesianVector &position3D, const pandora::HitType view)
Project 3D position into a given 2D view.
void lar_content::EventSlicingTool::GetRemainingClusters ( const pandora::Algorithm *const  pAlgorithm,
const 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
pAlgorithmthe address of the calling algorithm
clusterListNamesthe hit type to cluster list name map
assignedClustersthe list of 2D clusters with hits assigned to slices
remainingClustersto receive the list of 2D clusters with hits yet to be assigned to slices

Referenced by CopyPfoHitsToSlices(), and RunSlicing().

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
pAlgorithmthe address of the calling algorithm
clusterListNamethe cluster list name
assignedClustersthe list of 2D clusters with hits assigned to slices
remainingClustersto 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
pAlgorithmthe address of the calling algorithm
pfoListNamethe pfo list name
clusters3Dto receive the list of 3D clusters
clusterToPfoMapto receive the mapping from 3D clusters to parent pfos

Definition at line 129 of file EventSlicingTool.cc.

References lar_content::LArPfoHelper::GetThreeDClusterList(), and m_minHitsPer3DCluster.

Referenced by RunSlicing().

131 {
132  const PfoList *pPfoList(nullptr);
133  PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*pAlgorithm, pfoListName, pPfoList));
134 
135  if (!pPfoList || pPfoList->empty())
136  {
137  if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
138  std::cout << "EventSlicingTool: unable to find pfo list " << pfoListName << std::endl;
139 
140  return;
141  }
142 
143  for (const ParticleFlowObject *const pPfo : *pPfoList)
144  {
145  ClusterList pfoClusters3D;
146  LArPfoHelper::GetThreeDClusterList(pPfo, pfoClusters3D);
147 
148  for (const Cluster *const pCluster3D : pfoClusters3D)
149  {
150  if (pCluster3D->GetNCaloHits() < m_minHitsPer3DCluster)
151  continue;
152 
153  if (!clusterToPfoMap.insert(ClusterToPfoMap::value_type(pCluster3D, pPfo)).second)
154  throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
155 
156  if (clusters3D.end() != std::find(clusters3D.begin(), clusters3D.end(), pCluster3D))
157  throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
158 
159  clusters3D.push_back(pCluster3D);
160  }
161  }
162 }
unsigned int m_minHitsPer3DCluster
The minimum number of hits in a 3D cluster to warrant consideration in slicing.
static void GetThreeDClusterList(const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
Get the list of 3D clusters from an input pfo.
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
cluster1the first pointing cluster
cluster2the second pointing cluster
Returns
whether the pointing clusters are declared to be in the same slice

Definition at line 402 of file EventSlicingTool.cc.

References lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), lar_content::LArPointingCluster::Vertex::GetPosition(), lar_content::LArPointingClusterHelper::IsEmission(), m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_minVertexLongitudinalDistance, and m_vertexAngularAllowance.

Referenced by PassPointing().

403 {
404  return (LArPointingClusterHelper::IsEmission(cluster1.GetInnerVertex().GetPosition(), cluster2.GetInnerVertex(),
406  LArPointingClusterHelper::IsEmission(cluster1.GetOuterVertex().GetPosition(), cluster2.GetInnerVertex(),
408  LArPointingClusterHelper::IsEmission(cluster1.GetInnerVertex().GetPosition(), cluster2.GetOuterVertex(),
410  LArPointingClusterHelper::IsEmission(cluster1.GetOuterVertex().GetPosition(), cluster2.GetOuterVertex(),
412  LArPointingClusterHelper::IsEmission(cluster2.GetInnerVertex().GetPosition(), cluster1.GetInnerVertex(),
414  LArPointingClusterHelper::IsEmission(cluster2.GetOuterVertex().GetPosition(), cluster1.GetInnerVertex(),
416  LArPointingClusterHelper::IsEmission(cluster2.GetInnerVertex().GetPosition(), cluster1.GetOuterVertex(),
418  LArPointingClusterHelper::IsEmission(cluster2.GetOuterVertex().GetPosition(), cluster1.GetOuterVertex(),
420 }
float m_maxVertexTransverseDistance
Pointing association check: max transverse distance cut.
static bool IsEmission(const pandora::CartesianVector &parentVertex, const LArPointingCluster::Vertex &daughterVertex, const float minLongitudinalDistance, const float maxLongitudinalDistance, const float maxTransverseDistance, const float angularAllowance)
Whether pointing vertex is emitted from a given position.
float m_maxVertexLongitudinalDistance
Pointing association check: max longitudinal distance cut.
float m_minVertexLongitudinalDistance
Pointing association check: min longitudinal distance cut.
float m_vertexAngularAllowance
Pointing association check: pointing angular allowance in degrees.
bool lar_content::EventSlicingTool::IsNode ( const LArPointingCluster cluster1,
const LArPointingCluster cluster2 
) const
private

Check whether a pair of pointing clusters are nodally associated.

Parameters
cluster1the first pointing cluster
cluster2the second pointing cluster
Returns
whether the pointing clusters are declared to be in the same slice

Definition at line 380 of file EventSlicingTool.cc.

References lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), lar_content::LArPointingCluster::Vertex::GetPosition(), lar_content::LArPointingClusterHelper::IsNode(), m_maxVertexTransverseDistance, and m_minVertexLongitudinalDistance.

Referenced by PassPointing().

381 {
382  return (LArPointingClusterHelper::IsNode(cluster1.GetInnerVertex().GetPosition(), cluster2.GetInnerVertex(),
384  LArPointingClusterHelper::IsNode(cluster1.GetOuterVertex().GetPosition(), cluster2.GetInnerVertex(),
386  LArPointingClusterHelper::IsNode(cluster1.GetInnerVertex().GetPosition(), cluster2.GetOuterVertex(),
388  LArPointingClusterHelper::IsNode(cluster1.GetOuterVertex().GetPosition(), cluster2.GetOuterVertex(),
390  LArPointingClusterHelper::IsNode(cluster2.GetInnerVertex().GetPosition(), cluster1.GetInnerVertex(),
392  LArPointingClusterHelper::IsNode(cluster2.GetOuterVertex().GetPosition(), cluster1.GetInnerVertex(),
394  LArPointingClusterHelper::IsNode(cluster2.GetInnerVertex().GetPosition(), cluster1.GetOuterVertex(),
396  LArPointingClusterHelper::IsNode(cluster2.GetOuterVertex().GetPosition(), cluster1.GetOuterVertex(),
398 }
float m_maxVertexTransverseDistance
Pointing association check: max transverse distance cut.
float m_minVertexLongitudinalDistance
Pointing association check: min longitudinal distance cut.
static bool IsNode(const pandora::CartesianVector &parentVertex, const LArPointingCluster::Vertex &daughterVertex, const float minLongitudinalDistance, const float maxTransverseDistance)
Whether pointing vertex is adjacent to a given position.
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
pCluster2Dthe address of the 2D cluster
kdTreethe kd tree
Returns
the nearest-neighbour point identified by the kd tree

Definition at line 672 of file EventSlicingTool.cc.

References lar_content::KDTreeLinkerAlgo< DATA, DIM >::findNearestNeighbour().

Referenced by AssignRemainingHitsToSlices().

673 {
674  PointList clusterPointList;
675  const PointKDNode2D *pBestResultPoint(nullptr);
676 
677  try
678  {
679  clusterPointList.push_back(new CartesianVector(pCluster2D->GetCentroid(pCluster2D->GetInnerPseudoLayer())));
680  clusterPointList.push_back(new CartesianVector(pCluster2D->GetCentroid(pCluster2D->GetOuterPseudoLayer())));
681  clusterPointList.push_back(new CartesianVector(
682  (pCluster2D->GetCentroid(pCluster2D->GetInnerPseudoLayer()) + pCluster2D->GetCentroid(pCluster2D->GetOuterPseudoLayer())) * 0.5f));
683 
684  float bestDistance(std::numeric_limits<float>::max());
685 
686  for (const CartesianVector *const pClusterPoint : clusterPointList)
687  {
688  const PointKDNode2D *pResultPoint(nullptr);
689  float resultDistance(std::numeric_limits<float>::max());
690  const PointKDNode2D targetPoint(pClusterPoint, pClusterPoint->GetX(), pClusterPoint->GetZ());
691  kdTree.findNearestNeighbour(targetPoint, pResultPoint, resultDistance);
692 
693  if (pResultPoint && (resultDistance < bestDistance))
694  {
695  pBestResultPoint = pResultPoint;
696  bestDistance = resultDistance;
697  }
698  }
699  }
700  catch (...)
701  {
702  std::cout << "EventSlicingTool::MatchClusterToSlice - exception " << std::endl;
703  for (const CartesianVector *const pPoint : clusterPointList)
704  delete pPoint;
705  throw;
706  }
707 
708  for (const CartesianVector *const pPoint : clusterPointList)
709  delete pPoint;
710 
711  return pBestResultPoint;
712 }
KDTreeNodeInfoT< const pandora::CartesianVector *, 2 > PointKDNode2D
std::list< const pandora::CartesianVector * > PointList
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
pClusterInSliceaddress of a cluster already in the slice
pCandidateClusteraddress of the candidate cluster
trackFitResultsthe map of sliding fit results for track candidate clusters
Returns
whether an addition to the cluster slice should be made

Definition at line 258 of file EventSlicingTool.cc.

References CheckClosestApproach(), IsEmission(), and IsNode().

Referenced by CollectAssociatedClusters().

260 {
261  ThreeDSlidingFitResultMap::const_iterator inSliceIter = trackFitResults.find(pClusterInSlice);
262  ThreeDSlidingFitResultMap::const_iterator candidateIter = trackFitResults.find(pCandidateCluster);
263 
264  if ((trackFitResults.end() == inSliceIter) || (trackFitResults.end() == candidateIter))
265  return false;
266 
267  const LArPointingCluster inSlicePointingCluster(inSliceIter->second);
268  const LArPointingCluster candidatePointingCluster(candidateIter->second);
269 
270  if (this->CheckClosestApproach(inSlicePointingCluster, candidatePointingCluster) ||
271  this->IsEmission(inSlicePointingCluster, candidatePointingCluster) || this->IsNode(inSlicePointingCluster, candidatePointingCluster))
272  {
273  return true;
274  }
275 
276  return false;
277 }
intermediate_table::const_iterator const_iterator
bool IsNode(const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
Check whether a pair of pointing clusters are nodally associated.
bool CheckClosestApproach(const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
Check closest approach metrics for a pair of pointing clusters.
bool IsEmission(const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
Check whether a pair of pointing clusters are consistent with an emission.
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
pClusterInSliceaddress of a cluster already in the slice
pCandidateClusteraddress of the candidate cluster
Returns
whether an addition to the cluster slice should be made

Definition at line 281 of file EventSlicingTool.cc.

References m_maxHitSeparationSquared.

Referenced by CollectAssociatedClusters().

282 {
283  for (const auto &orderedList1 : pClusterInSlice->GetOrderedCaloHitList())
284  {
285  for (const CaloHit *const pCaloHit1 : *(orderedList1.second))
286  {
287  const CartesianVector &positionVector1(pCaloHit1->GetPositionVector());
288 
289  for (const auto &orderedList2 : pCandidateCluster->GetOrderedCaloHitList())
290  {
291  for (const CaloHit *const pCaloHit2 : *(orderedList2.second))
292  {
293  if ((positionVector1 - pCaloHit2->GetPositionVector()).GetMagnitudeSquared() < m_maxHitSeparationSquared)
294  return true;
295  }
296  }
297  }
298  }
299 
300  return false;
301 }
float m_maxHitSeparationSquared
Proximity association: max distance allowed between the closest pair of hits.
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
pClusterInSliceaddress of a cluster already in the slice
pCandidateClusteraddress of the candidate cluster
showerConeFitResultsthe map of sliding cone fit results for shower candidate clusters
Returns
whether an addition to the cluster slice should be made

Definition at line 305 of file EventSlicingTool.cc.

References lar_content::CONE_BOTH_DIRECTIONS, f, lar_content::ThreeDSlidingConeFitResult::GetSimpleConeList(), lar_content::ThreeDSlidingConeFitResult::GetSlidingFitResult(), m_coneBoundedFraction1, m_coneBoundedFraction2, m_coneLengthMultiplier, m_coneTanHalfAngle1, m_coneTanHalfAngle2, m_maxConeLength, m_nConeFitLayers, and m_nConeFits.

Referenced by CollectAssociatedClusters().

307 {
308  ThreeDSlidingConeFitResultMap::const_iterator fitIter = showerConeFitResults.find(pConeCluster);
309 
310  if (showerConeFitResults.end() == fitIter)
311  return false;
312 
313  float clusterLength(0.f);
314  SimpleConeList simpleConeList;
315 
316  try
317  {
318  const ThreeDSlidingConeFitResult &slidingConeFitResult3D(fitIter->second);
319  const ThreeDSlidingFitResult &slidingFitResult3D(slidingConeFitResult3D.GetSlidingFitResult());
320  slidingConeFitResult3D.GetSimpleConeList(m_nConeFitLayers, m_nConeFits, CONE_BOTH_DIRECTIONS, simpleConeList);
321  clusterLength = (slidingFitResult3D.GetGlobalMaxLayerPosition() - slidingFitResult3D.GetGlobalMinLayerPosition()).GetMagnitude();
322  }
323  catch (const StatusCodeException &)
324  {
325  return false;
326  }
327 
328  for (const SimpleCone &simpleCone : simpleConeList)
329  {
330  const float coneLength(std::min(m_coneLengthMultiplier * clusterLength, m_maxConeLength));
331 
332  if (simpleCone.GetBoundedHitFraction(pNearbyCluster, coneLength, m_coneTanHalfAngle1) < m_coneBoundedFraction1)
333  continue;
334 
335  if (simpleCone.GetBoundedHitFraction(pNearbyCluster, coneLength, m_coneTanHalfAngle2) < m_coneBoundedFraction2)
336  continue;
337 
338  return true;
339  }
340 
341  return false;
342 }
unsigned int m_nConeFits
The number of cone fits to perform, spread roughly uniformly along the shower length.
unsigned int m_nConeFitLayers
The number of layers over which to sum fitted direction to obtain cone fit.
float m_coneTanHalfAngle2
The cone tan half angle to use when calculating bounded cluster fractions 2.
float m_coneBoundedFraction2
The minimum cluster bounded fraction for association 2.
std::vector< SimpleCone > SimpleConeList
intermediate_table::const_iterator const_iterator
float m_coneTanHalfAngle1
The cone tan half angle to use when calculating bounded cluster fractions 1.
TFile f
Definition: plotHisto.C:6
float m_coneLengthMultiplier
The cone length multiplier to use when calculating bounded cluster fractions.
float m_maxConeLength
The maximum allowed cone length to use when calculating bounded cluster fractions.
float m_coneBoundedFraction1
The minimum cluster bounded fraction for association 1.
StatusCode lar_content::EventSlicingTool::ReadSettings ( const pandora::TiXmlHandle  xmlHandle)
private

Definition at line 731 of file EventSlicingTool.cc.

References m_coneBoundedFraction1, m_coneBoundedFraction2, m_coneLengthMultiplier, m_coneTanHalfAngle1, m_coneTanHalfAngle2, m_halfWindowLayers, m_maxClosestApproach, m_maxConeLength, m_maxHitSeparationSquared, m_maxInterceptDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_min3DHitsToSeedNewSlice, m_minHitsPer3DCluster, m_minVertexLongitudinalDistance, m_nConeFitLayers, m_nConeFits, m_showerPfoListName, m_trackPfoListName, m_use3DProjectionsInHitPickUp, m_usePointingAssociation, m_useProximityAssociation, m_useShowerConeAssociation, and m_vertexAngularAllowance.

732 {
733  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrackPfoListName", m_trackPfoListName));
734 
735  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ShowerPfoListName", m_showerPfoListName));
736 
737  PANDORA_RETURN_RESULT_IF_AND_IF(
738  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinHitsPer3DCluster", m_minHitsPer3DCluster));
739 
740  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
741  XmlHelper::ReadValue(xmlHandle, "Min3DHitsToSeedNewSlice", m_min3DHitsToSeedNewSlice));
742 
743  PANDORA_RETURN_RESULT_IF_AND_IF(
744  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitHalfWindow", m_halfWindowLayers));
745 
746  PANDORA_RETURN_RESULT_IF_AND_IF(
747  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UsePointingAssociation", m_usePointingAssociation));
748 
749  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
750  XmlHelper::ReadValue(xmlHandle, "MinVertexLongitudinalDistance", m_minVertexLongitudinalDistance));
751 
752  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
753  XmlHelper::ReadValue(xmlHandle, "MaxVertexLongitudinalDistance", m_maxVertexLongitudinalDistance));
754 
755  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
756  XmlHelper::ReadValue(xmlHandle, "MaxVertexTransverseDistance", m_maxVertexTransverseDistance));
757 
758  PANDORA_RETURN_RESULT_IF_AND_IF(
759  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexAngularAllowance", m_vertexAngularAllowance));
760 
761  PANDORA_RETURN_RESULT_IF_AND_IF(
762  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxClosestApproach", m_maxClosestApproach));
763 
764  PANDORA_RETURN_RESULT_IF_AND_IF(
765  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxInterceptDistance", m_maxInterceptDistance));
766 
767  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
768  XmlHelper::ReadValue(xmlHandle, "UseProximityAssociation", m_useProximityAssociation));
769 
770  float maxHitSeparation = std::sqrt(m_maxHitSeparationSquared);
771  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxHitSeparation", maxHitSeparation));
772  m_maxHitSeparationSquared = maxHitSeparation * maxHitSeparation;
773 
774  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
775  XmlHelper::ReadValue(xmlHandle, "UseShowerConeAssociation", m_useShowerConeAssociation));
776 
777  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NConeFitLayers", m_nConeFitLayers));
778 
779  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NConeFits", m_nConeFits));
780 
781  PANDORA_RETURN_RESULT_IF_AND_IF(
782  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeLengthMultiplier", m_coneLengthMultiplier));
783 
784  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxConeLength", m_maxConeLength));
785 
786  PANDORA_RETURN_RESULT_IF_AND_IF(
787  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeTanHalfAngle1", m_coneTanHalfAngle1));
788 
789  PANDORA_RETURN_RESULT_IF_AND_IF(
790  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeBoundedFraction1", m_coneBoundedFraction1));
791 
792  PANDORA_RETURN_RESULT_IF_AND_IF(
793  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeTanHalfAngle2", m_coneTanHalfAngle2));
794 
795  PANDORA_RETURN_RESULT_IF_AND_IF(
796  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeBoundedFraction2", m_coneBoundedFraction2));
797 
798  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
799  XmlHelper::ReadValue(xmlHandle, "Use3DProjectionsInHitPickUp", m_use3DProjectionsInHitPickUp));
800 
801  return STATUS_CODE_SUCCESS;
802 }
unsigned int m_nConeFits
The number of cone fits to perform, spread roughly uniformly along the shower length.
unsigned int m_min3DHitsToSeedNewSlice
The minimum number of hits in a 3D cluster to seed a new slice.
float m_maxHitSeparationSquared
Proximity association: max distance allowed between the closest pair of hits.
unsigned int m_nConeFitLayers
The number of layers over which to sum fitted direction to obtain cone fit.
float m_coneTanHalfAngle2
The cone tan half angle to use when calculating bounded cluster fractions 2.
float m_maxVertexTransverseDistance
Pointing association check: max transverse distance cut.
float m_coneBoundedFraction2
The minimum cluster bounded fraction for association 2.
std::string m_showerPfoListName
The name of the input shower pfo list.
unsigned int m_minHitsPer3DCluster
The minimum number of hits in a 3D cluster to warrant consideration in slicing.
float m_coneTanHalfAngle1
The cone tan half angle to use when calculating bounded cluster fractions 1.
float m_maxVertexLongitudinalDistance
Pointing association check: max longitudinal distance cut.
std::string m_trackPfoListName
The name of the input track pfo list.
bool m_useProximityAssociation
Whether to use proximity association.
float m_maxClosestApproach
Pointing association: max distance of closest approach between straight line fits.
bool m_usePointingAssociation
Whether to use pointing association.
float m_coneLengthMultiplier
The cone length multiplier to use when calculating bounded cluster fractions.
float m_maxInterceptDistance
Pointing association: max distance from cluster vertex to point of closest approach.
float m_minVertexLongitudinalDistance
Pointing association check: min longitudinal distance cut.
bool m_use3DProjectionsInHitPickUp
Whether to include 3D cluster projections when assigning remaining clusters to slices.
float m_maxConeLength
The maximum allowed cone length to use when calculating bounded cluster fractions.
bool m_useShowerConeAssociation
Whether to use shower cone association.
float m_vertexAngularAllowance
Pointing association check: pointing angular allowance in degrees.
float m_coneBoundedFraction1
The minimum cluster bounded fraction for association 1.
unsigned int m_halfWindowLayers
The number of layers to use for half-window of sliding fit.
void lar_content::EventSlicingTool::RunSlicing ( const pandora::Algorithm *const  pAlgorithm,
const HitTypeToNameMap caloHitListNames,
const HitTypeToNameMap clusterListNames,
SliceList sliceList 
)
virtual

Run the slicing tool.

Parameters
pAlgorithmaddress of the calling algorithm
caloHitListNamesthe hit type to calo hit list name map
clusterListNamesthe hit type to cluster list name map
sliceListto receive the populated slice list

Implements lar_content::EventSlicingBaseTool.

Definition at line 58 of file EventSlicingTool.cc.

References AssignRemainingHitsToSlices(), CopyAllHitsToSingleSlice(), CopyPfoHitsToSlices(), CreateSlices(), GetClusterSliceList(), GetRemainingClusters(), GetThreeDClusters(), m_showerPfoListName, and m_trackPfoListName.

60 {
61  if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
62  std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
63 
64  ClusterToPfoMap clusterToPfoMap;
65 
66  ClusterList trackClusters3D;
67  this->GetThreeDClusters(pAlgorithm, m_trackPfoListName, trackClusters3D, clusterToPfoMap);
68 
69  ClusterList showerClusters3D;
70  this->GetThreeDClusters(pAlgorithm, m_showerPfoListName, showerClusters3D, clusterToPfoMap);
71 
72  ClusterSliceList clusterSliceList;
73  this->GetClusterSliceList(trackClusters3D, showerClusters3D, clusterSliceList);
74 
75  if (clusterSliceList.size() < 2)
76  {
77  return this->CopyAllHitsToSingleSlice(pAlgorithm, caloHitListNames, sliceList);
78  }
79  else
80  {
81  ClusterToSliceIndexMap clusterToSliceIndexMap;
82  this->CreateSlices(clusterSliceList, sliceList, clusterToSliceIndexMap);
83 
84  ClusterSet assignedClusters;
85  this->CopyPfoHitsToSlices(clusterToSliceIndexMap, clusterToPfoMap, sliceList, assignedClusters);
86 
87  ClusterList remainingClusters;
88  this->GetRemainingClusters(pAlgorithm, clusterListNames, assignedClusters, remainingClusters);
89 
90  this->AssignRemainingHitsToSlices(remainingClusters, clusterToSliceIndexMap, sliceList);
91  }
92 }
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 p...
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.
std::unordered_map< const pandora::Cluster *, const pandora::ParticleFlowObject * > ClusterToPfoMap
std::string m_showerPfoListName
The name of the input shower pfo list.
void CopyPfoHitsToSlices(const ClusterToSliceIndexMap &clusterToSliceIndexMap, const ClusterToPfoMap &clusterToPfoMap, 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 clust...
void CopyAllHitsToSingleSlice(const pandora::Algorithm *const pAlgorithm, const HitTypeToNameMap &caloHitListNames, SliceList &sliceList) const
Copy all the input hits in an event into a single slice.
std::string m_trackPfoListName
The name of the input track pfo list.
std::vector< pandora::ClusterVector > ClusterSliceList
std::unordered_map< const pandora::Cluster *, unsigned int > ClusterToSliceIndexMap
void GetRemainingClusters(const pandora::Algorithm *const pAlgorithm, const HitTypeToNameMap &clusterListNames, const pandora::ClusterSet &assignedClusters, pandora::ClusterList &remainingClusters) const
Get the list of 2D clusters with hits yets to be assigned to slices.
void CreateSlices(const ClusterSliceList &clusterSliceList, SliceList &sliceList, ClusterToSliceIndexMap &clusterToSliceIndexMap) const
Create new slices for each of the groupings of 3D clusters in the provided cluster slice list...
void AssignRemainingHitsToSlices(const pandora::ClusterList &remainingClusters, const ClusterToSliceIndexMap &clusterToSliceIndexMap, SliceList &sliceList) const
Use the list of remaining 2D clusters to assign all remaining 2D hits to existing slices in the slice...
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
pLhsaddress of first point
pRhsaddress of second point

Definition at line 716 of file EventSlicingTool.cc.

Referenced by AssignRemainingHitsToSlices().

717 {
718  const CartesianVector deltaPosition(*pRhs - *pLhs);
719 
720  if (std::fabs(deltaPosition.GetZ()) > std::numeric_limits<float>::epsilon())
721  return (deltaPosition.GetZ() > std::numeric_limits<float>::epsilon());
722 
723  if (std::fabs(deltaPosition.GetX()) > std::numeric_limits<float>::epsilon())
724  return (deltaPosition.GetX() > std::numeric_limits<float>::epsilon());
725 
726  return (deltaPosition.GetY() > std::numeric_limits<float>::epsilon());
727 }

Member Data Documentation

float lar_content::EventSlicingTool::m_coneBoundedFraction1
private

The minimum cluster bounded fraction for association 1.

Definition at line 299 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

float lar_content::EventSlicingTool::m_coneBoundedFraction2
private

The minimum cluster bounded fraction for association 2.

Definition at line 301 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

float lar_content::EventSlicingTool::m_coneLengthMultiplier
private

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

Definition at line 296 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

float lar_content::EventSlicingTool::m_coneTanHalfAngle1
private

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

Definition at line 298 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

float lar_content::EventSlicingTool::m_coneTanHalfAngle2
private

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

Definition at line 300 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

unsigned int lar_content::EventSlicingTool::m_halfWindowLayers
private

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

Definition at line 280 of file EventSlicingTool.h.

Referenced by GetClusterSliceList(), and ReadSettings().

float lar_content::EventSlicingTool::m_maxClosestApproach
private

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

Definition at line 287 of file EventSlicingTool.h.

Referenced by CheckClosestApproach(), and ReadSettings().

float lar_content::EventSlicingTool::m_maxConeLength
private

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

Definition at line 297 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

float lar_content::EventSlicingTool::m_maxHitSeparationSquared
private

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

Definition at line 291 of file EventSlicingTool.h.

Referenced by PassProximity(), and ReadSettings().

float lar_content::EventSlicingTool::m_maxInterceptDistance
private

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

Definition at line 288 of file EventSlicingTool.h.

Referenced by CheckClosestApproach(), and ReadSettings().

float lar_content::EventSlicingTool::m_maxVertexLongitudinalDistance
private

Pointing association check: max longitudinal distance cut.

Definition at line 284 of file EventSlicingTool.h.

Referenced by IsEmission(), and ReadSettings().

float lar_content::EventSlicingTool::m_maxVertexTransverseDistance
private

Pointing association check: max transverse distance cut.

Definition at line 285 of file EventSlicingTool.h.

Referenced by IsEmission(), IsNode(), and ReadSettings().

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 279 of file EventSlicingTool.h.

Referenced by GetClusterSliceList(), and ReadSettings().

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 278 of file EventSlicingTool.h.

Referenced by GetThreeDClusters(), and ReadSettings().

float lar_content::EventSlicingTool::m_minVertexLongitudinalDistance
private

Pointing association check: min longitudinal distance cut.

Definition at line 283 of file EventSlicingTool.h.

Referenced by IsEmission(), IsNode(), and ReadSettings().

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 294 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

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 295 of file EventSlicingTool.h.

Referenced by PassShowerCone(), and ReadSettings().

std::string lar_content::EventSlicingTool::m_showerPfoListName
private

The name of the input shower pfo list.

Definition at line 276 of file EventSlicingTool.h.

Referenced by ReadSettings(), and RunSlicing().

std::string lar_content::EventSlicingTool::m_trackPfoListName
private

The name of the input track pfo list.

Definition at line 275 of file EventSlicingTool.h.

Referenced by ReadSettings(), and RunSlicing().

bool lar_content::EventSlicingTool::m_use3DProjectionsInHitPickUp
private

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

Definition at line 303 of file EventSlicingTool.h.

Referenced by AssignRemainingHitsToSlices(), and ReadSettings().

bool lar_content::EventSlicingTool::m_usePointingAssociation
private

Whether to use pointing association.

Definition at line 282 of file EventSlicingTool.h.

Referenced by CollectAssociatedClusters(), and ReadSettings().

bool lar_content::EventSlicingTool::m_useProximityAssociation
private

Whether to use proximity association.

Definition at line 290 of file EventSlicingTool.h.

Referenced by CollectAssociatedClusters(), and ReadSettings().

bool lar_content::EventSlicingTool::m_useShowerConeAssociation
private

Whether to use shower cone association.

Definition at line 293 of file EventSlicingTool.h.

Referenced by CollectAssociatedClusters(), and ReadSettings().

float lar_content::EventSlicingTool::m_vertexAngularAllowance
private

Pointing association check: pointing angular allowance in degrees.

Definition at line 286 of file EventSlicingTool.h.

Referenced by IsEmission(), and ReadSettings().


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