#include "ClearTrackFragmentsTool.h"

Inheritance diagram for lar_content::ClearTrackFragmentsTool:

Public Types
typedef ThreeDTrackFragmentsAlgorithm::TensorType	TensorType

typedef std::vector< TensorType::ElementList::const_iterator >	IteratorList

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

bool	Run (ThreeDTrackFragmentsAlgorithm *const pAlgorithm, TensorType &overlapTensor)
	Run the algorithm tool. More...

Private Member Functions
bool	FindTrackFragments (ThreeDTrackFragmentsAlgorithm *const pAlgorithm, const TensorType &overlapTensor) const
	Find suitable matching track fragments in the overlap tensor to use for 3D particle creation, return value indicates whether particles are made. More...

bool	GetAndCheckElementList (const TensorType &overlapTensor, const pandora::Cluster *const pCluster, TensorType::ElementList &elementList) const
	Get the list of elements connected to a given cluster and check its suitability (no ambiguities) More...

bool	CheckForHitAmbiguities (const TensorType::ElementList &elementList) const
	Check the list of hits, stored in tensor elements, for ambiguities. More...

bool	CheckOverlapResult (const TensorType::OverlapResult &overlapResult) const
	Check whether the overlap result passes matched sampling point and number of matched hit checks. More...

void	SelectClearElements (const TensorType::ElementList &elementList, IteratorList &iteratorList) const
	Select a list of clear track-like elements from a set of connected tensor elements. More...

void	ProcessTensorElement (ThreeDTrackFragmentsAlgorithm const pAlgorithm, const TensorType::OverlapResult &overlapResult, pandora::ClusterList &modifiedClusters, pandora::ClusterList &deletedClusters, pandora::ClusterSet &badClusters, const pandora::Cluster &pFragmentCluster) const
	Process a tensor element, reclustering the fragments as required. More...

void	Recluster (ThreeDTrackFragmentsAlgorithm const pAlgorithm, const pandora::Cluster const pCluster, const pandora::CaloHitList &daughterHits, const pandora::CaloHitList &separateHits, pandora::ClusterList &deletedClusters, pandora::ClusterSet &badClusters, const pandora::Cluster *&pFragmentCluster) const
	Rearrange the hits in a cluster from the fragment list, using the Pandora fragmentation mechanism. More...

void	RebuildClusters (ThreeDTrackFragmentsAlgorithm *const pAlgorithm, const pandora::ClusterList &modifiedClusters, pandora::ClusterList &newClusters) const
	Rebuild clusters after fragmentation. More...

void	UpdateTensor (ThreeDTrackFragmentsAlgorithm *const pAlgorithm, const TensorType &overlapTensor, const pandora::ClusterList &clustersToRemoveFromTensor, const pandora::ClusterList &clustersToAddToTensor) const
	Update the tensor following the fragmentation operations performed by this tool. More...

void	GetAffectedKeyClusters (const TensorType &overlapTensor, const pandora::ClusterList &clustersToRemoveFromTensor, pandora::ClusterList &affectedKeyClusters) const
	Get a list of the tensor key clusters for which tensor elements have been impacted by fragmentation operations. More...

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

Private Attributes
float	m_minMatchedSamplingPointFraction
	The minimum fraction of matched sampling points. More...

unsigned int	m_minMatchedHits
	The minimum number of matched calo hits. More...

Detailed Description

ClearTrackFragmentsTool class.

Definition at line 19 of file ClearTrackFragmentsTool.h.

Member Typedef Documentation

typedef std::vector<TensorType::ElementList::const_iterator> lar_content::FragmentTensorTool::IteratorList

inherited

Definition at line 164 of file ThreeDTrackFragmentsAlgorithm.h.

typedef ThreeDTrackFragmentsAlgorithm::TensorType lar_content::FragmentTensorTool::TensorType

inherited

Definition at line 163 of file ThreeDTrackFragmentsAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ClearTrackFragmentsTool::ClearTrackFragmentsTool ( )

Default constructor.

Definition at line 20 of file ClearTrackFragmentsTool.cc.

                                                  :
     m_minMatchedSamplingPointFraction(0.5f),
     m_minMatchedHits(5)
 {
 }

Member Function Documentation

bool lar_content::ClearTrackFragmentsTool::CheckForHitAmbiguities ( const TensorType::ElementList & elementList ) const

private

Check the list of hits, stored in tensor elements, for ambiguities.

Parameters

elementList the element list

Returns: boolean

Definition at line 135 of file ClearTrackFragmentsTool.cc.

 {
     CaloHitList allMatchedHits;
 
     for (TensorType::ElementList::const_iterator eIter = elementList.begin(); eIter != elementList.end(); ++eIter)
     {
         const CaloHitList &fragmentHits(eIter->GetOverlapResult().GetFragmentCaloHitList());
 
         for (CaloHitList::const_iterator hIter = fragmentHits.begin(), hIterEnd = fragmentHits.end(); hIter != hIterEnd; ++hIter)
         {
             if (allMatchedHits.end() != std::find(allMatchedHits.begin(), allMatchedHits.end(), *hIter))
                 return false;
 
             allMatchedHits.push_back(*hIter);
         }
     }
 
     return true;
 }

bool lar_content::ClearTrackFragmentsTool::CheckOverlapResult ( const TensorType::OverlapResult & overlapResult ) const

private

Check whether the overlap result passes matched sampling point and number of matched hit checks.

Parameters

overlapResult the overlap result

Returns: boolean

Definition at line 157 of file ClearTrackFragmentsTool.cc.

References lar_content::FragmentOverlapResult::GetFragmentCaloHitList(), lar_content::TrackOverlapResult::GetMatchedFraction(), m_minMatchedHits, and m_minMatchedSamplingPointFraction.

Referenced by FindTrackFragments().

 {
     // ATTN This method is currently mirrored in ThreeDTrackFragmentsAlgorithm algorithm
 
     if (overlapResult.GetMatchedFraction() < m_minMatchedSamplingPointFraction)
         return false;
 
     if (overlapResult.GetFragmentCaloHitList().size() < m_minMatchedHits)
         return false;
 
     return true;
 }

bool lar_content::ClearTrackFragmentsTool::FindTrackFragments	(	ThreeDTrackFragmentsAlgorithm *const	pAlgorithm,
		const TensorType &	overlapTensor
	)		const

private

Find suitable matching track fragments in the overlap tensor to use for 3D particle creation, return value indicates whether particles are made.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor

Returns: boolean

Definition at line 38 of file ClearTrackFragmentsTool.cc.

References CheckOverlapResult(), lar_content::ThreeDBaseAlgorithm< T >::CreateThreeDParticles(), GetAndCheckElementList(), lar_content::OverlapTensor< T >::GetSortedKeyClusters(), lar_content::ProtoParticle::m_clusterListU, lar_content::ProtoParticle::m_clusterListV, lar_content::ProtoParticle::m_clusterListW, ProcessTensorElement(), RebuildClusters(), SelectClearElements(), and UpdateTensor().

Referenced by Run().

 {
     ClusterVector sortedKeyClusters;
     overlapTensor.GetSortedKeyClusters(sortedKeyClusters);
 
     for (const Cluster *const pKeyCluster : sortedKeyClusters)
     {
         if (!pKeyCluster->IsAvailable())
             continue;
 
         TensorType::ElementList elementList;
         if (!this->GetAndCheckElementList(overlapTensor, pKeyCluster, elementList))
             continue;
 
         IteratorList iteratorList;
         this->SelectClearElements(elementList, iteratorList);
 
         bool particlesMade(false);
         ClusterList deletedClusters, modifiedClusters, clustersToRemoveFromTensor, clustersToAddToTensor;
         ClusterSet badClusters;
 
         for (IteratorList::const_iterator iIter = iteratorList.begin(), iIterEnd = iteratorList.end(); iIter != iIterEnd; ++iIter)
         {
             const TensorType::OverlapResult &overlapResult((*iIter)->GetOverlapResult());
 
             if (!this->CheckOverlapResult(overlapResult))
                 continue;
 
             const Cluster *pFragmentCluster(nullptr);
             this->ProcessTensorElement(pAlgorithm, overlapResult, modifiedClusters, deletedClusters, badClusters, pFragmentCluster);
 
             if (!pFragmentCluster)
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             const HitType fragmentHitType(overlapResult.GetFragmentHitType());
             const Cluster *const pClusterU((TPC_VIEW_U == fragmentHitType) ? pFragmentCluster : (*iIter)->GetClusterU());
             const Cluster *const pClusterV((TPC_VIEW_V == fragmentHitType) ? pFragmentCluster : (*iIter)->GetClusterV());
             const Cluster *const pClusterW((TPC_VIEW_W == fragmentHitType) ? pFragmentCluster : (*iIter)->GetClusterW());
 
             if (!(pClusterU->IsAvailable() && pClusterV->IsAvailable() && pClusterW->IsAvailable()))
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             clustersToRemoveFromTensor.push_back(pClusterU);
             clustersToRemoveFromTensor.push_back(pClusterV);
             clustersToRemoveFromTensor.push_back(pClusterW);
 
             ProtoParticle protoParticle;
             ProtoParticleVector protoParticleVector;
             protoParticle.m_clusterListU.push_back(pClusterU);
             protoParticle.m_clusterListV.push_back(pClusterV);
             protoParticle.m_clusterListW.push_back(pClusterW);
             protoParticleVector.push_back(protoParticle);
             particlesMade |= pAlgorithm->CreateThreeDParticles(protoParticleVector);
         }
 
         clustersToRemoveFromTensor.insert(clustersToRemoveFromTensor.end(), modifiedClusters.begin(), modifiedClusters.end());
         clustersToRemoveFromTensor.insert(clustersToRemoveFromTensor.end(), deletedClusters.begin(), deletedClusters.end());
 
         this->RebuildClusters(pAlgorithm, modifiedClusters, clustersToAddToTensor);
         this->UpdateTensor(pAlgorithm, overlapTensor, clustersToRemoveFromTensor, clustersToAddToTensor);
 
         if (particlesMade)
             return true;
     }
 
     return false;
 }

void lar_content::ClearTrackFragmentsTool::GetAffectedKeyClusters	(	const TensorType &	overlapTensor,
		const pandora::ClusterList &	clustersToRemoveFromTensor,
		pandora::ClusterList &	affectedKeyClusters
	)		const

private

Get a list of the tensor key clusters for which tensor elements have been impacted by fragmentation operations.

Parameters

overlapTensor	the overlap tensor
clustersToRemoveFromTensor	the list of clusters removed from the tensor by fragmentation operations
affectedKeyClusters	to receive the list of tensor key clusters that have been affected by fragmentation operations

Definition at line 394 of file ClearTrackFragmentsTool.cc.

References lar_content::OverlapTensor< T >::begin(), lar_content::OverlapTensor< T >::end(), lar_content::FragmentOverlapResult::GetFragmentClusterList(), lar_content::FragmentOverlapResult::GetFragmentHitType(), and lar_content::LArClusterHelper::SortByNHits().

Referenced by UpdateTensor().

 {
     for (TensorType::const_iterator tIterU = overlapTensor.begin(), tIterUEnd = overlapTensor.end(); tIterU != tIterUEnd; ++tIterU)
     {
         for (TensorType::OverlapMatrix::const_iterator tIterV = tIterU->second.begin(), tIterVEnd = tIterU->second.end(); tIterV != tIterVEnd; ++tIterV)
         {
             for (TensorType::OverlapList::const_iterator tIterW = tIterV->second.begin(), tIterWEnd = tIterV->second.end(); tIterW != tIterWEnd; ++tIterW)
             {
                 const TensorType::OverlapResult &overlapResult(tIterW->second);
                 const HitType fragmentHitType(overlapResult.GetFragmentHitType());
                 const ClusterList &fragmentClusters(overlapResult.GetFragmentClusterList());
 
                 for (ClusterList::const_iterator fIter = fragmentClusters.begin(), fIterEnd = fragmentClusters.end(); fIter != fIterEnd; ++fIter)
                 {
                     if (clustersToRemoveFromTensor.end() == std::find(clustersToRemoveFromTensor.begin(), clustersToRemoveFromTensor.end(), *fIter))
                         continue;
 
                     if ((TPC_VIEW_U != fragmentHitType) && (affectedKeyClusters.end() == std::find(affectedKeyClusters.begin(), affectedKeyClusters.end(), tIterU->first)))
                         affectedKeyClusters.push_back(tIterU->first);
 
                     if ((TPC_VIEW_V != fragmentHitType) && (affectedKeyClusters.end() == std::find(affectedKeyClusters.begin(), affectedKeyClusters.end(), tIterV->first)))
                         affectedKeyClusters.push_back(tIterV->first);
 
                     if ((TPC_VIEW_W != fragmentHitType) && (affectedKeyClusters.end() == std::find(affectedKeyClusters.begin(), affectedKeyClusters.end(), tIterW->first)))
                         affectedKeyClusters.push_back(tIterW->first);
 
                     break;
                 }
             }
         }
     }
 
     affectedKeyClusters.sort(LArClusterHelper::SortByNHits);
 }

bool lar_content::ClearTrackFragmentsTool::GetAndCheckElementList	(	const TensorType &	overlapTensor,
		const pandora::Cluster *const	pCluster,
		TensorType::ElementList &	elementList
	)		const

private

Get the list of elements connected to a given cluster and check its suitability (no ambiguities)

Parameters

overlapTensor	the overlap tensor
pCluster	address of the key cluster
elementList	to receive the element list

Returns: boolean

Definition at line 108 of file ClearTrackFragmentsTool.cc.

References lar_content::OverlapTensor< T >::GetConnectedElements().

Referenced by FindTrackFragments().

 {
     // Get list of connected elements from tensor
     unsigned int nU(0), nV(0), nW(0);
     overlapTensor.GetConnectedElements(pCluster, true, elementList, nU, nV, nW);
 
     // Only allow one fragment hit type
     HitType fragmentHitType(HIT_CUSTOM);
 
     for (TensorType::ElementList::const_iterator eIter = elementList.begin(); eIter != elementList.end(); ++eIter)
     {
         const HitType thisHitType(eIter->GetOverlapResult().GetFragmentHitType());
 
         if (!((TPC_VIEW_U == thisHitType) || (TPC_VIEW_V == thisHitType) || (TPC_VIEW_W == thisHitType)))
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         if (thisHitType != fragmentHitType && HIT_CUSTOM != fragmentHitType)
             return false;
 
         fragmentHitType = thisHitType;
     }
 
     return true;
 }

void lar_content::ClearTrackFragmentsTool::ProcessTensorElement	(	ThreeDTrackFragmentsAlgorithm *const	pAlgorithm,
		const TensorType::OverlapResult &	overlapResult,
		pandora::ClusterList &	modifiedClusters,
		pandora::ClusterList &	deletedClusters,
		pandora::ClusterSet &	badClusters,
		const pandora::Cluster *&	pFragmentCluster
	)		const

private

Process a tensor element, reclustering the fragments as required.

Parameters

pAlgorithm	address of the calling algorithm
overlapResult	the overlap result
modifiedClusters	to receive the list of modified clusters
deletedClusters	to receive the list of deleted clusters
badClusters	the set of clusters that should not be dereferenced
pFragmentCluster	to receive the address of the new fragment cluster

Definition at line 239 of file ClearTrackFragmentsTool.cc.

References lar_content::ThreeDBaseAlgorithm< T >::GetClusterListNameU(), lar_content::ThreeDBaseAlgorithm< T >::GetClusterListNameV(), lar_content::ThreeDBaseAlgorithm< T >::GetClusterListNameW(), lar_content::FragmentOverlapResult::GetFragmentCaloHitList(), lar_content::FragmentOverlapResult::GetFragmentClusterList(), lar_content::FragmentOverlapResult::GetFragmentHitType(), Recluster(), and lar_content::LArClusterHelper::SortByNHits().

Referenced by FindTrackFragments().

 {
     pFragmentCluster = nullptr;
 
     const HitType fragmentHitType(overlapResult.GetFragmentHitType());
     const std::string currentListName((TPC_VIEW_U == fragmentHitType) ? pAlgorithm->GetClusterListNameU() :
         (TPC_VIEW_V == fragmentHitType) ? pAlgorithm->GetClusterListNameV() : pAlgorithm->GetClusterListNameW());
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*pAlgorithm, currentListName));
 
     ClusterList clusterList(overlapResult.GetFragmentClusterList());
     clusterList.sort(LArClusterHelper::SortByNHits);
     const CaloHitSet caloHitSet(overlapResult.GetFragmentCaloHitList().begin(), overlapResult.GetFragmentCaloHitList().end());
 
     for (const Cluster *const pCluster : clusterList)
     {
         if (deletedClusters.end() != std::find(deletedClusters.begin(), deletedClusters.end(), pCluster))
             continue;
 
         if (!pCluster->IsAvailable())
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         CaloHitList clusterHitList;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(clusterHitList);
 
         CaloHitList daughterHits, separateHits;
         for (const CaloHit *const pCaloHit : clusterHitList)
         {
             if (caloHitSet.count(pCaloHit))
             {
                 daughterHits.push_back(pCaloHit);
             }
             else
             {
                 separateHits.push_back(pCaloHit);
             }
         }
 
         if (daughterHits.empty())
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         this->Recluster(pAlgorithm, pCluster, daughterHits, separateHits, deletedClusters, badClusters, pFragmentCluster);
 
         if (badClusters.count(pFragmentCluster))
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         // ATTN Keep track of modified clusters; does not include those for which address has been deleted at any time
         // Note distinction between list of all deletions and the up-to-date list of bad clusters
         ClusterList::iterator modifiedIter(std::find(modifiedClusters.begin(), modifiedClusters.end(), pCluster));
         if (deletedClusters.end() != std::find(deletedClusters.begin(), deletedClusters.end(), pCluster))
         {
             if (modifiedClusters.end() != modifiedIter)
                 modifiedClusters.erase(modifiedIter);
         }
         else if (modifiedClusters.end() == modifiedIter)
         {
             modifiedClusters.push_back(pCluster);
         }
     }
 
     if (!pFragmentCluster)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 }

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

private

Definition at line 432 of file ClearTrackFragmentsTool.cc.

References m_minMatchedHits, and m_minMatchedSamplingPointFraction.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinMatchedSamplingPointFraction", m_minMatchedSamplingPointFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinMatchedHits", m_minMatchedHits));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ClearTrackFragmentsTool::RebuildClusters	(	ThreeDTrackFragmentsAlgorithm *const	pAlgorithm,
		const pandora::ClusterList &	modifiedClusters,
		pandora::ClusterList &	newClusters
	)		const

private

Rebuild clusters after fragmentation.

Parameters

pAlgorithm	address of the calling algorithm
modifiedClusters	the list of clusters to rebuild
newClusters	the list of new clusters

Definition at line 354 of file ClearTrackFragmentsTool.cc.

References lar_content::ThreeDTrackFragmentsAlgorithm::RebuildClusters().

Referenced by FindTrackFragments().

 {
     ClusterList rebuildList;
 
     for (const Cluster *const pCluster : modifiedClusters)
     {
         if (pCluster->IsAvailable())
             rebuildList.push_back(pCluster);
     }
 
     if (!rebuildList.empty())
         pAlgorithm->RebuildClusters(rebuildList, newClusters);
 }

void lar_content::ClearTrackFragmentsTool::Recluster	(	ThreeDTrackFragmentsAlgorithm *const	pAlgorithm,
		const pandora::Cluster *const	pCluster,
		const pandora::CaloHitList &	daughterHits,
		const pandora::CaloHitList &	separateHits,
		pandora::ClusterList &	deletedClusters,
		pandora::ClusterSet &	badClusters,
		const pandora::Cluster *&	pFragmentCluster
	)		const

private

Rearrange the hits in a cluster from the fragment list, using the Pandora fragmentation mechanism.

Parameters

pAlgorithm	address of the calling algorithm
pCluster	address of the input cluster
daughterHits	the full list of hits to place in the new fragment cluster
separateHits	the full list of hits that are not to be placed in the new fragment cluster
deletedClusters	to receive the list of deleted clusters
badClusters	the set of clusters that should not be dereferenced
pFragmentCluster	to receive the address of the new fragment cluster

Definition at line 306 of file ClearTrackFragmentsTool.cc.

Referenced by ProcessTensorElement().

 {
     if (separateHits.empty())
     {
         if (!pFragmentCluster)
         {
             pFragmentCluster = pCluster;
         }
         else
         {
             // ATTN Addresses can be re-used by new allocations, so can't just use list of all cluster deletions; keep track of "bad" clusters
             if (!badClusters.insert(pCluster).second)
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             if (deletedClusters.end() == std::find(deletedClusters.begin(), deletedClusters.end(), pCluster)) deletedClusters.push_back(pCluster);
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*pAlgorithm, pFragmentCluster, pCluster));
         }
     }
     else
     {
         for (const CaloHit *const pCaloHit : daughterHits)
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RemoveFromCluster(*pAlgorithm, pCluster, pCaloHit));
 
         if (!pFragmentCluster)
         {
             const ClusterList *pTemporaryList(nullptr);
             std::string temporaryListName, currentListName;
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentListName<Cluster>(*pAlgorithm, currentListName));
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent<ClusterList>(*pAlgorithm, pTemporaryList, temporaryListName));
 
             PandoraContentApi::Cluster::Parameters hitParameters;
             hitParameters.m_caloHitList = daughterHits;
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*pAlgorithm, hitParameters, pFragmentCluster));
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Cluster>(*pAlgorithm, temporaryListName, currentListName));
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*pAlgorithm, currentListName));
 
             (void) badClusters.erase(pFragmentCluster);
         }
         else
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*pAlgorithm, pFragmentCluster, &daughterHits));
         }
     }
 }

bool lar_content::ClearTrackFragmentsTool::Run	(	ThreeDTrackFragmentsAlgorithm *const	pAlgorithm,
		TensorType &	overlapTensor
	)

virtual

Run the algorithm tool.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor

Returns: whether changes have been made by the tool

Implements lar_content::FragmentTensorTool.

Definition at line 28 of file ClearTrackFragmentsTool.cc.

References FindTrackFragments().

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
        std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     return this->FindTrackFragments(pAlgorithm, overlapTensor);
 }

void lar_content::ClearTrackFragmentsTool::SelectClearElements	(	const TensorType::ElementList &	elementList,
		IteratorList &	iteratorList
	)		const

private

Select a list of clear track-like elements from a set of connected tensor elements.

Parameters

elementList	the full list of connected tensor elements
iteratorList	to receive a list of iterators to long track-like elements

Definition at line 172 of file ClearTrackFragmentsTool.cc.

References f.

Referenced by FindTrackFragments().

 {
     for (TensorType::ElementList::const_iterator eIter1 = elementList.begin(), eIterEnd1 = elementList.end(); eIter1 != eIterEnd1; ++eIter1)
     {
         const CaloHitList &fragmentHits1(eIter1->GetOverlapResult().GetFragmentCaloHitList());
         const float nCaloHits1(static_cast<float>(eIter1->GetClusterU()->GetNCaloHits() + eIter1->GetClusterV()->GetNCaloHits() +
             eIter1->GetClusterW()->GetNCaloHits()));
 
         bool isClearElement(true);
 
         for (TensorType::ElementList::const_iterator eIter2 = elementList.begin(), eIterEnd2 = elementList.end(); eIter2 != eIterEnd2; ++eIter2)
         {
             const CaloHitList &fragmentHits2(eIter2->GetOverlapResult().GetFragmentCaloHitList());
             const float nCaloHits2(static_cast<float>(eIter2->GetClusterU()->GetNCaloHits() + eIter2->GetClusterV()->GetNCaloHits() +
                     eIter2->GetClusterW()->GetNCaloHits()));
 
             const bool commonClusterU(eIter1->GetClusterU() == eIter2->GetClusterU());
             const bool commonClusterV(eIter1->GetClusterV() == eIter2->GetClusterV());
             const bool commonClusterW(eIter1->GetClusterW() == eIter2->GetClusterW());
 
             if (commonClusterU && commonClusterV && commonClusterW)
                 continue;
 
             if (eIter1->GetOverlapResult().GetFragmentHitType() != eIter2->GetOverlapResult().GetFragmentHitType())
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             bool isAmbiguousElement(commonClusterU || commonClusterV || commonClusterW);
 
             if (!isAmbiguousElement)
             {
                 for (CaloHitList::const_iterator hIter2 = fragmentHits2.begin(), hIterEnd2 = fragmentHits2.end(); hIter2 != hIterEnd2; ++hIter2)
                 {
                     if (fragmentHits1.end() != std::find(fragmentHits1.begin(), fragmentHits1.end(), *hIter2))
                     {
                         isAmbiguousElement = true;
                         break;
                     }
                 }
             }
 
             if (isAmbiguousElement && nCaloHits2 > 0.25f * nCaloHits1)
             {
                 isClearElement = false;
                 break;
             }
         }
 
 // --- DEBUG BEGIN ---
 // if(isClearElement)
 // {
 // std::cout << " pU=" << eIter1->GetClusterU() << " pV=" << eIter1->GetClusterV() << " pW=" << eIter1->GetClusterW() << "  (" <<  eIter1->GetClusterU()->IsAvailable() << "," << eIter1->GetClusterV()->IsAvailable() << "," << eIter1->GetClusterW()->IsAvailable() << ")" << std::endl;
 // const ClusterList &clusterList(eIter1->GetOverlapResult().GetFragmentClusterList());
 // for (ClusterList::const_iterator cIter = clusterList.begin(), cIterEnd = clusterList.end(); cIter != cIterEnd; ++cIter)
 // {
 // Cluster *const pCluster = *cIter;
 // std::cout << "   Fragment: " << pCluster << " " << pCluster->IsAvailable() << std::endl;
 // }
 // }
 // --- DEBUG END ---
 
         if (isClearElement)
             iteratorList.push_back(eIter1);
     }
 }

void lar_content::ClearTrackFragmentsTool::UpdateTensor	(	ThreeDTrackFragmentsAlgorithm *const	pAlgorithm,
		const TensorType &	overlapTensor,
		const pandora::ClusterList &	clustersToRemoveFromTensor,
		const pandora::ClusterList &	clustersToAddToTensor
	)		const

private

Update the tensor following the fragmentation operations performed by this tool.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor
clustersToRemoveFromTensor	the list of clusters to remove from the tensor
clustersToAddToTensor	the list of clusters newly made available for future particle reconstruction

Definition at line 370 of file ClearTrackFragmentsTool.cc.

References GetAffectedKeyClusters(), lar_content::ThreeDTracksBaseAlgorithm< T >::SelectInputClusters(), lar_content::ThreeDTrackFragmentsAlgorithm::UpdateForNewCluster(), and lar_content::ThreeDTracksBaseAlgorithm< T >::UpdateUponDeletion().

Referenced by FindTrackFragments().

 {
     for (ClusterList::const_iterator iter = clustersToRemoveFromTensor.begin(), iterEnd = clustersToRemoveFromTensor.end(); iter != iterEnd; ++iter)
         pAlgorithm->UpdateUponDeletion(*iter);
 
     ClusterList newKeyClusters;
     pAlgorithm->SelectInputClusters(&clustersToAddToTensor, newKeyClusters);
 
     for (ClusterList::const_iterator iter = newKeyClusters.begin(), iterEnd = newKeyClusters.end(); iter != iterEnd; ++iter)
         pAlgorithm->UpdateForNewCluster(*iter);
 
     ClusterList affectedKeyClusters;
     this->GetAffectedKeyClusters(overlapTensor, clustersToRemoveFromTensor, affectedKeyClusters);
 
     for (ClusterList::const_iterator iter = affectedKeyClusters.begin(), iterEnd = affectedKeyClusters.end(); iter != iterEnd; ++iter)
         pAlgorithm->UpdateUponDeletion(*iter);
 
     for (ClusterList::const_iterator iter = affectedKeyClusters.begin(), iterEnd = affectedKeyClusters.end(); iter != iterEnd; ++iter)
         pAlgorithm->UpdateForNewCluster(*iter);
 }

Member Data Documentation

unsigned int lar_content::ClearTrackFragmentsTool::m_minMatchedHits

private

The minimum number of matched calo hits.

Definition at line 138 of file ClearTrackFragmentsTool.h.

Referenced by CheckOverlapResult(), and ReadSettings().

float lar_content::ClearTrackFragmentsTool::m_minMatchedSamplingPointFraction

private

The minimum fraction of matched sampling points.

Definition at line 137 of file ClearTrackFragmentsTool.h.

Referenced by CheckOverlapResult(), and ReadSettings().

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

/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArThreeDReco/LArTrackFragments/ClearTrackFragmentsTool.h
/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArThreeDReco/LArTrackFragments/ClearTrackFragmentsTool.cc

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation