LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
CutClusterCharacterisationAlgorithm.cc
Go to the documentation of this file.
1 
9 #include "Pandora/AlgorithmHeaders.h"
10 
13 
16 
18 
19 using namespace pandora;
20 
21 namespace lar_content
22 {
23 
24 CutClusterCharacterisationAlgorithm::CutClusterCharacterisationAlgorithm() :
25  m_slidingFitWindow(5),
26  m_slidingShowerFitWindow(10),
27  m_minCaloHitsCut(6),
28  m_maxShowerLengthCut(80.f),
29  m_pathLengthRatioCut(1.005f),
30  m_rTWidthRatioCut(0.05f),
31  m_vertexDistanceRatioCut(0.5f),
32  m_showerWidthRatioCut(0.35f)
33 {
34 }
35 
36 //------------------------------------------------------------------------------------------------------------------------------------------
37 
38 float CutClusterCharacterisationAlgorithm::GetVertexDistance(const Algorithm *const pAlgorithm, const Cluster *const pCluster)
39 {
40  const VertexList *pVertexList = nullptr;
41  (void)PandoraContentApi::GetCurrentList(*pAlgorithm, pVertexList);
42 
43  if (!pVertexList || (pVertexList->size() != 1) || (VERTEX_3D != pVertexList->front()->GetVertexType()))
44  return -1.f;
45 
46  const Vertex *const pVertex(pVertexList->front());
47  const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
48 
49  const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(pAlgorithm->GetPandora(), pVertex->GetPosition(), hitType));
50  return LArClusterHelper::GetClosestDistance(vertexPosition2D, pCluster);
51 }
52 
53 //------------------------------------------------------------------------------------------------------------------------------------------
54 
55 float CutClusterCharacterisationAlgorithm::GetShowerFitWidth(const Algorithm *const pAlgorithm, const Cluster *const pCluster, const unsigned int showerFitWindow)
56 {
57  try
58  {
59  const TwoDSlidingShowerFitResult showerFitResult(pCluster, showerFitWindow, LArGeometryHelper::GetWireZPitch(pAlgorithm->GetPandora()));
60  const LayerFitResultMap &layerFitResultMapS(showerFitResult.GetShowerFitResult().GetLayerFitResultMap());
61  const LayerFitResultMap &layerFitResultMapP(showerFitResult.GetPositiveEdgeFitResult().GetLayerFitResultMap());
62  const LayerFitResultMap &layerFitResultMapN(showerFitResult.GetNegativeEdgeFitResult().GetLayerFitResultMap());
63 
64  if (!layerFitResultMapS.empty())
65  {
66  float showerFitWidth(0.f);
67 
68  for (const auto &mapEntryS : layerFitResultMapS)
69  {
70  LayerFitResultMap::const_iterator iterP = layerFitResultMapP.find(mapEntryS.first);
71  LayerFitResultMap::const_iterator iterN = layerFitResultMapN.find(mapEntryS.first);
72 
73  if ((layerFitResultMapP.end() != iterP) && (layerFitResultMapN.end() != iterN))
74  showerFitWidth += std::fabs(iterP->second.GetFitT() - iterN->second.GetFitT());
75  }
76 
77  return showerFitWidth;
78  }
79  }
80  catch (const StatusCodeException &)
81  {
82  }
83 
84  return -1.f;
85 }
86 
87 //------------------------------------------------------------------------------------------------------------------------------------------
88 
89 bool CutClusterCharacterisationAlgorithm::IsClearTrack(const Cluster *const pCluster) const
90 {
91  if (pCluster->GetNCaloHits() < m_minCaloHitsCut)
92  return false;
93 
94  float straightLineLength(-1.f), integratedPathLength(-1.f);
95  float rTMin(+std::numeric_limits<float>::max()), rTMax(-std::numeric_limits<float>::max());
96 
97  try
98  {
99  const TwoDSlidingFitResult slidingFitResult(pCluster, m_slidingFitWindow, LArGeometryHelper::GetWireZPitch(this->GetPandora()));
100  const CartesianVector globalMinLayerPosition(slidingFitResult.GetGlobalMinLayerPosition());
101  straightLineLength = (slidingFitResult.GetGlobalMaxLayerPosition() - globalMinLayerPosition).GetMagnitude();
102 
103  integratedPathLength = 0.f;
104  CartesianVector previousFitPosition(globalMinLayerPosition);
105 
106  for (const auto &mapEntry : slidingFitResult.GetLayerFitResultMap())
107  {
108  rTMin = std::min(rTMin, static_cast<float>(mapEntry.second.GetFitT()));
109  rTMax = std::max(rTMax, static_cast<float>(mapEntry.second.GetFitT()));
110 
111  CartesianVector thisFitPosition(0.f, 0.f, 0.f);
112  slidingFitResult.GetGlobalPosition(mapEntry.second.GetL(), mapEntry.second.GetFitT(), thisFitPosition);
113  integratedPathLength += (thisFitPosition - previousFitPosition).GetMagnitude();
114  previousFitPosition = thisFitPosition;
115  }
116  }
117  catch (const StatusCodeException &)
118  {
119  }
120 
121  if (straightLineLength < std::numeric_limits<float>::epsilon())
122  return false;
123 
124  if (straightLineLength > m_maxShowerLengthCut)
125  return true;
126 
127  if ((integratedPathLength < std::numeric_limits<float>::epsilon()) || (integratedPathLength / straightLineLength > m_pathLengthRatioCut))
128  return false;
129 
130  if ((rTMax - rTMin) / straightLineLength > m_rTWidthRatioCut)
131  return false;
132 
133  const float vertexDistance(CutClusterCharacterisationAlgorithm::GetVertexDistance(this, pCluster));
134 
135  if ((vertexDistance > std::numeric_limits<float>::epsilon()) && ((vertexDistance / straightLineLength) > m_vertexDistanceRatioCut))
136  return false;
137 
138  const float showerFitWidth(CutClusterCharacterisationAlgorithm::GetShowerFitWidth(this, pCluster, m_slidingShowerFitWindow));
139 
140  if ((showerFitWidth < std::numeric_limits<float>::epsilon()) || ((showerFitWidth / straightLineLength) > m_showerWidthRatioCut))
141  return false;
142 
143  return true;
144 }
145 
146 //------------------------------------------------------------------------------------------------------------------------------------------
147 
148 StatusCode CutClusterCharacterisationAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)
149 {
150  PANDORA_RETURN_RESULT_IF_AND_IF(
151  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitWindow", m_slidingFitWindow));
152 
153  PANDORA_RETURN_RESULT_IF_AND_IF(
154  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingShowerFitWindow", m_slidingShowerFitWindow));
155 
156  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitsCut", m_minCaloHitsCut));
157 
158  PANDORA_RETURN_RESULT_IF_AND_IF(
159  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxShowerLengthCut", m_maxShowerLengthCut));
160 
161  PANDORA_RETURN_RESULT_IF_AND_IF(
162  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PathLengthRatioCut", m_pathLengthRatioCut));
163 
164  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "RTWidthRatioCut", m_rTWidthRatioCut));
165 
166  PANDORA_RETURN_RESULT_IF_AND_IF(
167  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexDistanceRatioCut", m_vertexDistanceRatioCut));
168 
169  PANDORA_RETURN_RESULT_IF_AND_IF(
170  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowerWidthRatioCut", m_showerWidthRatioCut));
171 
173 }
174 
175 } // namespace lar_content
Header file for the lar two dimensional sliding shower fit result class.
Header file for the cut based cluster characterisation algorithm class.
virtual bool IsClearTrack(const pandora::Cluster *const pCluster) const
Whether cluster is identified as a clear track.
static float GetVertexDistance(const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster)
Get the distance between the interaction vertex (if present in the current vertex list) and a provide...
const TwoDSlidingFitResult & GetShowerFitResult() const
Get the sliding fit result for the full shower cluster.
static pandora::CartesianVector ProjectPosition(const pandora::Pandora &pandora, const pandora::CartesianVector &position3D, const pandora::HitType view)
Project 3D position into a given 2D view.
intermediate_table::const_iterator const_iterator
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
static float GetWireZPitch(const pandora::Pandora &pandora, const float maxWirePitchDiscrepancy=0.01)
Return the wire pitch.
float m_rTWidthRatioCut
The maximum ratio of transverse fit position width to straight line length to qualify as a track...
float m_vertexDistanceRatioCut
The maximum ratio of vertex separation to straight line length to qualify as a track.
TFile f
Definition: plotHisto.C:6
Header file for the geometry helper class.
float m_maxShowerLengthCut
The maximum cluster length to qualify as a shower.
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Header file for the cluster helper class.
unsigned int m_minCaloHitsCut
The minimum number of calo hits to qualify as a track.
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Header file for the lar two dimensional sliding fit result class.
std::map< int, LayerFitResult > LayerFitResultMap
pandora::CartesianVector GetGlobalMinLayerPosition() const
Get global position corresponding to the fit result in minimum fit layer.
unsigned int m_slidingShowerFitWindow
The layer window for the sliding shower fits.
const TwoDSlidingFitResult & GetPositiveEdgeFitResult() const
Get the sliding fit result for the positive shower edge.
unsigned int m_slidingFitWindow
The layer window for the sliding linear fits.
const LayerFitResultMap & GetLayerFitResultMap() const
Get the layer fit result map.
const TwoDSlidingFitResult & GetNegativeEdgeFitResult() const
Get the sliding fit result for the negative shower edge.
HitType
Definition: HitType.h:12
float m_showerWidthRatioCut
The maximum ratio of shower fit width to straight line length to qualify as a track.
void GetGlobalPosition(const float rL, const float rT, pandora::CartesianVector &position) const
Get global coordinates for given sliding linear fit coordinates.
boost::graph_traits< ModuleGraph >::vertex_descriptor Vertex
Definition: ModuleGraph.h:25
static float GetShowerFitWidth(const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster, const unsigned int showerFitWindow)
Get a measure of the width of a cluster, using a sliding shower fit result.
std::list< Vertex > VertexList
Definition: DCEL.h:169
pandora::CartesianVector GetGlobalMaxLayerPosition() const
Get global position corresponding to the fit result in maximum fit layer.
float m_pathLengthRatioCut
The maximum ratio of path length to straight line length to qualify as a track.
static float GetClosestDistance(const pandora::ClusterList &clusterList1, const pandora::ClusterList &clusterList2)
Get closest distance between clusters in a pair of cluster lists.