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

ParticleRecoveryAlgorithm class. More...

#include "ParticleRecoveryAlgorithm.h"

Inheritance diagram for lar_content::ParticleRecoveryAlgorithm:

Classes

class  SimpleOverlapTensor
 SimpleOverlapTensor class. More...
 

Public Member Functions

 ParticleRecoveryAlgorithm ()
 Default constructor. More...
 

Private Member Functions

pandora::StatusCode Run ()
 
void GetInputClusters (pandora::ClusterList &inputClusterListU, pandora::ClusterList &inputClusterListV, pandora::ClusterList &inputClusterListW) const
 Get the input cluster lists for processing in this algorithm. More...
 
void SelectInputClusters (const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const
 Select a subset of input clusters for processing in this algorithm. More...
 
void StandardClusterSelection (const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const
 Select a subset of input clusters for processing in this algorithm. More...
 
void VertexClusterSelection (const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const
 Select a subset of input clusters nodally associated with the vertices of existing particles. More...
 
void FindOverlaps (const pandora::ClusterList &clusterList1, const pandora::ClusterList &clusterList2, SimpleOverlapTensor &overlapTensor) const
 Find cluster overlaps and record these in the overlap tensor. More...
 
bool IsOverlap (const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2) const
 Whether two clusters overlap convincingly in x. More...
 
void CalculateEffectiveOverlapFractions (const pandora::Cluster *const pCluster1, const float xMin1, const float xMax1, const pandora::Cluster *const pCluster2, const float xMin2, const float xMax2, float &xOverlapFraction1, float &xOverlapFraction2) const
 Calculate effective overlap fractions taking into account gaps. More...
 
void CalculateEffectiveSpan (const pandora::Cluster *const pCluster, const float xMin, const float xMax, float &xMinEff, float &xMaxEff) const
 Calculate effective span for a given clsuter taking gaps into account. More...
 
void ExamineTensor (const SimpleOverlapTensor &overlapTensor) const
 Identify unambiguous cluster overlaps and resolve ambiguous overlaps, creating new track particles. More...
 
bool CheckConsistency (const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW) const
 Whether a trio of clusters are consistent with representing projections of the same 3d trajectory. More...
 
void CreateTrackParticle (const pandora::ClusterList &clusterList) const
 Create and save a track particle containing the provided clusters. More...
 
pandora::StatusCode ReadSettings (const pandora::TiXmlHandle xmlHandle)
 

Private Attributes

pandora::StringVector m_inputClusterListNames
 The list of cluster list names. More...
 
std::string m_outputPfoListName
 The output pfo list name. More...
 
bool m_checkGaps
 Whether to check for gaps in the calculation of the overlap. More...
 
unsigned int m_minClusterCaloHits
 The min number of hits in base cluster selection method. More...
 
float m_minClusterLengthSquared
 The min length (squared) in base cluster selection method. More...
 
float m_minClusterXSpan
 The min x span required in order to consider a cluster. More...
 
bool m_vertexClusterMode
 Whether to demand clusters are associated with vertices of existing particles. More...
 
float m_minVertexLongitudinalDistance
 Vertex association check: min longitudinal distance cut. More...
 
float m_maxVertexTransverseDistance
 Vertex association check: max transverse distance cut. More...
 
float m_minXOverlapFraction
 The min x overlap fraction required in order to id overlapping clusters. More...
 
float m_minXOverlapFractionGaps
 The min x overlap fraction when there are gaps involved. More...
 
float m_sampleStepSize
 The sampling step size used in association checks, units cm. More...
 
unsigned int m_slidingFitHalfWindow
 The half window for the fit sliding result constructor. More...
 
float m_pseudoChi2Cut
 The selection cut on the matched chi2. More...
 

Detailed Description

ParticleRecoveryAlgorithm class.

Definition at line 21 of file ParticleRecoveryAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ParticleRecoveryAlgorithm::ParticleRecoveryAlgorithm ( )

Default constructor.

Definition at line 26 of file ParticleRecoveryAlgorithm.cc.

26  :
27  m_checkGaps(true),
30  m_minClusterXSpan(0.25f),
31  m_vertexClusterMode(false),
36  m_sampleStepSize(0.5f),
39 {
40 }
unsigned int m_minClusterCaloHits
The min number of hits in base cluster selection method.
float m_minClusterLengthSquared
The min length (squared) in base cluster selection method.
float m_maxVertexTransverseDistance
Vertex association check: max transverse distance cut.
float m_minXOverlapFractionGaps
The min x overlap fraction when there are gaps involved.
TFile f
Definition: plotHisto.C:6
float m_minVertexLongitudinalDistance
Vertex association check: min longitudinal distance cut.
float m_minClusterXSpan
The min x span required in order to consider a cluster.
float m_pseudoChi2Cut
The selection cut on the matched chi2.
unsigned int m_slidingFitHalfWindow
The half window for the fit sliding result constructor.
float m_minXOverlapFraction
The min x overlap fraction required in order to id overlapping clusters.
bool m_checkGaps
Whether to check for gaps in the calculation of the overlap.
bool m_vertexClusterMode
Whether to demand clusters are associated with vertices of existing particles.
float m_sampleStepSize
The sampling step size used in association checks, units cm.

Member Function Documentation

void lar_content::ParticleRecoveryAlgorithm::CalculateEffectiveOverlapFractions ( const pandora::Cluster *const  pCluster1,
const float  xMin1,
const float  xMax1,
const pandora::Cluster *const  pCluster2,
const float  xMin2,
const float  xMax2,
float &  xOverlapFraction1,
float &  xOverlapFraction2 
) const
private

Calculate effective overlap fractions taking into account gaps.

Parameters
pCluster1address of the first cluster
xMin1min x value of the first cluster
xMax1max x value of the first cluster
pCluster2address of the second cluster
xMin2min x value of the second cluster
xMax2max x value of the second cluster
xOverlapFraction1to receive the effective overlap fraction for the first cluster
xOverlapFraction2to receive the effective overlap fraction for the second cluster

Definition at line 236 of file ParticleRecoveryAlgorithm.cc.

References CalculateEffectiveSpan(), and f.

Referenced by IsOverlap().

238 {
239  if (PandoraContentApi::GetGeometry(*this)->GetDetectorGapList().empty())
240  return;
241 
242  const float xMin(std::min(xMin1, xMin2));
243  const float xMax(std::max(xMax1, xMax2));
244  float xMinEff1(xMin1), xMaxEff1(xMax1), xMinEff2(xMin2), xMaxEff2(xMax2);
245 
246  this->CalculateEffectiveSpan(pCluster1, xMin, xMax, xMinEff1, xMaxEff1);
247  this->CalculateEffectiveSpan(pCluster2, xMin, xMax, xMinEff2, xMaxEff2);
248 
249  const float effectiveXSpan1(xMaxEff1 - xMinEff1), effectiveXSpan2(xMaxEff2 - xMinEff2);
250  const float effectiveXOverlapSpan(std::min(xMaxEff1, xMaxEff2) - std::max(xMinEff1, xMinEff2));
251 
252  if ((effectiveXSpan1 > std::numeric_limits<float>::epsilon()) && (effectiveXSpan2 > std::numeric_limits<float>::epsilon()))
253  {
254  xOverlapFraction1 = std::min(1.f, (effectiveXOverlapSpan / effectiveXSpan1));
255  xOverlapFraction2 = std::min(1.f, (effectiveXOverlapSpan / effectiveXSpan2));
256  }
257 }
TFile f
Definition: plotHisto.C:6
void CalculateEffectiveSpan(const pandora::Cluster *const pCluster, const float xMin, const float xMax, float &xMinEff, float &xMaxEff) const
Calculate effective span for a given clsuter taking gaps into account.
void lar_content::ParticleRecoveryAlgorithm::CalculateEffectiveSpan ( const pandora::Cluster *const  pCluster,
const float  xMin,
const float  xMax,
float &  xMinEff,
float &  xMaxEff 
) const
private

Calculate effective span for a given clsuter taking gaps into account.

Parameters
pClusteraddress of the cluster
xMinthe min x value above which checks for gaps will be performed
xMaxthe max x value below which checks for gaps will be performed
xMinEffto receive the effective min x value for the cluster, including adjacent gaps
xMaxEffto receive the effective max x value for the cluster, including adjacent gaps

Definition at line 261 of file ParticleRecoveryAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArGeometryHelper::GetWirePitch(), lar_content::LArGeometryHelper::IsXSamplingPointInGap(), m_sampleStepSize, and m_slidingFitHalfWindow.

Referenced by CalculateEffectiveOverlapFractions().

263 {
264  // TODO cache sliding linear fit results and optimise protection against exceptions from TwoDSlidingFitResult and IsXSamplingPointInGap
265  try
266  {
267  const float slidingFitPitch(LArGeometryHelper::GetWirePitch(this->GetPandora(), LArClusterHelper::GetClusterHitType(pCluster)));
268 
269  const TwoDSlidingFitResult slidingFitResult(pCluster, m_slidingFitHalfWindow, slidingFitPitch);
270 
271  const int nSamplingPointsLeft(1 + static_cast<int>((xMinEff - xMin) / m_sampleStepSize));
272  const int nSamplingPointsRight(1 + static_cast<int>((xMax - xMaxEff) / m_sampleStepSize));
273  float dxMin(0.f), dxMax(0.f);
274 
275  for (int iSample = 1; iSample <= nSamplingPointsLeft; ++iSample)
276  {
277  const float xSample(std::max(xMin, xMinEff - static_cast<float>(iSample) * m_sampleStepSize));
278 
279  if (!LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult, m_sampleStepSize))
280  break;
281 
282  dxMin = xMinEff - xSample;
283  }
284 
285  for (int iSample = 1; iSample <= nSamplingPointsRight; ++iSample)
286  {
287  const float xSample(std::min(xMax, xMaxEff + static_cast<float>(iSample) * m_sampleStepSize));
288 
289  if (!LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult, m_sampleStepSize))
290  break;
291 
292  dxMax = xSample - xMaxEff;
293  }
294 
295  xMinEff = xMinEff - dxMin;
296  xMaxEff = xMaxEff + dxMax;
297  }
298  catch (StatusCodeException &)
299  {
300  }
301 }
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
TFile f
Definition: plotHisto.C:6
static float GetWirePitch(const pandora::Pandora &pandora, const pandora::HitType view, const float maxWirePitchDiscrepancy=0.01)
Return the wire pitch.
static bool IsXSamplingPointInGap(const pandora::Pandora &pandora, const float xSample, const TwoDSlidingFitResult &slidingFitResult, const float gapTolerance=0.f)
Whether there is a gap in a cluster (described via its sliding fit result) at a specified x sampling ...
unsigned int m_slidingFitHalfWindow
The half window for the fit sliding result constructor.
float m_sampleStepSize
The sampling step size used in association checks, units cm.
bool lar_content::ParticleRecoveryAlgorithm::CheckConsistency ( const pandora::Cluster *const  pClusterU,
const pandora::Cluster *const  pClusterV,
const pandora::Cluster *const  pClusterW 
) const
private

Whether a trio of clusters are consistent with representing projections of the same 3d trajectory.

Parameters
pClusterUthe address of cluster u
pClusterVthe address of cluster v
pClusterWthe address of cluster w
Returns
boolean

Definition at line 343 of file ParticleRecoveryAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetAverageZ(), m_pseudoChi2Cut, lar_content::LArGeometryHelper::MergeTwoPositions(), and w.

Referenced by ExamineTensor().

344 {
345  // Requirements on X matching
346  float xMinU(0.f), xMinV(0.f), xMinW(0.f), xMaxU(0.f), xMaxV(0.f), xMaxW(0.f);
347  pClusterU->GetClusterSpanX(xMinU, xMaxU);
348  pClusterV->GetClusterSpanX(xMinV, xMaxV);
349  pClusterW->GetClusterSpanX(xMinW, xMaxW);
350 
351  const float xMin(std::max(xMinU, std::max(xMinV, xMinW)));
352  const float xMax(std::min(xMaxU, std::min(xMaxV, xMaxW)));
353  const float xOverlap(xMax - xMin);
354 
355  if (xOverlap < std::numeric_limits<float>::epsilon())
356  return false;
357 
358  // Requirements on 3D matching
359  float u(std::numeric_limits<float>::max()), v(std::numeric_limits<float>::max()), w(std::numeric_limits<float>::max());
360 
361  if ((STATUS_CODE_SUCCESS != LArClusterHelper::GetAverageZ(pClusterU, xMin, xMax, u)) ||
362  (STATUS_CODE_SUCCESS != LArClusterHelper::GetAverageZ(pClusterV, xMin, xMax, v)) ||
363  (STATUS_CODE_SUCCESS != LArClusterHelper::GetAverageZ(pClusterW, xMin, xMax, w)))
364  {
365  return false;
366  }
367 
368  const float uv2w(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), TPC_VIEW_U, TPC_VIEW_V, u, v));
369  const float vw2u(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), TPC_VIEW_V, TPC_VIEW_W, v, w));
370  const float wu2v(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), TPC_VIEW_W, TPC_VIEW_U, w, u));
371 
372  const float pseudoChi2(((u - vw2u) * (u - vw2u) + (v - wu2v) * (v - wu2v) + (w - uv2w) * (w - uv2w)) / 3.f);
373 
374  if (pseudoChi2 > m_pseudoChi2Cut)
375  return false;
376 
377  return true;
378 }
static pandora::StatusCode GetAverageZ(const pandora::Cluster *const pCluster, const float xmin, const float xmax, float &averageZ)
Get average Z positions of the calo hits in a cluster in range xmin to xmax.
TFile f
Definition: plotHisto.C:6
static float MergeTwoPositions(const pandora::Pandora &pandora, const pandora::HitType view1, const pandora::HitType view2, const float position1, const float position2)
Merge two views (U,V) to give a third view (Z).
float m_pseudoChi2Cut
The selection cut on the matched chi2.
Float_t w
Definition: plot.C:20
void lar_content::ParticleRecoveryAlgorithm::CreateTrackParticle ( const pandora::ClusterList &  clusterList) const
private

Create and save a track particle containing the provided clusters.

Parameters
clusterListthe cluster list

Definition at line 382 of file ParticleRecoveryAlgorithm.cc.

References f, and m_outputPfoListName.

Referenced by ExamineTensor().

383 {
384  if (clusterList.size() < 2)
385  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
386 
387  const PfoList *pPfoList = NULL;
388  std::string pfoListName;
389  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pPfoList, pfoListName));
390 
391  // TODO Correct these placeholder parameters
392  PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;
393  pfoParameters.m_particleId = MU_MINUS;
394  pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());
395  pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());
396  pfoParameters.m_energy = 0.f;
397  pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);
398  pfoParameters.m_clusterList = clusterList;
399 
400  const ParticleFlowObject *pPfo(NULL);
401  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pPfo));
402 
403  if (!pPfoList->empty())
404  {
405  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_outputPfoListName));
406  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Pfo>(*this, m_outputPfoListName));
407  }
408 }
TFile f
Definition: plotHisto.C:6
std::string m_outputPfoListName
The output pfo list name.
void lar_content::ParticleRecoveryAlgorithm::ExamineTensor ( const SimpleOverlapTensor overlapTensor) const
private

Identify unambiguous cluster overlaps and resolve ambiguous overlaps, creating new track particles.

Parameters
overlapTensorthe overlap tensor

Definition at line 305 of file ParticleRecoveryAlgorithm.cc.

References CheckConsistency(), CreateTrackParticle(), lar_content::ParticleRecoveryAlgorithm::SimpleOverlapTensor::GetConnectedElements(), lar_content::ParticleRecoveryAlgorithm::SimpleOverlapTensor::GetKeyClusters(), and lar_content::LArClusterHelper::SortByNHits().

Referenced by Run().

306 {
307  ClusterVector sortedKeyClusters(overlapTensor.GetKeyClusters().begin(), overlapTensor.GetKeyClusters().end());
308  std::sort(sortedKeyClusters.begin(), sortedKeyClusters.end(), LArClusterHelper::SortByNHits);
309 
310  for (const Cluster *const pKeyCluster : sortedKeyClusters)
311  {
312  ClusterList clusterListU, clusterListV, clusterListW;
313 
314  overlapTensor.GetConnectedElements(pKeyCluster, true, clusterListU, clusterListV, clusterListW);
315  const unsigned int nU(clusterListU.size()), nV(clusterListV.size()), nW(clusterListW.size());
316 
317  if ((0 == nU * nV) && (0 == nV * nW) && (0 == nW * nU))
318  continue;
319 
320  ClusterList clusterListAll;
321  clusterListAll.insert(clusterListAll.end(), clusterListU.begin(), clusterListU.end());
322  clusterListAll.insert(clusterListAll.end(), clusterListV.begin(), clusterListV.end());
323  clusterListAll.insert(clusterListAll.end(), clusterListW.begin(), clusterListW.end());
324 
325  if ((1 == nU * nV * nW) && this->CheckConsistency(*(clusterListU.begin()), *(clusterListV.begin()), *(clusterListW.begin())))
326  {
327  this->CreateTrackParticle(clusterListAll);
328  }
329  else if ((0 == nU * nV * nW) && ((1 == nU && 1 == nV) || (1 == nV && 1 == nW) || (1 == nW && 1 == nU)))
330  {
331  this->CreateTrackParticle(clusterListAll);
332  }
333  else
334  {
335  // TODO - check here whether there is a gap in the 2 in one view when 1:2:0
336  // May later choose to resolve simple ambiguities, e.g. of form nU:nV:nW == 1:2:0
337  }
338  }
339 }
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.
bool CheckConsistency(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW) const
Whether a trio of clusters are consistent with representing projections of the same 3d trajectory...
void CreateTrackParticle(const pandora::ClusterList &clusterList) const
Create and save a track particle containing the provided clusters.
std::vector< art::Ptr< recob::Cluster > > ClusterVector
void lar_content::ParticleRecoveryAlgorithm::FindOverlaps ( const pandora::ClusterList &  clusterList1,
const pandora::ClusterList &  clusterList2,
SimpleOverlapTensor overlapTensor 
) const
private

Find cluster overlaps and record these in the overlap tensor.

Parameters
clusterList1the first cluster list
clusterList2the second cluster list
overlapTensorthe overlap tensor

Definition at line 190 of file ParticleRecoveryAlgorithm.cc.

References lar_content::ParticleRecoveryAlgorithm::SimpleOverlapTensor::AddAssociation(), and IsOverlap().

Referenced by Run().

191 {
192  for (ClusterList::const_iterator iter1 = clusterList1.begin(), iter1End = clusterList1.end(); iter1 != iter1End; ++iter1)
193  {
194  for (ClusterList::const_iterator iter2 = clusterList2.begin(), iter2End = clusterList2.end(); iter2 != iter2End; ++iter2)
195  {
196  if (this->IsOverlap(*iter1, *iter2))
197  overlapTensor.AddAssociation(*iter1, *iter2);
198  }
199  }
200 }
intermediate_table::const_iterator const_iterator
bool IsOverlap(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2) const
Whether two clusters overlap convincingly in x.
void lar_content::ParticleRecoveryAlgorithm::GetInputClusters ( pandora::ClusterList &  inputClusterListU,
pandora::ClusterList &  inputClusterListV,
pandora::ClusterList &  inputClusterListW 
) const
private

Get the input cluster lists for processing in this algorithm.

Parameters
inputClusterListUto receive the list of clusters in the u view
inputClusterListUto receive the list of clusters in the v view
inputClusterListUto receive the list of clusters in the w view

Definition at line 65 of file ParticleRecoveryAlgorithm.cc.

References lar_content::LArClusterHelper::GetClusterHitType(), and m_inputClusterListNames.

Referenced by Run().

66 {
67  for (StringVector::const_iterator iter = m_inputClusterListNames.begin(), iterEnd = m_inputClusterListNames.end(); iter != iterEnd; ++iter)
68  {
69  const ClusterList *pClusterList(NULL);
70  PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, *iter, pClusterList));
71 
72  if (!pClusterList || pClusterList->empty())
73  {
74  if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
75  std::cout << "ParticleRecoveryAlgorithm: unable to find cluster list " << *iter << std::endl;
76 
77  continue;
78  }
79 
80  for (ClusterList::const_iterator cIter = pClusterList->begin(), cIterEnd = pClusterList->end(); cIter != cIterEnd; ++cIter)
81  {
82  const Cluster *const pCluster(*cIter);
83  const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
84 
85  if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
86  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
87 
88  ClusterList &clusterList((TPC_VIEW_U == hitType) ? inputClusterListU
89  : (TPC_VIEW_V == hitType) ? inputClusterListV
90  : inputClusterListW);
91  clusterList.push_back(pCluster);
92  }
93  }
94 }
pandora::StringVector m_inputClusterListNames
The list of cluster list names.
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.
HitType
Definition: HitType.h:12
bool lar_content::ParticleRecoveryAlgorithm::IsOverlap ( const pandora::Cluster *const  pCluster1,
const pandora::Cluster *const  pCluster2 
) const
private

Whether two clusters overlap convincingly in x.

Parameters
pCluster1address of the first cluster
pCluster2address of the second cluster

Definition at line 204 of file ParticleRecoveryAlgorithm.cc.

References CalculateEffectiveOverlapFractions(), f, lar_content::LArClusterHelper::GetClusterHitType(), m_checkGaps, and m_minXOverlapFraction.

Referenced by FindOverlaps().

205 {
207  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
208 
209  if ((0 == pCluster1->GetNCaloHits()) || (0 == pCluster2->GetNCaloHits()))
210  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
211 
212  float xMin1(0.f), xMax1(0.f), xMin2(0.f), xMax2(0.f);
213  pCluster1->GetClusterSpanX(xMin1, xMax1);
214  pCluster2->GetClusterSpanX(xMin2, xMax2);
215 
216  const float xSpan1(xMax1 - xMin1), xSpan2(xMax2 - xMin2);
217 
218  if ((xSpan1 < std::numeric_limits<float>::epsilon()) || (xSpan2 < std::numeric_limits<float>::epsilon()))
219  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
220 
221  const float xOverlap(std::min(xMax1, xMax2) - std::max(xMin1, xMin2));
222 
223  float xOverlapFraction1(xOverlap / xSpan1), xOverlapFraction2(xOverlap / xSpan2);
224 
225  if (m_checkGaps)
226  this->CalculateEffectiveOverlapFractions(pCluster1, xMin1, xMax1, pCluster2, xMin2, xMax2, xOverlapFraction1, xOverlapFraction2);
227 
228  if ((xOverlapFraction1 < m_minXOverlapFraction) || (xOverlapFraction2 < m_minXOverlapFraction))
229  return false;
230 
231  return true;
232 }
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
TFile f
Definition: plotHisto.C:6
void CalculateEffectiveOverlapFractions(const pandora::Cluster *const pCluster1, const float xMin1, const float xMax1, const pandora::Cluster *const pCluster2, const float xMin2, const float xMax2, float &xOverlapFraction1, float &xOverlapFraction2) const
Calculate effective overlap fractions taking into account gaps.
float m_minXOverlapFraction
The min x overlap fraction required in order to id overlapping clusters.
bool m_checkGaps
Whether to check for gaps in the calculation of the overlap.
StatusCode lar_content::ParticleRecoveryAlgorithm::ReadSettings ( const pandora::TiXmlHandle  xmlHandle)
private

Definition at line 484 of file ParticleRecoveryAlgorithm.cc.

References m_checkGaps, m_inputClusterListNames, m_maxVertexTransverseDistance, m_minClusterCaloHits, m_minClusterLengthSquared, m_minClusterXSpan, m_minVertexLongitudinalDistance, m_minXOverlapFraction, m_minXOverlapFractionGaps, m_outputPfoListName, m_pseudoChi2Cut, m_sampleStepSize, m_slidingFitHalfWindow, and m_vertexClusterMode.

485 {
486  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));
487  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputPfoListName", m_outputPfoListName));
488 
489  PANDORA_RETURN_RESULT_IF_AND_IF(
490  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterCaloHits", m_minClusterCaloHits));
491 
492  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CheckGaps", m_checkGaps));
493 
494  float minClusterLength = std::sqrt(m_minClusterLengthSquared);
495  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLength", minClusterLength));
496  m_minClusterLengthSquared = minClusterLength * minClusterLength;
497 
498  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterXSpan", m_minClusterXSpan));
499 
500  PANDORA_RETURN_RESULT_IF_AND_IF(
501  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexClusterMode", m_vertexClusterMode));
502 
503  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
504  XmlHelper::ReadValue(xmlHandle, "MinVertexLongitudinalDistance", m_minVertexLongitudinalDistance));
505 
506  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
507  XmlHelper::ReadValue(xmlHandle, "MaxVertexTransverseDistance", m_maxVertexTransverseDistance));
508 
509  PANDORA_RETURN_RESULT_IF_AND_IF(
510  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinXOverlapFraction", m_minXOverlapFraction));
511 
512  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
513  XmlHelper::ReadValue(xmlHandle, "MinXOverlapFractionGaps", m_minXOverlapFractionGaps));
514 
515  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SampleStepSize", m_sampleStepSize));
516 
517  if (m_sampleStepSize < std::numeric_limits<float>::epsilon())
518  {
519  std::cout << "ParticleRecoveryAlgorithm: Invalid value for SampleStepSize " << m_sampleStepSize << std::endl;
520  throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
521  }
522 
523  PANDORA_RETURN_RESULT_IF_AND_IF(
524  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitHalfWindow", m_slidingFitHalfWindow));
525 
526  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PseudoChi2Cut", m_pseudoChi2Cut));
527 
528  return STATUS_CODE_SUCCESS;
529 }
pandora::StringVector m_inputClusterListNames
The list of cluster list names.
unsigned int m_minClusterCaloHits
The min number of hits in base cluster selection method.
float m_minClusterLengthSquared
The min length (squared) in base cluster selection method.
float m_maxVertexTransverseDistance
Vertex association check: max transverse distance cut.
float m_minXOverlapFractionGaps
The min x overlap fraction when there are gaps involved.
float m_minVertexLongitudinalDistance
Vertex association check: min longitudinal distance cut.
float m_minClusterXSpan
The min x span required in order to consider a cluster.
float m_pseudoChi2Cut
The selection cut on the matched chi2.
unsigned int m_slidingFitHalfWindow
The half window for the fit sliding result constructor.
float m_minXOverlapFraction
The min x overlap fraction required in order to id overlapping clusters.
bool m_checkGaps
Whether to check for gaps in the calculation of the overlap.
bool m_vertexClusterMode
Whether to demand clusters are associated with vertices of existing particles.
std::string m_outputPfoListName
The output pfo list name.
float m_sampleStepSize
The sampling step size used in association checks, units cm.
StatusCode lar_content::ParticleRecoveryAlgorithm::Run ( )
private

Definition at line 44 of file ParticleRecoveryAlgorithm.cc.

References ExamineTensor(), FindOverlaps(), GetInputClusters(), and SelectInputClusters().

45 {
46  ClusterList inputClusterListU, inputClusterListV, inputClusterListW;
47  this->GetInputClusters(inputClusterListU, inputClusterListV, inputClusterListW);
48 
49  ClusterList selectedClusterListU, selectedClusterListV, selectedClusterListW;
50  this->SelectInputClusters(inputClusterListU, selectedClusterListU);
51  this->SelectInputClusters(inputClusterListV, selectedClusterListV);
52  this->SelectInputClusters(inputClusterListW, selectedClusterListW);
53 
54  SimpleOverlapTensor overlapTensor;
55  this->FindOverlaps(selectedClusterListU, selectedClusterListV, overlapTensor);
56  this->FindOverlaps(selectedClusterListV, selectedClusterListW, overlapTensor);
57  this->FindOverlaps(selectedClusterListW, selectedClusterListU, overlapTensor);
58  this->ExamineTensor(overlapTensor);
59 
60  return STATUS_CODE_SUCCESS;
61 }
void GetInputClusters(pandora::ClusterList &inputClusterListU, pandora::ClusterList &inputClusterListV, pandora::ClusterList &inputClusterListW) const
Get the input cluster lists for processing in this algorithm.
void ExamineTensor(const SimpleOverlapTensor &overlapTensor) const
Identify unambiguous cluster overlaps and resolve ambiguous overlaps, creating new track particles...
void SelectInputClusters(const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const
Select a subset of input clusters for processing in this algorithm.
void FindOverlaps(const pandora::ClusterList &clusterList1, const pandora::ClusterList &clusterList2, SimpleOverlapTensor &overlapTensor) const
Find cluster overlaps and record these in the overlap tensor.
void lar_content::ParticleRecoveryAlgorithm::SelectInputClusters ( const pandora::ClusterList &  inputClusterList,
pandora::ClusterList &  selectedClusterList 
) const
private

Select a subset of input clusters for processing in this algorithm.

Parameters
inputClusterListthe input cluster list
selectedClusterListto receive the selected cluster list

Definition at line 98 of file ParticleRecoveryAlgorithm.cc.

References m_vertexClusterMode, StandardClusterSelection(), and VertexClusterSelection().

Referenced by Run().

99 {
101  {
102  ClusterList vertexClusterList;
103  this->VertexClusterSelection(inputClusterList, vertexClusterList);
104  this->StandardClusterSelection(vertexClusterList, selectedClusterList);
105  }
106  else
107  {
108  this->StandardClusterSelection(inputClusterList, selectedClusterList);
109  }
110 }
bool m_vertexClusterMode
Whether to demand clusters are associated with vertices of existing particles.
void StandardClusterSelection(const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const
Select a subset of input clusters for processing in this algorithm.
void VertexClusterSelection(const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const
Select a subset of input clusters nodally associated with the vertices of existing particles...
void lar_content::ParticleRecoveryAlgorithm::StandardClusterSelection ( const pandora::ClusterList &  inputClusterList,
pandora::ClusterList &  selectedClusterList 
) const
private

Select a subset of input clusters for processing in this algorithm.

Parameters
inputClusterListthe input cluster list
selectedClusterListto receive the selected cluster list

Definition at line 114 of file ParticleRecoveryAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetLengthSquared(), m_minClusterCaloHits, m_minClusterLengthSquared, and m_minClusterXSpan.

Referenced by SelectInputClusters().

115 {
116  for (ClusterList::const_iterator iter = inputClusterList.begin(), iterEnd = inputClusterList.end(); iter != iterEnd; ++iter)
117  {
118  const Cluster *const pCluster = *iter;
119 
120  if (!pCluster->IsAvailable())
121  continue;
122 
123  if (pCluster->GetNCaloHits() < m_minClusterCaloHits)
124  continue;
125 
127  continue;
128 
129  float xMin(0.f), xMax(0.f);
130  pCluster->GetClusterSpanX(xMin, xMax);
131 
132  if ((xMax - xMin) < m_minClusterXSpan)
133  continue;
134 
135  selectedClusterList.push_back(pCluster);
136  }
137 }
unsigned int m_minClusterCaloHits
The min number of hits in base cluster selection method.
float m_minClusterLengthSquared
The min length (squared) in base cluster selection method.
intermediate_table::const_iterator const_iterator
TFile f
Definition: plotHisto.C:6
float m_minClusterXSpan
The min x span required in order to consider a cluster.
static float GetLengthSquared(const pandora::Cluster *const pCluster)
Get length squared of cluster.
void lar_content::ParticleRecoveryAlgorithm::VertexClusterSelection ( const pandora::ClusterList &  inputClusterList,
pandora::ClusterList &  selectedClusterList 
) const
private

Select a subset of input clusters nodally associated with the vertices of existing particles.

Parameters
inputClusterListthe input cluster list
selectedClusterListto receive the selected cluster list

Definition at line 141 of file ParticleRecoveryAlgorithm.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 SelectInputClusters().

142 {
143  CartesianPointVector vertexList;
144 
145  for (ClusterList::const_iterator iter = inputClusterList.begin(), iterEnd = inputClusterList.end(); iter != iterEnd; ++iter)
146  {
147  try
148  {
149  if (!(*iter)->IsAvailable())
150  {
151  const LArPointingCluster pointingCluster(*iter);
152  vertexList.push_back(pointingCluster.GetInnerVertex().GetPosition());
153  vertexList.push_back(pointingCluster.GetOuterVertex().GetPosition());
154  }
155  }
156  catch (StatusCodeException &)
157  {
158  }
159  }
160 
161  for (ClusterList::const_iterator iter = inputClusterList.begin(), iterEnd = inputClusterList.end(); iter != iterEnd; ++iter)
162  {
163  try
164  {
165  const Cluster *const pCluster = *iter;
166 
167  if (!pCluster->IsAvailable())
168  continue;
169 
170  const LArPointingCluster pointingCluster(pCluster);
171 
172  for (CartesianPointVector::const_iterator vIter = vertexList.begin(), vIterEnd = vertexList.end(); vIter != vIterEnd; ++vIter)
173  {
176  {
177  selectedClusterList.push_back(pCluster);
178  break;
179  }
180  }
181  }
182  catch (StatusCodeException &)
183  {
184  }
185  }
186 }
float m_maxVertexTransverseDistance
Vertex association check: max transverse distance cut.
intermediate_table::const_iterator const_iterator
float m_minVertexLongitudinalDistance
Vertex 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.

Member Data Documentation

bool lar_content::ParticleRecoveryAlgorithm::m_checkGaps
private

Whether to check for gaps in the calculation of the overlap.

Definition at line 180 of file ParticleRecoveryAlgorithm.h.

Referenced by IsOverlap(), and ReadSettings().

pandora::StringVector lar_content::ParticleRecoveryAlgorithm::m_inputClusterListNames
private

The list of cluster list names.

Definition at line 177 of file ParticleRecoveryAlgorithm.h.

Referenced by GetInputClusters(), and ReadSettings().

float lar_content::ParticleRecoveryAlgorithm::m_maxVertexTransverseDistance
private

Vertex association check: max transverse distance cut.

Definition at line 188 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings(), and VertexClusterSelection().

unsigned int lar_content::ParticleRecoveryAlgorithm::m_minClusterCaloHits
private

The min number of hits in base cluster selection method.

Definition at line 182 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings(), and StandardClusterSelection().

float lar_content::ParticleRecoveryAlgorithm::m_minClusterLengthSquared
private

The min length (squared) in base cluster selection method.

Definition at line 183 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings(), and StandardClusterSelection().

float lar_content::ParticleRecoveryAlgorithm::m_minClusterXSpan
private

The min x span required in order to consider a cluster.

Definition at line 184 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings(), and StandardClusterSelection().

float lar_content::ParticleRecoveryAlgorithm::m_minVertexLongitudinalDistance
private

Vertex association check: min longitudinal distance cut.

Definition at line 187 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings(), and VertexClusterSelection().

float lar_content::ParticleRecoveryAlgorithm::m_minXOverlapFraction
private

The min x overlap fraction required in order to id overlapping clusters.

Definition at line 190 of file ParticleRecoveryAlgorithm.h.

Referenced by IsOverlap(), and ReadSettings().

float lar_content::ParticleRecoveryAlgorithm::m_minXOverlapFractionGaps
private

The min x overlap fraction when there are gaps involved.

Definition at line 191 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings().

std::string lar_content::ParticleRecoveryAlgorithm::m_outputPfoListName
private

The output pfo list name.

Definition at line 178 of file ParticleRecoveryAlgorithm.h.

Referenced by CreateTrackParticle(), and ReadSettings().

float lar_content::ParticleRecoveryAlgorithm::m_pseudoChi2Cut
private

The selection cut on the matched chi2.

Definition at line 194 of file ParticleRecoveryAlgorithm.h.

Referenced by CheckConsistency(), and ReadSettings().

float lar_content::ParticleRecoveryAlgorithm::m_sampleStepSize
private

The sampling step size used in association checks, units cm.

Definition at line 192 of file ParticleRecoveryAlgorithm.h.

Referenced by CalculateEffectiveSpan(), and ReadSettings().

unsigned int lar_content::ParticleRecoveryAlgorithm::m_slidingFitHalfWindow
private

The half window for the fit sliding result constructor.

Definition at line 193 of file ParticleRecoveryAlgorithm.h.

Referenced by CalculateEffectiveSpan(), and ReadSettings().

bool lar_content::ParticleRecoveryAlgorithm::m_vertexClusterMode
private

Whether to demand clusters are associated with vertices of existing particles.

Definition at line 186 of file ParticleRecoveryAlgorithm.h.

Referenced by ReadSettings(), and SelectInputClusters().


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