CosmicRayTrackMatchingAlgorithm class. More...

#include "CosmicRayTrackMatchingAlgorithm.h"

Inheritance diagram for lar_content::CosmicRayTrackMatchingAlgorithm:

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

Protected Types
typedef std::vector< Particle >	ParticleList

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

Protected Member Functions
pandora::StatusCode	Run ()

Private Member Functions
void	SelectCleanClusters (const pandora::ClusterVector &inputVector, pandora::ClusterVector &outputVector) const
	Select a set of clusters judged to be clean. More...

bool	MatchClusters (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2) const
	Match a pair of clusters from two views. More...

bool	CheckMatchedClusters3D (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, const pandora::Cluster *const pCluster3) const
	Check that three clusters have a consistent 3D position. More...

void	SetPfoParameters (const Particle &protoParticle, PandoraContentApi::ParticleFlowObject::Parameters &pfoParameters) const
	Calculate Pfo properties from proto particle. More...

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

Private Attributes
float	m_clusterMinLength
	minimum length of clusters for this algorithm More...

float	m_vtxXOverlap
	requirement on X overlap of start/end positions More...

float	m_minXOverlap
	requirement on minimum X overlap for associated clusters More...

float	m_minXOverlapFraction
	requirement on minimum X overlap fraction for associated clusters More...

float	m_maxDisplacement
	requirement on 3D consistency checks More...

Detailed Description

CosmicRayTrackMatchingAlgorithm class.

Definition at line 19 of file CosmicRayTrackMatchingAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster*, pandora::ClusterList> lar_content::CosmicRayBaseMatchingAlgorithm::ClusterAssociationMap

protectedinherited

Definition at line 49 of file CosmicRayBaseMatchingAlgorithm.h.

typedef std::vector<Particle> lar_content::CosmicRayBaseMatchingAlgorithm::ParticleList

protectedinherited

Definition at line 48 of file CosmicRayBaseMatchingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CosmicRayTrackMatchingAlgorithm::CosmicRayTrackMatchingAlgorithm ( )

Default constructor.

Definition at line 21 of file CosmicRayTrackMatchingAlgorithm.cc.

                                                                  :
     m_clusterMinLength(10.f),
     m_vtxXOverlap(3.f),
     m_minXOverlap(3.f),
     m_minXOverlapFraction(0.8f),
     m_maxDisplacement(10.f)
 {
 }

Member Function Documentation

bool lar_content::CosmicRayTrackMatchingAlgorithm::CheckMatchedClusters3D	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		const pandora::Cluster *const	pCluster3
	)		const

privatevirtual

Check that three clusters have a consistent 3D position.

Parameters

pCluster1	the cluster from the first view
pCluster2	the cluster from the second view
pCluster3	the cluster from the third view

Returns: boolean

Implements lar_content::CosmicRayBaseMatchingAlgorithm.

Definition at line 114 of file CosmicRayTrackMatchingAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClosestDistance(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArClusterHelper::GetExtremalCoordinates(), m_maxDisplacement, m_vtxXOverlap, max, lar_content::LArGeometryHelper::MergeTwoPositions(), and n.

 {
     // Check that three clusters have a consistent 3D position
     const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));
     const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));
     const HitType hitType3(LArClusterHelper::GetClusterHitType(pCluster3));
 
     if (hitType1 == hitType2 || hitType2 == hitType3 || hitType3 == hitType1)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     CartesianVector innerVertex1(0.f,0.f,0.f), outerVertex1(0.f,0.f,0.f);
     CartesianVector innerVertex2(0.f,0.f,0.f), outerVertex2(0.f,0.f,0.f);
     CartesianVector innerVertex3(0.f,0.f,0.f), outerVertex3(0.f,0.f,0.f);
 
     LArClusterHelper::GetExtremalCoordinates(pCluster1, innerVertex1, outerVertex1);
     LArClusterHelper::GetExtremalCoordinates(pCluster2, innerVertex2, outerVertex2);
     LArClusterHelper::GetExtremalCoordinates(pCluster3, innerVertex3, outerVertex3);
 
     for (unsigned int n = 0; n < 4; ++n)
     {
         CartesianVector vtx1(1 == n ? outerVertex1 : innerVertex1);
         CartesianVector end1(1 == n ? innerVertex1 : outerVertex1);
 
         CartesianVector vtx2(2 == n ? outerVertex2 : innerVertex2);
         CartesianVector end2(2 == n ? innerVertex2 : outerVertex2);
 
         CartesianVector vtx3(3 == n ? outerVertex3 : innerVertex3);
         CartesianVector end3(3 == n ? innerVertex3 : outerVertex3);
 
         if (std::fabs(vtx1.GetX() - vtx2.GetX()) < std::max(m_vtxXOverlap, std::fabs(vtx1.GetX() - end2.GetX())) &&
             std::fabs(end1.GetX() - end2.GetX()) < std::max(m_vtxXOverlap, std::fabs(end1.GetX() - vtx2.GetX())) &&
             std::fabs(vtx2.GetX() - vtx3.GetX()) < std::max(m_vtxXOverlap, std::fabs(vtx2.GetX() - end3.GetX())) &&
             std::fabs(end2.GetX() - end3.GetX()) < std::max(m_vtxXOverlap, std::fabs(end2.GetX() - vtx3.GetX())) &&
             std::fabs(vtx3.GetX() - vtx1.GetX()) < std::max(m_vtxXOverlap, std::fabs(vtx3.GetX() - end1.GetX())) &&
             std::fabs(end3.GetX() - end1.GetX()) < std::max(m_vtxXOverlap, std::fabs(end3.GetX() - vtx1.GetX())))
         {
             float chi2(0.f);
             CartesianVector projVtx1(0.f,0.f,0.f), projEnd1(0.f,0.f,0.f);
             CartesianVector projVtx2(0.f,0.f,0.f), projEnd2(0.f,0.f,0.f);
             CartesianVector projVtx3(0.f,0.f,0.f), projEnd3(0.f,0.f,0.f);
 
             LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType1, hitType2, vtx1, vtx2, projVtx3, chi2);
             LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType1, hitType2, end1, end2, projEnd3, chi2);
             LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType2, hitType3, vtx2, vtx3, projVtx1, chi2);
             LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType2, hitType3, end2, end3, projEnd1, chi2);
             LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType3, hitType1, vtx3, vtx1, projVtx2, chi2);
             LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType3, hitType1, end3, end1, projEnd2, chi2);
 
             const bool matchedVtx1(LArClusterHelper::GetClosestDistance(projVtx1, pCluster1) < m_maxDisplacement);
             const bool matchedVtx2(LArClusterHelper::GetClosestDistance(projVtx2, pCluster2) < m_maxDisplacement);
             const bool matchedVtx3(LArClusterHelper::GetClosestDistance(projVtx3, pCluster3) < m_maxDisplacement);
 
             const bool matchedEnd1(LArClusterHelper::GetClosestDistance(projEnd1, pCluster1) < m_maxDisplacement);
             const bool matchedEnd2(LArClusterHelper::GetClosestDistance(projEnd2, pCluster2) < m_maxDisplacement);
             const bool matchedEnd3(LArClusterHelper::GetClosestDistance(projEnd3, pCluster3) < m_maxDisplacement);
 
             const bool matchedCluster1(matchedVtx1 || matchedEnd1);
             const bool matchedCluster2(matchedVtx2 || matchedEnd2);
             const bool matchedCluster3(matchedVtx3 || matchedEnd3);
             const bool matchedVtx(matchedVtx1 || matchedVtx2 || matchedVtx3);
             const bool matchedEnd(matchedEnd1 || matchedEnd2 || matchedEnd3);
 
             if (matchedCluster1 && matchedCluster2 && matchedCluster3 && matchedVtx && matchedEnd)
                 return true;
         }
     }
 
     return false;
 }

bool lar_content::CosmicRayTrackMatchingAlgorithm::MatchClusters	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2
	)		const

privatevirtual

Match a pair of clusters from two views.

Parameters

pCluster1	the first cluster
pCluster2	the second cluster

Returns: boolean

Implements lar_content::CosmicRayBaseMatchingAlgorithm.

Definition at line 75 of file CosmicRayTrackMatchingAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClusterSpanX(), lar_content::LArClusterHelper::GetExtremalCoordinates(), m_minXOverlap, m_minXOverlapFraction, m_vtxXOverlap, max, and min.

 {
     // Use start and end points
     CartesianVector innerVertex1(0.f,0.f,0.f), outerVertex1(0.f,0.f,0.f);
     CartesianVector innerVertex2(0.f,0.f,0.f), outerVertex2(0.f,0.f,0.f);
 
     LArClusterHelper::GetExtremalCoordinates(pCluster1, innerVertex1, outerVertex1);
     LArClusterHelper::GetExtremalCoordinates(pCluster2, innerVertex2, outerVertex2);
 
     const float dxA(std::fabs(innerVertex2.GetX() - innerVertex1.GetX())); // inner1 <-> inner2
     const float dxB(std::fabs(outerVertex2.GetX() - outerVertex1.GetX())); // outer1 <-> outer2
 
     const float dxC(std::fabs(outerVertex2.GetX() - innerVertex1.GetX())); // inner1 <-> outer2
     const float dxD(std::fabs(innerVertex2.GetX() - outerVertex1.GetX())); // inner2 <-> outer1
 
     const float xVertex(std::min(std::max(dxA, dxB), std::max(dxC, dxD)));
 
     if (xVertex < m_vtxXOverlap)
         return true;
 
     // use X overlap
     float xMin1(0.f), xMax1(0.f), xMin2(0.f), xMax2(0.f);
     LArClusterHelper::GetClusterSpanX(pCluster1, xMin1, xMax1);
     LArClusterHelper::GetClusterSpanX(pCluster2, xMin2, xMax2);
 
     const float xOverlap(std::min(xMax1,xMax2) - std::max(xMin1,xMin2));
     const float xSpan(std::max(xMax1,xMax2) - std::min(xMin1,xMin2));
 
     if (xSpan < std::numeric_limits<float>::epsilon())
         return false;
 
     if (xOverlap > m_minXOverlap && xOverlap / xSpan > m_minXOverlapFraction)
         return true;
 
     return false;
 }

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

private

Definition at line 205 of file CosmicRayTrackMatchingAlgorithm.cc.

References m_clusterMinLength, m_maxDisplacement, m_minXOverlap, m_minXOverlapFraction, m_vtxXOverlap, and lar_content::CosmicRayBaseMatchingAlgorithm::ReadSettings().

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "ClusterMinLength", m_clusterMinLength));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "VtxXOverlap", m_vtxXOverlap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinXOverlap", m_minXOverlap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinXOverlapFraction", m_minXOverlapFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MaxDisplacement", m_maxDisplacement));
 
     return CosmicRayBaseMatchingAlgorithm::ReadSettings(xmlHandle);
 }

StatusCode lar_content::CosmicRayBaseMatchingAlgorithm::Run ( )

protectedinherited

Definition at line 20 of file CosmicRayBaseMatchingAlgorithm.cc.

 {
     // Get the available clusters for each view
     ClusterVector availableClustersU, availableClustersV, availableClustersW;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetAvailableClusters(m_inputClusterListNameU, availableClustersU));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetAvailableClusters(m_inputClusterListNameV, availableClustersV));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetAvailableClusters(m_inputClusterListNameW, availableClustersW));
 
     // Select clean clusters in each view
     ClusterVector cleanClustersU, cleanClustersV, cleanClustersW;
     this->SelectCleanClusters(availableClustersU, cleanClustersU);
     this->SelectCleanClusters(availableClustersV, cleanClustersV);
     this->SelectCleanClusters(availableClustersW, cleanClustersW);
 
     // Build associations between pairs of views
     ClusterAssociationMap matchedClusterUV, matchedClusterVW, matchedClusterWU;
     this->MatchClusters(cleanClustersU, cleanClustersV, matchedClusterUV);
     this->MatchClusters(cleanClustersV, cleanClustersW, matchedClusterVW);
     this->MatchClusters(cleanClustersW, cleanClustersU, matchedClusterWU);
 
     // Build particles from associations
     ParticleList particleList;
     this->MatchThreeViews(matchedClusterUV, matchedClusterVW, matchedClusterWU, particleList);
     this->MatchTwoViews(matchedClusterUV, matchedClusterVW, matchedClusterWU, particleList);
     this->BuildParticles(particleList);
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::CosmicRayTrackMatchingAlgorithm::SelectCleanClusters	(	const pandora::ClusterVector &	inputVector,
		pandora::ClusterVector &	outputVector
	)		const

privatevirtual

Select a set of clusters judged to be clean.

Parameters

inputVector	the input vector of all available clusters
outputVector	the output vector of clean clusters

Implements lar_content::CosmicRayBaseMatchingAlgorithm.

Definition at line 32 of file CosmicRayTrackMatchingAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClosestDistance(), lar_content::LArClusterHelper::GetExtremalCoordinates(), lar_content::LArClusterHelper::GetLengthSquared(), m_clusterMinLength, and m_vtxXOverlap.

 {
     ClusterVector clusterVector;
 
     // Select long clusters
     for (const Cluster *const pCluster : inputVector)
     {
         if (LArClusterHelper::GetLengthSquared(pCluster) < m_clusterMinLength * m_clusterMinLength)
             continue;
 
         clusterVector.push_back(pCluster);
     }
 
     // Remove long delta rays
     for (const Cluster *const pCluster : clusterVector)
     {
         const float lengthSquared(LArClusterHelper::GetLengthSquared(pCluster));
         CartesianVector innerVertex(0.f,0.f,0.f), outerVertex(0.f,0.f,0.f);
         LArClusterHelper::GetExtremalCoordinates(pCluster, innerVertex, outerVertex);
 
         bool isDeltaRay(false);
 
         for (const Cluster *const pClusterCheck : clusterVector)
         {
             if (pCluster == pClusterCheck)
                 continue;
 
             if ((LArClusterHelper::GetLengthSquared(pClusterCheck) > 10.f * lengthSquared) &&
                 (LArClusterHelper::GetClosestDistance(innerVertex, pClusterCheck) < m_vtxXOverlap ||
                  LArClusterHelper::GetClosestDistance(outerVertex, pClusterCheck) < m_vtxXOverlap))
             {
                 isDeltaRay = true;
                 break;
             }
         }
 
         if (!isDeltaRay)
             outputVector.push_back(pCluster);
     }
 }

void lar_content::CosmicRayTrackMatchingAlgorithm::SetPfoParameters	(	const Particle &	protoParticle,
		PandoraContentApi::ParticleFlowObject::Parameters &	pfoParameters
	)		const

privatevirtual

Calculate Pfo properties from proto particle.

Parameters

protoParticle	the input proto particle
pfoParameters	the output pfo parameters

Implements lar_content::CosmicRayBaseMatchingAlgorithm.

Definition at line 187 of file CosmicRayTrackMatchingAlgorithm.cc.

References f, lar_content::CosmicRayBaseMatchingAlgorithm::Particle::m_pClusterU, lar_content::CosmicRayBaseMatchingAlgorithm::Particle::m_pClusterV, and lar_content::CosmicRayBaseMatchingAlgorithm::Particle::m_pClusterW.

 {
     ClusterList clusterList;
     if (particle.m_pClusterU) clusterList.push_back(particle.m_pClusterU);
     if (particle.m_pClusterV) clusterList.push_back(particle.m_pClusterV);
     if (particle.m_pClusterW) clusterList.push_back(particle.m_pClusterW);
 
     // TODO Correct these placeholder parameters
     pfoParameters.m_particleId = MU_MINUS; // TRACK
     pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());
     pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());
     pfoParameters.m_energy = 0.f;
     pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);
     pfoParameters.m_clusterList = clusterList;
 }

Member Data Documentation

float lar_content::CosmicRayTrackMatchingAlgorithm::m_clusterMinLength

private

minimum length of clusters for this algorithm

Definition at line 37 of file CosmicRayTrackMatchingAlgorithm.h.

Referenced by ReadSettings(), and SelectCleanClusters().

float lar_content::CosmicRayTrackMatchingAlgorithm::m_maxDisplacement

private

requirement on 3D consistency checks

Definition at line 41 of file CosmicRayTrackMatchingAlgorithm.h.

Referenced by CheckMatchedClusters3D(), and ReadSettings().

float lar_content::CosmicRayTrackMatchingAlgorithm::m_minXOverlap

private

requirement on minimum X overlap for associated clusters

Definition at line 39 of file CosmicRayTrackMatchingAlgorithm.h.

Referenced by MatchClusters(), and ReadSettings().

float lar_content::CosmicRayTrackMatchingAlgorithm::m_minXOverlapFraction

private

requirement on minimum X overlap fraction for associated clusters

Definition at line 40 of file CosmicRayTrackMatchingAlgorithm.h.

Referenced by MatchClusters(), and ReadSettings().

float lar_content::CosmicRayTrackMatchingAlgorithm::m_vtxXOverlap

private

requirement on X overlap of start/end positions

Definition at line 38 of file CosmicRayTrackMatchingAlgorithm.h.

Referenced by CheckMatchedClusters3D(), MatchClusters(), ReadSettings(), and SelectCleanClusters().

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

larpandoracontent/v03_13_02/source/larpandoracontent/LArThreeDReco/LArCosmicRay/CosmicRayTrackMatchingAlgorithm.h
larpandoracontent/v03_13_02/source/larpandoracontent/LArThreeDReco/LArCosmicRay/CosmicRayTrackMatchingAlgorithm.cc

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation