#include "PeakDirectionFinderTool.h"

Inheritance diagram for lar_content::PeakDirectionFinderTool:

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

pandora::StatusCode	Run (const pandora::ParticleFlowObject const pShowerPfo, const pandora::CartesianVector &nuVertex3D, const pandora::CaloHitList const pViewHitList, const pandora::HitType hitType, pandora::CartesianPointVector &peakDirectionVector)

Private Types
typedef std::map< int, float >	AngularDecompositionMap

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

void	CollectHitsWithinROI (const pandora::CaloHitList &showerHitList, const pandora::CaloHitList *const pViewHitList, const pandora::CartesianVector &nuVertex2D, pandora::CaloHitList &viewROIHits) const
	Collect the 2D hits within a region of interest (m_ambiguousParticleMode ? hits not in the shower : hits within the initial shower cone [originating from the nu vertex]) More...

void	GetAngularExtrema (const pandora::CaloHitList &showerHitList, const pandora::CartesianVector &nuVertex2D, float &lowestTheta, float &highestTheta) const
	Determine the angle (from the +ve drift-axis) of the shower cone boundaries (originating from the nu vertex) More...

void	CollectHitsWithinExtrema (const pandora::CaloHitList *const pViewHitList, const pandora::CartesianVector &nuVertex2D, const float lowestTheta, const float highestTheta, pandora::CaloHitList &viewROIHits) const
	Collect the hits that lie within the initial shower cone (originating from the nu vertex) More...

void	FillAngularDecompositionMap (const pandora::CaloHitList &viewShowerHitList, const pandora::CartesianVector &nuVertex2D, AngularDecompositionMap &angularDecompositionMap) const
	Determine the angular distribution of the ROI hits. More...

void	SmoothAngularDecompositionMap (AngularDecompositionMap &angularDecompositionMap) const
	Smooth the ROI angular angular distribution. More...

void	RetrievePeakDirections (const AngularDecompositionMap &angularDecompositionMap, pandora::CartesianPointVector &peakDirectionVector) const
	Obtain a vector of directions from the angular distribution peaks. More...

Private Attributes
float	m_pathwaySearchRegion
	The initial shower cone distance. More...

float	m_theta0XZBinSize
	The angular distribution bin size. More...

int	m_smoothingWindow
	On each side, the number of neighbouring bins with which each bin is averaged. More...

bool	m_ambiguousParticleMode
	Whether to find the initial pathway direction of the shower or of the other event particles. More...

Detailed Description

Definition at line 17 of file PeakDirectionFinderTool.h.

Member Typedef Documentation

typedef std::map<int, float> lar_content::PeakDirectionFinderTool::AngularDecompositionMap

private

Definition at line 29 of file PeakDirectionFinderTool.h.

Constructor & Destructor Documentation

lar_content::PeakDirectionFinderTool::PeakDirectionFinderTool ( )

Default constructor.

Definition at line 22 of file PeakDirectionFinderTool.cc.

                                                  :
     m_pathwaySearchRegion(10.f),
     m_theta0XZBinSize(0.005f),
     m_smoothingWindow(1),
     m_ambiguousParticleMode(false)
 {
 }

Member Function Documentation

void lar_content::PeakDirectionFinderTool::CollectHitsWithinExtrema	(	const pandora::CaloHitList *const	pViewHitList,
		const pandora::CartesianVector &	nuVertex2D,
		const float	lowestTheta,
		const float	highestTheta,
		pandora::CaloHitList &	viewROIHits
	)		const

private

Collect the hits that lie within the initial shower cone (originating from the nu vertex)

Parameters

pViewHitList	the event 2D hits list
nuVertex2D	the 2D neutrino vertex
lowestTheta	the lower angle (from the +ve drift-axis) boundary
highestTheta	the higher angle (from the +ve drift-axis) boundary
viewROIHits	the region of interest 2D hit list

Definition at line 120 of file PeakDirectionFinderTool.cc.

References f.

Referenced by CollectHitsWithinROI().

 {
     const CartesianVector xAxis(1.f, 0.f, 0.f);
 
     for (const CaloHit *const pCaloHit : *pViewHitList)
     {
         const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
         const CartesianVector displacementVector(hitPosition - nuVertex2D);
 
         float theta0XZ(xAxis.GetOpeningAngle(displacementVector));
 
         if (displacementVector.GetZ() < 0.f)
             theta0XZ = (2.0 * M_PI) - theta0XZ;
 
         if ((theta0XZ < lowestTheta) || (theta0XZ > highestTheta))
             continue;
 
         viewROIHits.push_back(pCaloHit);
     }
 }

void lar_content::PeakDirectionFinderTool::CollectHitsWithinROI	(	const pandora::CaloHitList &	showerHitList,
		const pandora::CaloHitList *const	pViewHitList,
		const pandora::CartesianVector &	nuVertex2D,
		pandora::CaloHitList &	viewROIHits
	)		const

private

Collect the 2D hits within a region of interest (m_ambiguousParticleMode ? hits not in the shower : hits within the initial shower cone [originating from the nu vertex])

Parameters

showerHitList	the 2D shower hit list
pViewHitList	the event 2D hits list
nuVertex2D	the 2D neutrino vertex
viewROIHits	the region of interest 2D hit list

Definition at line 68 of file PeakDirectionFinderTool.cc.

References CollectHitsWithinExtrema(), f, GetAngularExtrema(), and m_ambiguousParticleMode.

Referenced by Run().

 {
     if (m_ambiguousParticleMode)
     {
         for (const CaloHit *const pCaloHit : *pViewHitList)
         {
             if (std::find(showerHitList.begin(), showerHitList.end(), pCaloHit) != showerHitList.end())
                 continue;
 
             viewROIHits.push_back(pCaloHit);
         }
     }
     else
     {
         float lowestTheta(std::numeric_limits<float>::max()), highestTheta((-1.f) * std::numeric_limits<float>::max());
 
         this->GetAngularExtrema(showerHitList, nuVertex2D, lowestTheta, highestTheta);
         this->CollectHitsWithinExtrema(pViewHitList, nuVertex2D, lowestTheta, highestTheta, viewROIHits);
     }
 }

void lar_content::PeakDirectionFinderTool::FillAngularDecompositionMap	(	const pandora::CaloHitList &	viewShowerHitList,
		const pandora::CartesianVector &	nuVertex2D,
		AngularDecompositionMap &	angularDecompositionMap
	)		const

private

Determine the angular distribution of the ROI hits.

Parameters

viewShowerHitList	the 2D shower hit list
nuVertex2D	the 2D neutrino vertex
angularDecompositionMap	the output [angle from drift-axis -> weight] map

Definition at line 144 of file PeakDirectionFinderTool.cc.

References f, m_pathwaySearchRegion, and m_theta0XZBinSize.

Referenced by Run().

 {
     const CartesianVector xAxis(1.f, 0.f, 0.f);
 
     for (const CaloHit *const pCaloHit : viewShowerHitList)
     {
         const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
         const CartesianVector displacementVector(hitPosition - nuVertex2D);
 
         if (displacementVector.GetMagnitudeSquared() > (m_pathwaySearchRegion * m_pathwaySearchRegion))
             continue;
 
         float theta0XZ(xAxis.GetOpeningAngle(displacementVector));
 
         if (displacementVector.GetZ() < 0.f)
             theta0XZ *= -1.f;
 
         const int theta0XZFactor(std::floor(theta0XZ / m_theta0XZBinSize));
 
         if (angularDecompositionMap.find(theta0XZFactor) == angularDecompositionMap.end())
             angularDecompositionMap[theta0XZFactor] = 1;
         else
             angularDecompositionMap[theta0XZFactor] += 1;
     }
 }

void lar_content::PeakDirectionFinderTool::GetAngularExtrema	(	const pandora::CaloHitList &	showerHitList,
		const pandora::CartesianVector &	nuVertex2D,
		float &	lowestTheta,
		float &	highestTheta
	)		const

private

Determine the angle (from the +ve drift-axis) of the shower cone boundaries (originating from the nu vertex)

Parameters

showerHitList	the 2D shower hit list
nuVertex2D	the 2D neutrino vertex
lowestTheta	the lower angle boundary
highestTheta	the higher angle boundary

Definition at line 92 of file PeakDirectionFinderTool.cc.

References f.

Referenced by CollectHitsWithinROI().

 {
     lowestTheta = std::numeric_limits<float>::max();
     highestTheta = (-1.f) * std::numeric_limits<float>::max();
 
     const CartesianVector xAxis(1.f, 0.f, 0.f);
 
     for (const CaloHit *const pCaloHit : showerHitList)
     {
         const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
         const CartesianVector displacementVector(hitPosition - nuVertex2D);
 
         float theta0XZ(xAxis.GetOpeningAngle(displacementVector));
 
         if (displacementVector.GetZ() < 0.f)
             theta0XZ = (2.0 * M_PI) - theta0XZ;
 
         if (theta0XZ < lowestTheta)
             lowestTheta = theta0XZ;
 
         if (theta0XZ > highestTheta)
             highestTheta = theta0XZ;
     }
 }

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

private

Definition at line 274 of file PeakDirectionFinderTool.cc.

References m_ambiguousParticleMode, m_pathwaySearchRegion, m_smoothingWindow, and m_theta0XZBinSize.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PathwaySearchRegion", m_pathwaySearchRegion));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Theta0XZBinSize", m_theta0XZBinSize));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SmoothingWindow", m_smoothingWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "AmbiguousParticleMode", m_ambiguousParticleMode));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::PeakDirectionFinderTool::RetrievePeakDirections	(	const AngularDecompositionMap &	angularDecompositionMap,
		pandora::CartesianPointVector &	peakDirectionVector
	)		const

private

Obtain a vector of directions from the angular distribution peaks.

Parameters

angularDecompositionMap	the [angle from drift-axis -> weight] map
peakDirectionVector	the output peak direction vector

Definition at line 201 of file PeakDirectionFinderTool.cc.

References f, and m_theta0XZBinSize.

Referenced by Run().

 {
     IntVector orderedBinIndexVector;
 
     for (const auto &entry : angularDecompositionMap)
         orderedBinIndexVector.push_back(entry.first);
 
     // Order peak bin vector from highest to lowest bin height
     // Tie-break: highest index wins
     std::sort(orderedBinIndexVector.begin(), orderedBinIndexVector.end(),
         [&angularDecompositionMap](const int a, const int b) -> bool
         {
             const float aWeight(angularDecompositionMap.at(a));
             const float bWeight(angularDecompositionMap.at(b));
 
             if (std::fabs(aWeight - bWeight) < std::numeric_limits<float>::epsilon())
                 return a > b;
             else
                 return aWeight > bWeight;
         });
 
     for (int binIndex : orderedBinIndexVector)
     {
         const float binWeight(angularDecompositionMap.at(binIndex));
 
         int precedingBin(binIndex - 1);
         bool foundPreceeding(false);
 
         while (!foundPreceeding)
         {
             if ((angularDecompositionMap.find(precedingBin) == angularDecompositionMap.end()) ||
                 (std::fabs(angularDecompositionMap.at(precedingBin) - angularDecompositionMap.at(binIndex)) > std::numeric_limits<float>::epsilon()))
             {
                 foundPreceeding = true;
                 break;
             }
 
             --precedingBin;
         }
 
         int followingBin(binIndex + 1);
         bool foundFollowing(false);
 
         while (!foundFollowing)
         {
             if ((angularDecompositionMap.find(followingBin) == angularDecompositionMap.end()) ||
                 (std::fabs(angularDecompositionMap.at(followingBin) - angularDecompositionMap.at(binIndex)) > std::numeric_limits<float>::epsilon()))
             {
                 foundFollowing = true;
                 break;
             }
 
             ++followingBin;
         }
 
         const float precedingBinWeight(
             angularDecompositionMap.find(precedingBin) == angularDecompositionMap.end() ? 0.f : angularDecompositionMap.at(precedingBin));
         const float followingBinWeight(
             angularDecompositionMap.find(followingBin) == angularDecompositionMap.end() ? 0.f : angularDecompositionMap.at(followingBin));
 
         if ((binWeight < precedingBinWeight) || (binWeight < followingBinWeight))
             continue;
 
         // Convert to a direction
         const float theta0XZ(binIndex * m_theta0XZBinSize);
         const CartesianVector peakDirection(std::cos(theta0XZ), 0.f, std::sin(theta0XZ));
 
         peakDirectionVector.push_back(peakDirection);
     }
 }

StatusCode lar_content::PeakDirectionFinderTool::Run	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CartesianVector &	nuVertex3D,
		const pandora::CaloHitList *const	pViewHitList,
		const pandora::HitType	hitType,
		pandora::CartesianPointVector &	peakDirectionVector
	)

Definition at line 32 of file PeakDirectionFinderTool.cc.

References CollectHitsWithinROI(), FillAngularDecompositionMap(), lar_content::LArPfoHelper::GetCaloHits(), lar_content::LArGeometryHelper::ProjectPosition(), RetrievePeakDirections(), and SmoothAngularDecompositionMap().

Referenced by lar_content::ElectronInitialRegionRefinementAlgorithm::BuildViewPathways(), and lar_content::ElectronInitialRegionRefinementAlgorithm::BuildViewProtoShowers().

 {
     CaloHitList viewShowerHitList;
     LArPfoHelper::GetCaloHits(pShowerPfo, hitType, viewShowerHitList);
 
     const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
 
     // Get event hits in region of interest
     CaloHitList viewROIHits;
     this->CollectHitsWithinROI(viewShowerHitList, pViewHitList, nuVertex2D, viewROIHits);
 
     if (viewROIHits.empty())
         return STATUS_CODE_NOT_FOUND;
 
     // Fill angular decomposition map
     AngularDecompositionMap angularDecompositionMap;
     this->FillAngularDecompositionMap(viewROIHits, nuVertex2D, angularDecompositionMap);
 
     if (angularDecompositionMap.empty())
         return STATUS_CODE_NOT_FOUND;
 
     // Smooth angular decomposition map
     this->SmoothAngularDecompositionMap(angularDecompositionMap);
 
     // Get peak directions
     this->RetrievePeakDirections(angularDecompositionMap, peakDirectionVector);
 
     if (peakDirectionVector.empty())
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::PeakDirectionFinderTool::SmoothAngularDecompositionMap ( AngularDecompositionMap & angularDecompositionMap ) const

private

Smooth the ROI angular angular distribution.

Parameters

angularDecompositionMap the [angle from drift-axis -> weight] map

Definition at line 173 of file PeakDirectionFinderTool.cc.

References f, and m_smoothingWindow.

Referenced by Run().

 {
     const int loopMin((-1) * m_smoothingWindow);
     const int loopMax(m_smoothingWindow);
 
     const AngularDecompositionMap angularDecompositionMapTemp(angularDecompositionMap);
 
     angularDecompositionMap.clear();
 
     for (const auto &entry : angularDecompositionMapTemp)
     {
         float total(0.f);
         const int currentBin(entry.first);
 
         for (int binOffset = loopMin; binOffset <= loopMax; ++binOffset)
         {
             const int contributingBin = currentBin + binOffset;
             total += (angularDecompositionMapTemp.find(contributingBin) == angularDecompositionMapTemp.end())
                 ? 0.f
                 : angularDecompositionMapTemp.at(contributingBin);
         }
 
         angularDecompositionMap[currentBin] = total / static_cast<float>((2.0 * m_smoothingWindow) + 1);
     }
 }

Member Data Documentation

bool lar_content::PeakDirectionFinderTool::m_ambiguousParticleMode

private

Whether to find the initial pathway direction of the shower or of the other event particles.

Definition at line 96 of file PeakDirectionFinderTool.h.

Referenced by CollectHitsWithinROI(), and ReadSettings().

float lar_content::PeakDirectionFinderTool::m_pathwaySearchRegion

private

The initial shower cone distance.

Definition at line 93 of file PeakDirectionFinderTool.h.

Referenced by FillAngularDecompositionMap(), and ReadSettings().

int lar_content::PeakDirectionFinderTool::m_smoothingWindow

private

On each side, the number of neighbouring bins with which each bin is averaged.

Definition at line 95 of file PeakDirectionFinderTool.h.

Referenced by ReadSettings(), and SmoothAngularDecompositionMap().

float lar_content::PeakDirectionFinderTool::m_theta0XZBinSize

private

The angular distribution bin size.

Definition at line 94 of file PeakDirectionFinderTool.h.

Referenced by FillAngularDecompositionMap(), ReadSettings(), and RetrievePeakDirections().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArShowerRefinement/PeakDirectionFinderTool.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArShowerRefinement/PeakDirectionFinderTool.cc

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation