TrackClusterCreationAlgorithm class. More...

#include <TrackClusterCreationAlgorithm.h>

Inheritance diagram for lar_content::TrackClusterCreationAlgorithm:

Classes
class	HitAssociation
	HitAssociation class. More...

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

Private Types
typedef std::unordered_map < const pandora::CaloHit *, HitAssociation >	HitAssociationMap

typedef std::unordered_map < const pandora::CaloHit , const pandora::CaloHit >	HitJoinMap

typedef std::unordered_map < const pandora::CaloHit , const pandora::Cluster >	HitToClusterMap

Private Member Functions
pandora::StatusCode	Run ()

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

pandora::StatusCode	FilterCaloHits (const pandora::CaloHitList *const pCaloHitList, pandora::OrderedCaloHitList &selectedCaloHitList, pandora::OrderedCaloHitList &rejectedCaloHitList) const
	Filter out low pulse height hits in close proximity to high pulse height hits. More...

pandora::StatusCode	AddFilteredCaloHits (const pandora::OrderedCaloHitList &selectedCaloHitList, const pandora::OrderedCaloHitList &rejectedCaloHitList, HitToClusterMap &hitToClusterMap) const
	Merge previously filtered hits back into their associated clusters. More...

void	MakePrimaryAssociations (const pandora::OrderedCaloHitList &orderedCaloHitList, HitAssociationMap &forwardHitAssociationMap, HitAssociationMap &backwardHitAssociationMap) const
	Control primary association formation. More...

void	MakeSecondaryAssociations (const pandora::OrderedCaloHitList &orderedCaloHitList, HitAssociationMap &forwardHitAssociationMap, HitAssociationMap &backwardHitAssociationMap) const
	Control secondary association formation. More...

void	IdentifyJoins (const pandora::OrderedCaloHitList &orderedCaloHitList, const HitAssociationMap &forwardHitAssociationMap, const HitAssociationMap &backwardHitAssociationMap, HitJoinMap &hitJoinMap) const
	Identify final hit joins for use in cluster formation. More...

void	CreateClusters (const pandora::OrderedCaloHitList &orderedCaloHitList, const HitJoinMap &hitJoinMap, HitToClusterMap &hitToClusterMap) const
	Final cluster formation. More...

void	CreatePrimaryAssociation (const pandora::CaloHit const pCaloHitI, const pandora::CaloHit const pCaloHitJ, HitAssociationMap &forwardHitAssociationMap, HitAssociationMap &backwardHitAssociationMap) const
	Create primary association if appropriate, hitI<->hitJ. More...

void	CreateSecondaryAssociation (const pandora::CaloHit const pCaloHitI, const pandora::CaloHit const pCaloHitJ, HitAssociationMap &forwardHitAssociationMap, HitAssociationMap &backwardHitAssociationMap) const
	Create secondary association if appropriate, hitI<->hitJ. More...

const pandora::CaloHit *	GetJoinHit (const pandora::CaloHit *const pCaloHit, const HitAssociationMap &hitAssociationMapI, const HitAssociationMap &hitAssociationMapJ) const
	Get hit to join by tracing associations via map I, checking via map J. More...

const pandora::CaloHit *	TraceHitAssociation (const pandora::CaloHit *const pCaloHit, const HitAssociationMap &hitAssociationMapI, const HitAssociationMap &hitAssociationMapJ, unsigned int &nSteps) const
	Get last hit obtained by tracing associations via map I, checking via map J. More...

Private Attributes
bool	m_mergeBackFilteredHits
	Merge rejected hits into their associated clusters. More...

unsigned int	m_maxGapLayers
	Maximum number of layers for a gap. More...

float	m_maxCaloHitSeparationSquared
	Square of maximum calo hit separation. More...

float	m_minCaloHitSeparationSquared
	Square of minimum calo hit separation. More...

float	m_closeSeparationSquared
	Length scale (squared) for close hit separation. More...

Detailed Description

TrackClusterCreationAlgorithm class.

Definition at line 21 of file TrackClusterCreationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::CaloHit *, HitAssociation> lar_content::TrackClusterCreationAlgorithm::HitAssociationMap

private

Definition at line 87 of file TrackClusterCreationAlgorithm.h.

typedef std::unordered_map<const pandora::CaloHit *, const pandora::CaloHit *> lar_content::TrackClusterCreationAlgorithm::HitJoinMap

private

Definition at line 88 of file TrackClusterCreationAlgorithm.h.

typedef std::unordered_map<const pandora::CaloHit *, const pandora::Cluster *> lar_content::TrackClusterCreationAlgorithm::HitToClusterMap

private

Definition at line 89 of file TrackClusterCreationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TrackClusterCreationAlgorithm::TrackClusterCreationAlgorithm ( )

Default constructor.

Definition at line 20 of file TrackClusterCreationAlgorithm.cc.

                                                              :
     m_mergeBackFilteredHits(true),
     m_maxGapLayers(2),
     m_maxCaloHitSeparationSquared(1.3f * 1.3f),
     m_minCaloHitSeparationSquared(0.4f * 0.4f),
     m_closeSeparationSquared(0.9f * 0.9f)
 {
 }

Member Function Documentation

StatusCode lar_content::TrackClusterCreationAlgorithm::AddFilteredCaloHits	(	const pandora::OrderedCaloHitList &	selectedCaloHitList,
		const pandora::OrderedCaloHitList &	rejectedCaloHitList,
		HitToClusterMap &	hitToClusterMap
	)		const

private

Merge previously filtered hits back into their associated clusters.

Parameters

selectedCaloHitList	the ordered list of selected hits
rejectedCaloHitList	the ordered list of rejected hits
hitToClusterMap	the mapping between hits and their clusters

Definition at line 107 of file TrackClusterCreationAlgorithm.cc.

 {
     for (OrderedCaloHitList::const_iterator iter = rejectedCaloHitList.begin(), iterEnd = rejectedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         CaloHitList *pCaloHitList = NULL;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, selectedCaloHitList.GetCaloHitsInPseudoLayer(iter->first, pCaloHitList));
 
         CaloHitSet unavailableHits;
 
         CaloHitVector inputAvailableHits(iter->second->begin(), iter->second->end());
         std::sort(inputAvailableHits.begin(), inputAvailableHits.end(), LArClusterHelper::SortHitsByPosition);
 
         CaloHitVector clusteredHits(pCaloHitList->begin(), pCaloHitList->end());
         std::sort(clusteredHits.begin(), clusteredHits.end(), LArClusterHelper::SortHitsByPosition);
 
         bool carryOn(true);
 
         while (carryOn)
         {
             carryOn = false;
             CaloHitVector newClusteredHits;
 
             for (const CaloHit *const pCaloHitI : inputAvailableHits)
             {
                 if (unavailableHits.count(pCaloHitI))
                     continue;
 
                 if (hitToClusterMap.end() != hitToClusterMap.find(pCaloHitI))
                     continue;
 
                 const CaloHit *pClosestHit = NULL;
                 float closestSeparationSquared(m_minCaloHitSeparationSquared);
 
                 for (const CaloHit *const pCaloHitJ : clusteredHits)
                 {
                     if (pCaloHitI->GetMipEquivalentEnergy() > pCaloHitJ->GetMipEquivalentEnergy())
                         continue;
 
                     const float separationSquared((pCaloHitI->GetPositionVector() - pCaloHitJ->GetPositionVector()).GetMagnitudeSquared());
 
                     if (separationSquared < closestSeparationSquared)
                     {
                         closestSeparationSquared = separationSquared;
                         pClosestHit = pCaloHitJ;
                     }
                 }
 
                 if (!pClosestHit)
                     continue;
 
                 HitToClusterMap::const_iterator mapIter = hitToClusterMap.find(pClosestHit);
 
                 if (hitToClusterMap.end() == mapIter)
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 const Cluster *const pCluster = mapIter->second;
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pCluster, pCaloHitI));
                 (void)hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHitI, pCluster));
 
                 newClusteredHits.push_back(pCaloHitI);
                 carryOn = true;
             }
 
             for (const CaloHit *const pCaloHit : newClusteredHits)
             {
                 clusteredHits.push_back(pCaloHit);
                 unavailableHits.insert(pCaloHit);
             }
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::TrackClusterCreationAlgorithm::CreateClusters	(	const pandora::OrderedCaloHitList &	orderedCaloHitList,
		const HitJoinMap &	hitJoinMap,
		HitToClusterMap &	hitToClusterMap
	)		const

private

Final cluster formation.

Parameters

orderedCaloHitList	the ordered calo hit list
hitJoinMap	the hit join map
hitToClusterMap	the mapping between hits and their clusters

Definition at line 276 of file TrackClusterCreationAlgorithm.cc.

 {
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         CaloHitVector caloHits(iter->second->begin(), iter->second->end());
         std::sort(caloHits.begin(), caloHits.end(), LArClusterHelper::SortHitsByPosition);
 
         for (const CaloHit *const pCaloHit : caloHits)
         {
             const Cluster *pCluster = NULL;
 
             HitToClusterMap::const_iterator mapIter = hitToClusterMap.find(pCaloHit);
 
             if (hitToClusterMap.end() == mapIter)
             {
                 PandoraContentApi::Cluster::Parameters parameters;
                 parameters.m_caloHitList.push_back(pCaloHit);
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pCluster));
                 hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHit, pCluster));
             }
             else
             {
                 pCluster = mapIter->second;
             }
 
             HitJoinMap::const_iterator joinIter = hitJoinMap.find(pCaloHit);
 
             if (hitJoinMap.end() == joinIter)
                 continue;
 
             if (hitToClusterMap.end() != hitToClusterMap.find(joinIter->second))
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pCluster, joinIter->second));
             hitToClusterMap.insert(HitToClusterMap::value_type(joinIter->second, pCluster));
         }
     }
 }

void lar_content::TrackClusterCreationAlgorithm::CreatePrimaryAssociation	(	const pandora::CaloHit *const	pCaloHitI,
		const pandora::CaloHit *const	pCaloHitJ,
		HitAssociationMap &	forwardHitAssociationMap,
		HitAssociationMap &	backwardHitAssociationMap
	)		const

private

Create primary association if appropriate, hitI<->hitJ.

Parameters

pCaloHitI	address of calo hit I
pCaloHitJ	address of calo hit J
forwardHitAssociationMap	the forward hit association map
backwardHitAssociationMap	the backward hit association map

Definition at line 318 of file TrackClusterCreationAlgorithm.cc.

 {
     const float distanceSquared((pCaloHitJ->GetPositionVector() - pCaloHitI->GetPositionVector()).GetMagnitudeSquared());
 
     if (distanceSquared > m_maxCaloHitSeparationSquared)
         return;
 
     HitAssociationMap::iterator forwardIter = forwardHitAssociationMap.find(pCaloHitI);
 
     if (forwardHitAssociationMap.end() == forwardIter)
     {
         forwardHitAssociationMap.insert(HitAssociationMap::value_type(pCaloHitI, HitAssociation(pCaloHitJ, distanceSquared)));
     }
     else if (distanceSquared < forwardIter->second.GetPrimaryDistanceSquared())
     {
         forwardIter->second = HitAssociation(pCaloHitJ, distanceSquared);
     }
 
     HitAssociationMap::iterator backwardIter = backwardHitAssociationMap.find(pCaloHitJ);
 
     if (backwardHitAssociationMap.end() == backwardIter)
     {
         backwardHitAssociationMap.insert(HitAssociationMap::value_type(pCaloHitJ, HitAssociation(pCaloHitI, distanceSquared)));
     }
     else if (distanceSquared < backwardIter->second.GetPrimaryDistanceSquared())
     {
         backwardIter->second = HitAssociation(pCaloHitI, distanceSquared);
     }
 }

void lar_content::TrackClusterCreationAlgorithm::CreateSecondaryAssociation	(	const pandora::CaloHit *const	pCaloHitI,
		const pandora::CaloHit *const	pCaloHitJ,
		HitAssociationMap &	forwardHitAssociationMap,
		HitAssociationMap &	backwardHitAssociationMap
	)		const

private

Create secondary association if appropriate, hitI<->hitJ.

Parameters

pCaloHitI	address of calo hit I
pCaloHitJ	address of calo hit J
forwardHitAssociationMap	the forward hit association map
backwardHitAssociationMap	the backward hit association map

Definition at line 351 of file TrackClusterCreationAlgorithm.cc.

 {
     HitAssociationMap::iterator forwardIter = forwardHitAssociationMap.find(pCaloHitI);
     HitAssociationMap::iterator backwardIter = backwardHitAssociationMap.find(pCaloHitJ);
 
     if ((forwardHitAssociationMap.end() == forwardIter) || (backwardHitAssociationMap.end() == backwardIter))
         return;
 
     HitAssociation &forwardAssociation(forwardIter->second);
     HitAssociation &backwardAssociation(backwardIter->second);
 
     if ((forwardAssociation.GetPrimaryTarget() != pCaloHitJ) && (backwardAssociation.GetPrimaryTarget() == pCaloHitI))
     {
         if ((backwardAssociation.GetPrimaryDistanceSquared() < forwardAssociation.GetSecondaryDistanceSquared()) &&
             (backwardAssociation.GetPrimaryDistanceSquared() < m_closeSeparationSquared))
         {
             forwardAssociation.SetSecondaryTarget(pCaloHitJ, backwardAssociation.GetPrimaryDistanceSquared());
         }
     }
 
     if ((backwardAssociation.GetPrimaryTarget() != pCaloHitI) && (forwardAssociation.GetPrimaryTarget() == pCaloHitJ))
     {
         if ((forwardAssociation.GetPrimaryDistanceSquared() < backwardAssociation.GetSecondaryDistanceSquared()) &&
             (forwardAssociation.GetPrimaryDistanceSquared() < m_closeSeparationSquared))
         {
             backwardAssociation.SetSecondaryTarget(pCaloHitI, forwardAssociation.GetPrimaryDistanceSquared());
         }
     }
 }

StatusCode lar_content::TrackClusterCreationAlgorithm::FilterCaloHits	(	const pandora::CaloHitList *const	pCaloHitList,
		pandora::OrderedCaloHitList &	selectedCaloHitList,
		pandora::OrderedCaloHitList &	rejectedCaloHitList
	)		const

private

Filter out low pulse height hits in close proximity to high pulse height hits.

Parameters

pCaloHitList	input hit list
selectedCaloHitList	the output selected list of selected hits
rejectedCaloHitList	the output rejected list of rejected hits

Definition at line 58 of file TrackClusterCreationAlgorithm.cc.

 {
     CaloHitList availableHitList;
 
     for (const CaloHit *const pCaloHit : *pCaloHitList)
     {
         if (PandoraContentApi::IsAvailable(*this, pCaloHit))
             availableHitList.push_back(pCaloHit);
     }
 
     if (availableHitList.empty())
         return STATUS_CODE_SUCCESS;
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, selectedCaloHitList.Add(availableHitList));
 
     for (OrderedCaloHitList::const_iterator iter = selectedCaloHitList.begin(), iterEnd = selectedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         CaloHitVector caloHits(iter->second->begin(), iter->second->end());
         std::sort(caloHits.begin(), caloHits.end(), LArClusterHelper::SortHitsByPosition);
 
         for (const CaloHit *const pCaloHitI : caloHits)
         {
             bool useCaloHit(true);
 
             for (const CaloHit *const pCaloHitJ : caloHits)
             {
                 if (pCaloHitI == pCaloHitJ)
                     continue;
 
                 if ((pCaloHitI->GetMipEquivalentEnergy() < pCaloHitJ->GetMipEquivalentEnergy()) &&
                     ((pCaloHitI->GetPositionVector() - pCaloHitJ->GetPositionVector()).GetMagnitudeSquared() < m_minCaloHitSeparationSquared))
                 {
                     useCaloHit = false;
                     break;
                 }
             }
 
             if (!useCaloHit)
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, rejectedCaloHitList.Add(pCaloHitI));
         }
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, selectedCaloHitList.Remove(rejectedCaloHitList));
     return STATUS_CODE_SUCCESS;
 }

const CaloHit * lar_content::TrackClusterCreationAlgorithm::GetJoinHit	(	const pandora::CaloHit *const	pCaloHit,
		const HitAssociationMap &	hitAssociationMapI,
		const HitAssociationMap &	hitAssociationMapJ
	)		const

private

Get hit to join by tracing associations via map I, checking via map J.

Parameters

pCaloHit	the initial calo hit
hitAssociationMapI	hit association map I
hitAssociationMapJ	hit association map J

Returns: the hit to join

Definition at line 384 of file TrackClusterCreationAlgorithm.cc.

 {
     HitAssociationMap::const_iterator iterI = hitAssociationMapI.find(pCaloHit);
 
     if (hitAssociationMapI.end() == iterI)
         return NULL;
 
     const CaloHit *const pPrimaryTarget = iterI->second.GetPrimaryTarget();
     const CaloHit *const pSecondaryTarget = iterI->second.GetSecondaryTarget();
 
     if (NULL == pSecondaryTarget)
         return pPrimaryTarget;
 
     unsigned int primaryNSteps(0), secondaryNSteps(0);
     const CaloHit *const pPrimaryTrace = this->TraceHitAssociation(pPrimaryTarget, hitAssociationMapI, hitAssociationMapJ, primaryNSteps);
     const CaloHit *const pSecondaryTrace = this->TraceHitAssociation(pSecondaryTarget, hitAssociationMapI, hitAssociationMapJ, secondaryNSteps);
 
     if ((pPrimaryTrace == pSecondaryTrace) || (secondaryNSteps < 5))
         return pPrimaryTarget;
 
     return NULL;
 }

void lar_content::TrackClusterCreationAlgorithm::IdentifyJoins	(	const pandora::OrderedCaloHitList &	orderedCaloHitList,
		const HitAssociationMap &	forwardHitAssociationMap,
		const HitAssociationMap &	backwardHitAssociationMap,
		HitJoinMap &	hitJoinMap
	)		const

private

Identify final hit joins for use in cluster formation.

Parameters

orderedCaloHitList	the ordered calo hit list
forwardHitAssociationMap	the forward hit association map
backwardHitAssociationMap	the backward hit association map
hitJoinMap	to receive the hit join map

Definition at line 247 of file TrackClusterCreationAlgorithm.cc.

 {
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         CaloHitVector caloHits(iter->second->begin(), iter->second->end());
         std::sort(caloHits.begin(), caloHits.end(), LArClusterHelper::SortHitsByPosition);
 
         for (const CaloHit *const pCaloHit : caloHits)
         {
             const CaloHit *const pForwardJoinHit = this->GetJoinHit(pCaloHit, forwardHitAssociationMap, backwardHitAssociationMap);
             const CaloHit *const pBackwardJoinHit = this->GetJoinHit(pForwardJoinHit, backwardHitAssociationMap, forwardHitAssociationMap);
 
             if ((NULL == pForwardJoinHit) || (NULL == pBackwardJoinHit) || (pBackwardJoinHit != pCaloHit))
                 continue;
 
             HitJoinMap::const_iterator joinIter = hitJoinMap.find(pCaloHit);
 
             if (hitJoinMap.end() == joinIter)
                 hitJoinMap.insert(HitJoinMap::value_type(pCaloHit, pForwardJoinHit));
 
             if ((hitJoinMap.end() != joinIter) && (joinIter->second != pForwardJoinHit))
                 throw StatusCodeException(STATUS_CODE_FAILURE);
         }
     }
 }

void lar_content::TrackClusterCreationAlgorithm::MakePrimaryAssociations	(	const pandora::OrderedCaloHitList &	orderedCaloHitList,
		HitAssociationMap &	forwardHitAssociationMap,
		HitAssociationMap &	backwardHitAssociationMap
	)		const

private

Control primary association formation.

Parameters

orderedCaloHitList	the ordered calo hit list
forwardHitAssociationMap	the forward hit association map
backwardHitAssociationMap	the backward hit association map

Definition at line 184 of file TrackClusterCreationAlgorithm.cc.

 {
     for (OrderedCaloHitList::const_iterator iterI = orderedCaloHitList.begin(), iterIEnd = orderedCaloHitList.end(); iterI != iterIEnd; ++iterI)
     {
         unsigned int nLayersConsidered(0);
 
         CaloHitVector caloHitsI(iterI->second->begin(), iterI->second->end());
         std::sort(caloHitsI.begin(), caloHitsI.end(), LArClusterHelper::SortHitsByPosition);
 
         for (OrderedCaloHitList::const_iterator iterJ = iterI, iterJEnd = orderedCaloHitList.end();
              (nLayersConsidered++ <= m_maxGapLayers + 1) && (iterJ != iterJEnd); ++iterJ)
         {
             if (iterJ->first == iterI->first || iterJ->first > iterI->first + m_maxGapLayers + 1)
                 continue;
 
             CaloHitVector caloHitsJ(iterJ->second->begin(), iterJ->second->end());
             std::sort(caloHitsJ.begin(), caloHitsJ.end(), LArClusterHelper::SortHitsByPosition);
 
             for (const CaloHit *const pCaloHitI : caloHitsI)
             {
                 for (const CaloHit *const pCaloHitJ : caloHitsJ)
                     this->CreatePrimaryAssociation(pCaloHitI, pCaloHitJ, forwardHitAssociationMap, backwardHitAssociationMap);
             }
         }
     }
 }

void lar_content::TrackClusterCreationAlgorithm::MakeSecondaryAssociations	(	const pandora::OrderedCaloHitList &	orderedCaloHitList,
		HitAssociationMap &	forwardHitAssociationMap,
		HitAssociationMap &	backwardHitAssociationMap
	)		const

private

Control secondary association formation.

Parameters

orderedCaloHitList	the ordered calo hit list
forwardHitAssociationMap	the forward hit association map
backwardHitAssociationMap	the backward hit association map

Definition at line 214 of file TrackClusterCreationAlgorithm.cc.

 {
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         CaloHitVector caloHits(iter->second->begin(), iter->second->end());
         std::sort(caloHits.begin(), caloHits.end(), LArClusterHelper::SortHitsByPosition);
 
         for (const CaloHit *const pCaloHit : caloHits)
         {
             HitAssociationMap::const_iterator fwdIter = forwardHitAssociationMap.find(pCaloHit);
             const CaloHit *const pForwardHit((forwardHitAssociationMap.end() == fwdIter) ? NULL : fwdIter->second.GetPrimaryTarget());
 
             HitAssociationMap::const_iterator fwdCheckIter = backwardHitAssociationMap.find(pForwardHit);
             const CaloHit *const pForwardHitCheck((backwardHitAssociationMap.end() == fwdCheckIter) ? NULL : fwdCheckIter->second.GetPrimaryTarget());
 
             if ((NULL != pForwardHit) && (pForwardHitCheck != pCaloHit))
                 this->CreateSecondaryAssociation(pCaloHit, pForwardHit, forwardHitAssociationMap, backwardHitAssociationMap);
 
             HitAssociationMap::const_iterator bwdIter = backwardHitAssociationMap.find(pCaloHit);
             const CaloHit *const pBackwardHit((backwardHitAssociationMap.end() == bwdIter) ? NULL : bwdIter->second.GetPrimaryTarget());
 
             HitAssociationMap::const_iterator bwdCheckIter = forwardHitAssociationMap.find(pBackwardHit);
             const CaloHit *const pBackwardHitCheck((forwardHitAssociationMap.end() == bwdCheckIter) ? NULL : bwdCheckIter->second.GetPrimaryTarget());
 
             if ((NULL != pBackwardHit) && (pBackwardHitCheck != pCaloHit))
                 this->CreateSecondaryAssociation(pBackwardHit, pCaloHit, forwardHitAssociationMap, backwardHitAssociationMap);
         }
     }
 }

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

private

Definition at line 441 of file TrackClusterCreationAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MergeBackFilteredHits", m_mergeBackFilteredHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxGapLayers", m_maxGapLayers));
 
     float maxCaloHitSeparation = std::sqrt(m_maxCaloHitSeparationSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxCaloHitSeparation", maxCaloHitSeparation));
     m_maxCaloHitSeparationSquared = maxCaloHitSeparation * maxCaloHitSeparation;
 
     float minCaloHitSeparation = std::sqrt(m_minCaloHitSeparationSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitSeparation", minCaloHitSeparation));
     m_minCaloHitSeparationSquared = minCaloHitSeparation * minCaloHitSeparation;
 
     float closeSeparation = std::sqrt(m_closeSeparationSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CloseSeparation", closeSeparation));
     m_closeSeparationSquared = closeSeparation * closeSeparation;
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::TrackClusterCreationAlgorithm::Run ( )

private

Definition at line 31 of file TrackClusterCreationAlgorithm.cc.

 {
     const CaloHitList *pCaloHitList = NULL;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pCaloHitList));
 
     OrderedCaloHitList selectedCaloHitList, rejectedCaloHitList;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->FilterCaloHits(pCaloHitList, selectedCaloHitList, rejectedCaloHitList));
 
     HitAssociationMap forwardHitAssociationMap, backwardHitAssociationMap;
     this->MakePrimaryAssociations(selectedCaloHitList, forwardHitAssociationMap, backwardHitAssociationMap);
     this->MakeSecondaryAssociations(selectedCaloHitList, forwardHitAssociationMap, backwardHitAssociationMap);
 
     HitJoinMap hitJoinMap;
     HitToClusterMap hitToClusterMap;
     this->IdentifyJoins(selectedCaloHitList, forwardHitAssociationMap, backwardHitAssociationMap, hitJoinMap);
     this->CreateClusters(selectedCaloHitList, hitJoinMap, hitToClusterMap);
 
     if (!m_mergeBackFilteredHits)
         this->CreateClusters(rejectedCaloHitList, hitJoinMap, hitToClusterMap);
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->AddFilteredCaloHits(selectedCaloHitList, rejectedCaloHitList, hitToClusterMap));
 
     return STATUS_CODE_SUCCESS;
 }

const CaloHit * lar_content::TrackClusterCreationAlgorithm::TraceHitAssociation	(	const pandora::CaloHit *const	pCaloHit,
		const HitAssociationMap &	hitAssociationMapI,
		const HitAssociationMap &	hitAssociationMapJ,
		unsigned int &	nSteps
	)		const

private

Get last hit obtained by tracing associations via map I, checking via map J.

Parameters

pCaloHit	the initial calo hit
hitAssociationMapI	hit association map I
hitAssociationMapJ	hit association map J
nSteps	to receive the number of association steps

Returns: the last hit obtained in the chain of associations

Definition at line 410 of file TrackClusterCreationAlgorithm.cc.

 {
     nSteps = 0;
     const CaloHit *pThisHit = pCaloHit;
     const CaloHit *pLastHit = pCaloHit;
 
     while (true)
     {
         ++nSteps;
         pThisHit = pLastHit;
         HitAssociationMap::const_iterator iterI = hitAssociationMapI.find(pThisHit);
 
         if (hitAssociationMapI.end() == iterI)
             break;
 
         pLastHit = iterI->second.GetPrimaryTarget();
         HitAssociationMap::const_iterator iterJ = hitAssociationMapJ.find(pLastHit);
 
         if (hitAssociationMapJ.end() == iterJ)
             break;
 
         if (iterJ->second.GetPrimaryTarget() != pThisHit)
             break;
     }
 
     return pThisHit;
 }