LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
BoundedClusterMopUpAlgorithm.cc
Go to the documentation of this file.
1 
9 #include "Pandora/AlgorithmHeaders.h"
10 
13 
15 
16 using namespace pandora;
17 
18 namespace lar_content
19 {
20 
21 BoundedClusterMopUpAlgorithm::BoundedClusterMopUpAlgorithm() :
22  m_slidingFitWindow(20),
23  m_showerEdgeMultiplier(1.5f),
24  m_minBoundedFraction(0.5f)
25 {
26 }
27 
28 //------------------------------------------------------------------------------------------------------------------------------------------
29 
30 void BoundedClusterMopUpAlgorithm::ClusterMopUp(const ClusterList &pfoClusters, const ClusterList &remnantClusters) const
31 {
32  ClusterAssociationMap clusterAssociationMap;
33 
34  ClusterVector sortedPfoClusters(pfoClusters.begin(), pfoClusters.end());
35  std::sort(sortedPfoClusters.begin(), sortedPfoClusters.end(), LArClusterHelper::SortByNHits);
36 
37  ClusterVector sortedRemnantClusters(remnantClusters.begin(), remnantClusters.end());
38  std::sort(sortedRemnantClusters.begin(), sortedRemnantClusters.end(), LArClusterHelper::SortByNHits);
39 
40  for (const Cluster *const pPfoCluster : sortedPfoClusters)
41  {
42  CaloHitList clusterHitList;
43  pPfoCluster->GetOrderedCaloHitList().FillCaloHitList(clusterHitList);
44  if (clusterHitList.size() <= 3)
45  continue;
46  try
47  {
48  const float slidingFitPitch(LArGeometryHelper::GetWirePitch(this->GetPandora(), LArClusterHelper::GetClusterHitType(pPfoCluster)));
49  const TwoDSlidingShowerFitResult fitResult(pPfoCluster, m_slidingFitWindow, slidingFitPitch, m_showerEdgeMultiplier);
50 
51  ShowerPositionMap showerPositionMap;
52  const XSampling xSampling(fitResult.GetShowerFitResult());
53  this->GetShowerPositionMap(fitResult, xSampling, showerPositionMap);
54  for (const Cluster *const pRemnantCluster : sortedRemnantClusters)
55  {
56  const float boundedFraction(this->GetBoundedFraction(pRemnantCluster, xSampling, showerPositionMap));
57 
58  if (boundedFraction < m_minBoundedFraction)
59  continue;
60 
61  AssociationDetails &associationDetails(clusterAssociationMap[pRemnantCluster]);
62 
63  if (!associationDetails.insert(AssociationDetails::value_type(pPfoCluster, boundedFraction)).second)
64  throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
65  }
66  }
67  catch (const StatusCodeException &e)
68  {
69  if (e.GetStatusCode() != STATUS_CODE_NOT_INITIALIZED)
70  throw e;
71  }
72  }
73 
74  this->MakeClusterMerges(clusterAssociationMap);
75 }
76 
77 //------------------------------------------------------------------------------------------------------------------------------------------
78 
80  const TwoDSlidingShowerFitResult &fitResult, const XSampling &xSampling, ShowerPositionMap &showerPositionMap) const
81 {
82  for (int n = 0; n <= xSampling.m_nPoints; ++n)
83  {
84  const float x(xSampling.m_minX + (xSampling.m_maxX - xSampling.m_minX) * static_cast<float>(n) / static_cast<float>(xSampling.m_nPoints));
85 
86  FloatVector edgePositions;
87  fitResult.GetShowerEdges(x, false, edgePositions);
88 
89  if (edgePositions.size() < 2)
90  continue;
91 
92  std::sort(edgePositions.begin(), edgePositions.end());
93 
94  try
95  {
96  const int xBin(xSampling.GetBin(x));
97  showerPositionMap.insert(ShowerPositionMap::value_type(xBin, ShowerExtent(x, edgePositions.front(), edgePositions.back())));
98  }
99  catch (StatusCodeException &)
100  {
101  }
102  }
103 }
104 
105 //------------------------------------------------------------------------------------------------------------------------------------------
106 
108  const Cluster *const pCluster, const XSampling &xSampling, const ShowerPositionMap &showerPositionMap) const
109 {
110  if (((xSampling.m_maxX - xSampling.m_minX) < std::numeric_limits<float>::epsilon()) || (0 >= xSampling.m_nPoints) || (0 == pCluster->GetNCaloHits()))
111  {
112  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
113  }
114 
115  unsigned int nMatchedHits(0);
116  const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
117 
118  for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
119  {
120  for (CaloHitList::const_iterator hIter = iter->second->begin(), hIterEnd = iter->second->end(); hIter != hIterEnd; ++hIter)
121  {
122  const CaloHit *const pCaloHit = *hIter;
123  const float x(pCaloHit->GetPositionVector().GetX());
124  const float z(pCaloHit->GetPositionVector().GetZ());
125 
126  try
127  {
128  const int xBin(xSampling.GetBin(x));
129 
130  ShowerPositionMap::const_iterator positionIter = showerPositionMap.find(xBin);
131 
132  if ((showerPositionMap.end() != positionIter) && (z > positionIter->second.GetLowEdgeZ()) && (z < positionIter->second.GetHighEdgeZ()))
133  ++nMatchedHits;
134  }
135  catch (StatusCodeException &)
136  {
137  }
138  }
139  }
140 
141  return (static_cast<float>(nMatchedHits) / static_cast<float>(pCluster->GetNCaloHits()));
142 }
143 
144 //------------------------------------------------------------------------------------------------------------------------------------------
145 //------------------------------------------------------------------------------------------------------------------------------------------
146 
148 {
149  fitResult.GetMinAndMaxX(m_minX, m_maxX);
150 
151  m_nPoints = 1 + fitResult.GetMaxLayer() - fitResult.GetMinLayer();
152 
153  if (((m_maxX - m_minX) < std::numeric_limits<float>::epsilon()) || (0 >= m_nPoints))
154  throw StatusCodeException(STATUS_CODE_NOT_FOUND);
155 }
156 
157 //------------------------------------------------------------------------------------------------------------------------------------------
158 
160 {
161  if (((x - m_minX) < -std::numeric_limits<float>::epsilon()) || ((x - m_maxX) > +std::numeric_limits<float>::epsilon()))
162  throw StatusCodeException(STATUS_CODE_NOT_FOUND);
163 
164  return static_cast<int>(0.5f + static_cast<float>(m_nPoints) * (x - m_minX) / (m_maxX - m_minX));
165 }
166 
167 //------------------------------------------------------------------------------------------------------------------------------------------
168 //------------------------------------------------------------------------------------------------------------------------------------------
169 
170 StatusCode BoundedClusterMopUpAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)
171 {
172  PANDORA_RETURN_RESULT_IF_AND_IF(
173  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitWindow", m_slidingFitWindow));
174 
175  PANDORA_RETURN_RESULT_IF_AND_IF(
176  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowerEdgeMultiplier", m_showerEdgeMultiplier));
177 
178  PANDORA_RETURN_RESULT_IF_AND_IF(
179  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinBoundedFraction", m_minBoundedFraction));
180 
181  return ClusterMopUpBaseAlgorithm::ReadSettings(xmlHandle);
182 }
183 
184 } // namespace lar_content
Float_t x
Definition: compare.C:6
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.
virtual void MakeClusterMerges(const ClusterAssociationMap &clusterAssociationMap) const
Make the cluster merges specified in the cluster association map, using list name information in the ...
void GetMinAndMaxX(float &minX, float &maxX) const
Get the minimum and maximum x coordinates associated with the sliding fit.
XSampling(const TwoDSlidingFitResult &fitResult)
Constructor.
Double_t z
Definition: plot.C:276
const TwoDSlidingFitResult & GetShowerFitResult() const
Get the sliding fit result for the full shower cluster.
Header file for the bounded cluster mop up algorithm class.
void ClusterMopUp(const pandora::ClusterList &pfoClusters, const pandora::ClusterList &remnantClusters) const
Cluster mop up for a single view. This function is responsible for instructing pandora to make cluste...
intermediate_table::const_iterator const_iterator
float m_minBoundedFraction
The minimum cluster bounded fraction for merging.
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
void GetShowerPositionMap(const TwoDSlidingShowerFitResult &fitResult, const XSampling &xSampling, ShowerPositionMap &showerPositionMap) const
Get the shower position map containing high and low edge z positions in bins of x.
std::unordered_map< const pandora::Cluster *, AssociationDetails > ClusterAssociationMap
TFile f
Definition: plotHisto.C:6
Header file for the geometry helper class.
virtual pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
std::map< int, ShowerExtent > ShowerPositionMap
int GetBin(const float x) const
Convert an x position into a sampling bin.
int GetMaxLayer() const
Get the maximum occupied layer in the sliding fit.
int GetMinLayer() const
Get the minimum occupied layer in the sliding fit.
Header file for the cluster helper class.
float m_showerEdgeMultiplier
Artificially tune width of shower envelope so as to make it more/less inclusive.
float GetBoundedFraction(const pandora::Cluster *const pCluster, const XSampling &xSampling, const ShowerPositionMap &showerPositionMap) const
Get the fraction of hits in a cluster bounded by a specified shower position map. ...
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 *, float > AssociationDetails
int m_nPoints
The number of sampling points to be used.
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Char_t n[5]
unsigned int m_slidingFitWindow
The layer window for the sliding linear fits.
std::vector< art::Ptr< recob::Cluster > > ClusterVector
Float_t e
Definition: plot.C:35
second_as<> second
Type of time stored in seconds, in double precision.
Definition: spacetime.h:82
void GetShowerEdges(const float x, const bool widenIfAmbiguity, pandora::FloatVector &edgePositions) const
Get the most appropriate shower edges at a given x coordinate.