ConeClusterMopUpAlgorithm class. More...

#include <ConeClusterMopUpAlgorithm.h>

Inheritance diagram for lar_content::ConeClusterMopUpAlgorithm:

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

Public Member Functions inherited from lar_content::ClusterMopUpBaseAlgorithm
	ClusterMopUpBaseAlgorithm ()
	Default constructor. More...

Public Member Functions inherited from lar_content::MopUpBaseAlgorithm
template<typename T >
const std::string	GetListName (const T *const pT) const
	Find the name of the list hosting a specific object. More...

Private Types
typedef std::pair< float, float >	Coordinate

typedef std::vector< Coordinate >	CoordinateList

Private Member Functions
void	ClusterMopUp (const pandora::ClusterList &pfoClusters, const pandora::ClusterList &remnantClusters) const
	Cluster mop up for a single view. This function is responsible for instructing pandora to make cluster alterations. More...

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

Static Private Member Functions
static bool	SortCoordinates (const Coordinate &lhs, const Coordinate &rhs)
	Sort coordinates by increasing transverse displacement. More...

Private Attributes
unsigned int	m_slidingFitWindow
	The layer window for the sliding linear fits. More...

float	m_showerEdgeMultiplier
	Artificially tune width of shower envelope so as to make it more/less inclusive. More...

float	m_coneAngleCentile
	Cluster cone angle is defined using specified centile of distribution of hit half angles. More...

float	m_maxConeLengthMultiplier
	Consider hits as bound if inside cone, with projected distance less than N times cone length. More...

float	m_minBoundedFraction
	The minimum cluster bounded fraction for merging. More...

Additional Inherited Members
Protected Types inherited from lar_content::ClusterMopUpBaseAlgorithm
typedef std::unordered_map< const pandora::Cluster *, float >	AssociationDetails

typedef std::unordered_map< const pandora::Cluster *, AssociationDetails >	ClusterAssociationMap

Protected Member Functions inherited from lar_content::ClusterMopUpBaseAlgorithm
virtual pandora::StatusCode	Run ()

virtual void	GetPfoClusterLists (pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the two dimensional clusters contained in the input pfo list, divided into three different views. More...

virtual void	GetDaughterClusterLists (pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the two dimensional clusters contained in the input remant/daughter cluster lists, divided into three different views. More...

virtual void	GetClusterLists (const pandora::ClusterList &inputClusterList, const bool availabilityFlag, pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the two dimensional clusters contained in an input cluster list, divided into three different views. More...

virtual void	MakeClusterMerges (const ClusterAssociationMap &clusterAssociationMap) const
	Make the cluster merges specified in the cluster association map, using list name information in the cluster list name map. More...

Protected Attributes inherited from lar_content::ClusterMopUpBaseAlgorithm
pandora::StringVector	m_pfoListNames
	The list of pfo list names. More...

bool	m_excludePfosContainingTracks
	Whether to exclude any pfos containing clusters flagged as fixed tracks. More...

Protected Attributes inherited from lar_content::MopUpBaseAlgorithm
pandora::StringVector	m_daughterListNames
	The list of potential daughter object list names. More...

Detailed Description

ConeClusterMopUpAlgorithm class.

Definition at line 21 of file ConeClusterMopUpAlgorithm.h.

Member Typedef Documentation

typedef std::pair<float, float> lar_content::ConeClusterMopUpAlgorithm::Coordinate

private

Definition at line 32 of file ConeClusterMopUpAlgorithm.h.

typedef std::vector<Coordinate> lar_content::ConeClusterMopUpAlgorithm::CoordinateList

private

Definition at line 33 of file ConeClusterMopUpAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ConeClusterMopUpAlgorithm::ConeClusterMopUpAlgorithm ( )

Default constructor.

Definition at line 23 of file ConeClusterMopUpAlgorithm.cc.

                                                      :
     m_slidingFitWindow(20),
     m_showerEdgeMultiplier(1.5f),
     m_coneAngleCentile(0.85f),
     m_maxConeLengthMultiplier(1.5f),
     m_minBoundedFraction(0.5f)
 {
 }

Member Function Documentation

void lar_content::ConeClusterMopUpAlgorithm::ClusterMopUp	(	const pandora::ClusterList &	pfoClusters,
		const pandora::ClusterList &	remnantClusters
	)		const

privatevirtual

Cluster mop up for a single view. This function is responsible for instructing pandora to make cluster alterations.

Parameters

pfoClusters	the list of pfo clusters
remnantClusters	the list of remnant clusters

Implements lar_content::ClusterMopUpBaseAlgorithm.

Definition at line 34 of file ConeClusterMopUpAlgorithm.cc.

 {
     ClusterAssociationMap clusterAssociationMap;
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     const VertexList *pVertexList(NULL);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
 
     if ((pVertexList->size() != 1) || (VERTEX_3D != (*(pVertexList->begin()))->GetVertexType()))
         return;
 
     const Vertex *const pVertex(*(pVertexList->begin()));
 
     ClusterVector sortedPfoClusters(pfoClusters.begin(), pfoClusters.end());
     std::sort(sortedPfoClusters.begin(), sortedPfoClusters.end(), LArClusterHelper::SortByNHits);
 
     ClusterVector sortedRemnantClusters(remnantClusters.begin(), remnantClusters.end());
     std::sort(sortedRemnantClusters.begin(), sortedRemnantClusters.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pPfoCluster : sortedPfoClusters)
     {
         try
         {
             const TwoDSlidingShowerFitResult showerFitResult(pPfoCluster, m_slidingFitWindow, slidingFitPitch, m_showerEdgeMultiplier);
 
             const LayerFitResultMap &layerFitResultMapS(showerFitResult.GetShowerFitResult().GetLayerFitResultMap());
             const LayerFitResultMap &layerFitResultMapP(showerFitResult.GetPositiveEdgeFitResult().GetLayerFitResultMap());
             const LayerFitResultMap &layerFitResultMapN(showerFitResult.GetNegativeEdgeFitResult().GetLayerFitResultMap());
 
             if (layerFitResultMapS.size() < 2)
                 continue;
 
             // Cone direction
             CartesianVector minLayerPositionOnAxis(0.f, 0.f, 0.f), maxLayerPositionOnAxis(0.f, 0.f, 0.f);
             showerFitResult.GetShowerFitResult().GetGlobalPosition(layerFitResultMapS.begin()->second.GetL(), 0.f, minLayerPositionOnAxis);
             showerFitResult.GetShowerFitResult().GetGlobalPosition(layerFitResultMapS.rbegin()->second.GetL(), 0.f, maxLayerPositionOnAxis);
 
             const HitType hitType(LArClusterHelper::GetClusterHitType(pPfoCluster));
             const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));
             const bool vertexAtMinL((vertexPosition2D - minLayerPositionOnAxis).GetMagnitudeSquared() <
                                     (vertexPosition2D - maxLayerPositionOnAxis).GetMagnitudeSquared());
 
             // Cone edges
             CoordinateList coordinateListP, coordinateListN;
 
             for (LayerFitResultMap::const_iterator iterS = layerFitResultMapS.begin(); iterS != layerFitResultMapS.end(); ++iterS)
             {
                 LayerFitResultMap::const_iterator iterP = layerFitResultMapP.find(iterS->first);
                 LayerFitResultMap::const_iterator iterN = layerFitResultMapN.find(iterS->first);
 
                 if (layerFitResultMapP.end() != iterP)
                     coordinateListP.push_back(Coordinate(iterP->second.GetL(), iterP->second.GetFitT()));
 
                 if (layerFitResultMapN.end() != iterN)
                     coordinateListN.push_back(Coordinate(iterN->second.GetL(), iterN->second.GetFitT()));
             }
 
             if (coordinateListP.empty() || coordinateListN.empty())
                 continue;
 
             std::sort(coordinateListP.begin(), coordinateListP.end(), ConeClusterMopUpAlgorithm::SortCoordinates);
             std::sort(coordinateListN.begin(), coordinateListN.end(), ConeClusterMopUpAlgorithm::SortCoordinates);
 
             const Coordinate maxP(coordinateListP.at(m_coneAngleCentile * coordinateListP.size()));
             const Coordinate minP(vertexAtMinL
                                       ? Coordinate(layerFitResultMapP.begin()->second.GetL(), layerFitResultMapP.begin()->second.GetFitT())
                                       : Coordinate(layerFitResultMapP.rbegin()->second.GetL(), layerFitResultMapP.rbegin()->second.GetFitT()));
 
             const Coordinate maxN(coordinateListN.at((1.f - m_coneAngleCentile) * coordinateListN.size()));
             const Coordinate minN(vertexAtMinL
                                       ? Coordinate(layerFitResultMapN.begin()->second.GetL(), layerFitResultMapN.begin()->second.GetFitT())
                                       : Coordinate(layerFitResultMapN.rbegin()->second.GetL(), layerFitResultMapN.rbegin()->second.GetFitT()));
 
             const float minL(layerFitResultMapS.begin()->second.GetL());
             const float maxL(minL + m_maxConeLengthMultiplier * std::fabs(layerFitResultMapS.rbegin()->second.GetL() - minL));
 
             if ((std::fabs(maxP.first - minP.first) < std::numeric_limits<float>::epsilon()) ||
                 (std::fabs(maxN.first - minN.first) < std::numeric_limits<float>::epsilon()) ||
                 (std::fabs(maxL - minL) < std::numeric_limits<float>::epsilon()))
             {
                 continue;
             }
 
             // Bounded fraction calculation
             for (const Cluster *const pRemnantCluster : sortedRemnantClusters)
             {
                 const unsigned int nHits(pRemnantCluster->GetNCaloHits());
 
                 unsigned int nMatchedHits(0);
                 const OrderedCaloHitList &orderedCaloHitList(pRemnantCluster->GetOrderedCaloHitList());
 
                 for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
                 {
                     for (CaloHitList::const_iterator hIter = iter->second->begin(), hIterEnd = iter->second->end(); hIter != hIterEnd; ++hIter)
                     {
                         float rL(0.f), rT(0.f);
                         showerFitResult.GetShowerFitResult().GetLocalPosition((*hIter)->GetPositionVector(), rL, rT);
 
                         if ((rL < minL) || (rL > maxL))
                             continue;
 
                         const float rTP(minP.second + (rL - minP.first) * ((maxP.second - minP.second) / (maxP.first - minP.first)));
                         const float rTN(minN.second + (rL - minN.first) * ((maxN.second - minN.second) / (maxN.first - minN.first)));
 
                         if ((rT > rTP) || (rT < rTN))
                             continue;
 
                         ++nMatchedHits;
                     }
                 }
 
                 const float boundedFraction((nHits > 0) ? static_cast<float>(nMatchedHits) / static_cast<float>(nHits) : 0.f);
 
                 if (boundedFraction < m_minBoundedFraction)
                     continue;
 
                 AssociationDetails &associationDetails(clusterAssociationMap[pRemnantCluster]);
 
                 if (!associationDetails.insert(AssociationDetails::value_type(pPfoCluster, boundedFraction)).second)
                     throw StatusCodeException(STATUS_CODE_FAILURE);
             }
         }
         catch (StatusCodeException &statusCodeException)
         {
             if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                 throw statusCodeException;
         }
     }
 
     this->MakeClusterMerges(clusterAssociationMap);
 }

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

privatevirtual

Reimplemented from lar_content::ClusterMopUpBaseAlgorithm.

Definition at line 175 of file ConeClusterMopUpAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitWindow", m_slidingFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowerEdgeMultiplier", m_showerEdgeMultiplier));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeAngleCentile", m_coneAngleCentile));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxConeLengthMultiplier", m_maxConeLengthMultiplier));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinBoundedFraction", m_minBoundedFraction));
 
     return ClusterMopUpBaseAlgorithm::ReadSettings(xmlHandle);
 }

bool lar_content::ConeClusterMopUpAlgorithm::SortCoordinates	(	const Coordinate &	lhs,
		const Coordinate &	rhs
	)

staticprivate

Sort coordinates by increasing transverse displacement.

Parameters

lhs	the first coordinate for comparison
rhs	the second coordinate for comparison

Returns: boolean

Definition at line 168 of file ConeClusterMopUpAlgorithm.cc.

 {
     return (lhs.second < rhs.second);
 }

Member Data Documentation

float lar_content::ConeClusterMopUpAlgorithm::m_coneAngleCentile

private

Cluster cone angle is defined using specified centile of distribution of hit half angles.

Definition at line 49 of file ConeClusterMopUpAlgorithm.h.

float lar_content::ConeClusterMopUpAlgorithm::m_maxConeLengthMultiplier

private

Consider hits as bound if inside cone, with projected distance less than N times cone length.

Definition at line 50 of file ConeClusterMopUpAlgorithm.h.

float lar_content::ConeClusterMopUpAlgorithm::m_minBoundedFraction

private

The minimum cluster bounded fraction for merging.

Definition at line 51 of file ConeClusterMopUpAlgorithm.h.

float lar_content::ConeClusterMopUpAlgorithm::m_showerEdgeMultiplier

private

Artificially tune width of shower envelope so as to make it more/less inclusive.

Definition at line 48 of file ConeClusterMopUpAlgorithm.h.

unsigned int lar_content::ConeClusterMopUpAlgorithm::m_slidingFitWindow

private

The layer window for the sliding linear fits.

Definition at line 47 of file ConeClusterMopUpAlgorithm.h.

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

larpandoracontent/larpandoracontent/LArTwoDReco/LArClusterMopUp/ConeClusterMopUpAlgorithm.h
larpandoracontent/larpandoracontent/LArTwoDReco/LArClusterMopUp/ConeClusterMopUpAlgorithm.cc

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation