ConeParameters class. More...

#include <VertexBasedPfoMopUpAlgorithm.h>

Public Member Functions
	ConeParameters (const pandora::Cluster *const pCluster, const pandora::CartesianVector &vertexPosition2D, const float coneAngleCentile, const float maxConeCosHalfAngle)
	Constructor. More...

float	GetBoundedFraction (const pandora::Cluster *const pDaughterCluster, const float coneLengthMultiplier) const
	Get the fraction of hits in a candidate daughter cluster bounded by the cone. More...

Private Member Functions
pandora::CartesianVector	GetDirectionEstimate () const
	Get the cone direction estimate, with apex fixed at the 2d vertex position. More...

float	GetSignedConeLength () const
	Get the cone length (signed, by projections of hits onto initial direction estimate) More...

float	GetCosHalfAngleEstimate (const float coneAngleCentile) const
	Get the cone cos half angle estimate. More...

Private Attributes
const pandora::Cluster *	m_pCluster
	The parent cluster. More...

pandora::CartesianVector	m_apex
	The cone apex. More...

pandora::CartesianVector	m_direction
	The cone direction. More...

float	m_coneLength
	The cone length. More...

float	m_coneCosHalfAngle
	The cone cos half angle. More...

Detailed Description

ConeParameters class.

Definition at line 191 of file VertexBasedPfoMopUpAlgorithm.h.

Constructor & Destructor Documentation

lar_content::VertexBasedPfoMopUpAlgorithm::ConeParameters::ConeParameters	(	const pandora::Cluster *const	pCluster,
		const pandora::CartesianVector &	vertexPosition2D,
		const float	coneAngleCentile,
		const float	maxConeCosHalfAngle
	)

Constructor.

Parameters

pCluster	address of the cluster
vertexPosition2D	the event 2D vertex position
coneAngleCentile	the cone angle centile
maxConeCosHalfAngle	the maximum value for cosine of cone half angle

Definition at line 389 of file VertexBasedPfoMopUpAlgorithm.cc.

                                                                                                                                        :
     m_pCluster(pCluster),
     m_apex(vertexPosition2D),
     m_direction(0.f, 0.f, 0.f),
     m_coneLength(0.f),
     m_coneCosHalfAngle(0.f)
 {
     m_direction = this->GetDirectionEstimate();
     m_coneLength = this->GetSignedConeLength();
 
     // ATTN Compensate for coordinate shift when fitting with vertex constraint (cleaner way to do this?)
     if (m_coneLength < std::numeric_limits<float>::epsilon())
     {
         m_direction = m_direction * -1.f;
         m_coneLength = std::fabs(m_coneLength);
     }
 
     m_coneCosHalfAngle = std::min(maxCosHalfAngle, this->GetCosHalfAngleEstimate(coneAngleCentile));
 }

Member Function Documentation

float lar_content::VertexBasedPfoMopUpAlgorithm::ConeParameters::GetBoundedFraction	(	const pandora::Cluster *const	pDaughterCluster,
		const float	coneLengthMultiplier
	)		const

Get the fraction of hits in a candidate daughter cluster bounded by the cone.

Parameters

pDaughterCluster	the address of the daughter cluster
coneLengthMultiplier	cnsider hits as bound if inside cone with projected distance less than N times cone length

Returns: the bounded fraction

Definition at line 412 of file VertexBasedPfoMopUpAlgorithm.cc.

 {
     unsigned int nMatchedHits(0);
     const OrderedCaloHitList &orderedCaloHitList(pDaughterCluster->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)
         {
             const CartesianVector &positionVector((*hIter)->GetPositionVector());
 
             if (m_direction.GetCosOpeningAngle(positionVector - m_apex) < m_coneCosHalfAngle)
                 continue;
 
             if (m_direction.GetDotProduct(positionVector - m_apex) > coneLengthMultiplier * m_coneLength)
                 continue;
 
             ++nMatchedHits;
         }
     }
 
     if (0 == pDaughterCluster->GetNCaloHits())
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     return (static_cast<float>(nMatchedHits) / static_cast<float>(pDaughterCluster->GetNCaloHits()));
 }

float lar_content::VertexBasedPfoMopUpAlgorithm::ConeParameters::GetCosHalfAngleEstimate ( const float coneAngleCentile ) const

private

Get the cone cos half angle estimate.

Parameters

coneAngleCentile the cone angle centile

Returns: the cone cos half angle estimate

Definition at line 485 of file VertexBasedPfoMopUpAlgorithm.cc.

 {
     FloatVector halfAngleValues;
     const OrderedCaloHitList &orderedCaloHitList(m_pCluster->GetOrderedCaloHitList());
 
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         for (CaloHitList::const_iterator hitIter = iter->second->begin(), hitIterEnd = iter->second->end(); hitIter != hitIterEnd; ++hitIter)
             halfAngleValues.push_back(m_direction.GetOpeningAngle((*hitIter)->GetPositionVector() - m_apex));
     }
 
     std::sort(halfAngleValues.begin(), halfAngleValues.end());
 
     if (halfAngleValues.empty())
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     const unsigned int halfAngleBin(coneAngleCentile * halfAngleValues.size());
     return std::cos(halfAngleValues.at(halfAngleBin));
 }

CartesianVector lar_content::VertexBasedPfoMopUpAlgorithm::ConeParameters::GetDirectionEstimate ( ) const

private

Get the cone direction estimate, with apex fixed at the 2d vertex position.

Returns: the direction estimate

Definition at line 441 of file VertexBasedPfoMopUpAlgorithm.cc.

 {
     const OrderedCaloHitList &orderedCaloHitList(m_pCluster->GetOrderedCaloHitList());
     float sumDxDz(0.f), sumDxDx(0.f);
 
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         for (CaloHitList::const_iterator hitIter = iter->second->begin(), hitIterEnd = iter->second->end(); hitIter != hitIterEnd; ++hitIter)
         {
             const CartesianVector apexDisplacement((*hitIter)->GetPositionVector() - m_apex);
             sumDxDz += apexDisplacement.GetX() * apexDisplacement.GetZ();
             sumDxDx += apexDisplacement.GetX() * apexDisplacement.GetX();
         }
     }
 
     if (sumDxDx < std::numeric_limits<float>::epsilon())
         return CartesianVector(0.f, 0.f, 1.f);
 
     return CartesianVector(1.f, 0.f, sumDxDz / sumDxDx).GetUnitVector();
 }

float lar_content::VertexBasedPfoMopUpAlgorithm::ConeParameters::GetSignedConeLength ( ) const

private

Get the cone length (signed, by projections of hits onto initial direction estimate)

Returns: rhe cone length

Definition at line 464 of file VertexBasedPfoMopUpAlgorithm.cc.

 {
     float maxProjectedLength(0.f);
     const OrderedCaloHitList &orderedCaloHitList(m_pCluster->GetOrderedCaloHitList());
 
     for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
     {
         for (CaloHitList::const_iterator hitIter = iter->second->begin(), hitIterEnd = iter->second->end(); hitIter != hitIterEnd; ++hitIter)
         {
             const float projectedLength(m_direction.GetDotProduct((*hitIter)->GetPositionVector() - m_apex));
 
             if (std::fabs(projectedLength) > std::fabs(maxProjectedLength))
                 maxProjectedLength = projectedLength;
         }
     }
 
     return maxProjectedLength;
 }