#include <RPhiFeatureTool.h>

Inheritance diagram for lar_content::RPhiFeatureTool:

Classes
class	KernelEstimate
	Kernel estimate class. More...

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

void	Run (LArMvaHelper::MvaFeatureVector &featureVector, const VertexSelectionBaseAlgorithm const pAlgorithm, const pandora::Vertex const pVertex, const VertexSelectionBaseAlgorithm::SlidingFitDataListMap &, const VertexSelectionBaseAlgorithm::ClusterListMap &, const VertexSelectionBaseAlgorithm::KDTreeMap &kdTreeMap, const VertexSelectionBaseAlgorithm::ShowerClusterListMap &, const float beamDeweightingScore, float &bestFastScore)
	Run the tool. More...

Public Member Functions inherited from lar_content::MvaFeatureTool< Ts >
	MvaFeatureTool ()=default
	Default constructor. More...

virtual void	Run (MvaTypes::MvaFeatureVector &featureVector, Ts...args)=0
	Run the algorithm tool. More...

virtual void	Run (MvaTypes::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName, Ts...args)

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

float	GetFastScore (const KernelEstimate &kernelEstimateU, const KernelEstimate &kernelEstimateV, const KernelEstimate &kernelEstimateW) const
	Get the score for a trio of kernel estimations, using fast histogram approach. More...

float	GetMidwayScore (const KernelEstimate &kernelEstimateU, const KernelEstimate &kernelEstimateV, const KernelEstimate &kernelEstimateW) const
	Get the score for a trio of kernel estimations, using kernel density estimation but with reduced (binned) sampling. More...

float	GetFullScore (const KernelEstimate &kernelEstimateU, const KernelEstimate &kernelEstimateV, const KernelEstimate &kernelEstimateW) const
	Get the score for a trio of kernel estimations, using kernel density estimation and full hit-by-hit sampling. More...

void	FillKernelEstimate (const pandora::Vertex *const pVertex, const pandora::HitType hitType, VertexSelectionBaseAlgorithm::HitKDTree2D &kdTree, KernelEstimate &kernelEstimate) const
	Use hits in clusters (in the provided kd tree) to fill a provided kernel estimate with hit-vertex relationship information. More...

bool	AcceptVertexLocation (const pandora::Vertex *const pVertex, const pandora::VertexList &selectedVertexList) const
	Whether to accept a candidate vertex, based on its spatial position in relation to other selected candidates. More...

float	atan2Fast (const float y, const float x) const
	Fast estimate of std::atan2 function. Rather coarse (max \|error\| > 0.01) but should suffice for this use-case. More...

Private Attributes
bool	m_fastScoreCheck
	Whether to use the fast histogram based score to selectively avoid calling full or midway scores. More...

bool	m_fastScoreOnly
	Whether to use the fast histogram based score only. More...

bool	m_fullScore
	Whether to use the full kernel density estimation score, as opposed to the midway score. More...

float	m_kernelEstimateSigma
	The Gaussian width to use for kernel estimation. More...

float	m_kappa
	Hit-deweighting offset, of form: weight = 1 / sqrt(distance + kappa), units cm. More...

float	m_maxHitVertexDisplacement1D
	Max hit-vertex displacement in any one dimension for contribution to kernel estimation. More...

float	m_minFastScoreFraction
	Fast score must be at least this fraction of best fast score to calculate full score. More...

unsigned int	m_fastHistogramNPhiBins
	Number of bins to use for fast score histograms. More...

float	m_fastHistogramPhiMin
	Min value for fast score histograms. More...

float	m_fastHistogramPhiMax
	Max value for fast score histograms. More...

bool	m_enableFolding
	Whether to enable folding of -pi -> +pi phi distribution into 0 -> +pi region only. More...

Additional Inherited Members
Public Types inherited from lar_content::MvaFeatureTool< Ts >
typedef std::vector < MvaFeatureTool< Ts...> * >	FeatureToolVector

typedef std::map< std::string, MvaFeatureTool< Ts...> * >	FeatureToolMap

Detailed Description

RPhiFeatureTool class.

Definition at line 21 of file RPhiFeatureTool.h.

Constructor & Destructor Documentation

lar_content::RPhiFeatureTool::RPhiFeatureTool ( )

Default constructor.

Definition at line 21 of file RPhiFeatureTool.cc.

                                  :
     m_fastScoreCheck(true),
     m_fastScoreOnly(false),
     m_fullScore(false),
     m_kernelEstimateSigma(0.048f),
     m_kappa(0.42f),
     m_maxHitVertexDisplacement1D(100.f),
     m_minFastScoreFraction(0.8f),
     m_fastHistogramNPhiBins(200),
     m_fastHistogramPhiMin(-1.1f * M_PI),
     m_fastHistogramPhiMax(+1.1f * M_PI),
     m_enableFolding(true)
 {
 }

Member Function Documentation

bool lar_content::RPhiFeatureTool::AcceptVertexLocation	(	const pandora::Vertex *const	pVertex,
		const pandora::VertexList &	selectedVertexList
	)		const

private

Whether to accept a candidate vertex, based on its spatial position in relation to other selected candidates.

Parameters

pVertex	the address of the vertex
selectedVertexList	the selected vertex list

Returns: boolean

float lar_content::RPhiFeatureTool::atan2Fast	(	const float	y,
		const float	x
	)		const

private

Fast estimate of std::atan2 function. Rather coarse (max |error| > 0.01) but should suffice for this use-case.

Parameters

y	the y coordinate
x	the x coordinate

Returns: estimate of std::atan2

Definition at line 198 of file RPhiFeatureTool.cc.

 {
     const float ONE_QTR_PI(0.25f * M_PI);
     const float THR_QTR_PI(0.75f * M_PI);
 
     const float abs_y(std::max(std::fabs(y), std::numeric_limits<float>::epsilon()));
     const float abs_x(std::fabs(x));
 
     const float r((x < 0.f) ? (x + abs_y) / (abs_y + abs_x) : (abs_x - abs_y) / (abs_x + abs_y));
     const float angle(((x < 0.f) ? THR_QTR_PI : ONE_QTR_PI) + (0.1963f * r * r - 0.9817f) * r);
 
     return ((y < 0.f) ? -angle : angle); // negate if in quad III or IV
 }

void lar_content::RPhiFeatureTool::FillKernelEstimate	(	const pandora::Vertex *const	pVertex,
		const pandora::HitType	hitType,
		VertexSelectionBaseAlgorithm::HitKDTree2D &	kdTree,
		KernelEstimate &	kernelEstimate
	)		const

private

Use hits in clusters (in the provided kd tree) to fill a provided kernel estimate with hit-vertex relationship information.

Parameters

pVertex	the address of the vertex
hitType	the relevant hit type
kdTree	the relevant kd tree
kernelEstimate	to receive the populated kernel estimate

Definition at line 166 of file RPhiFeatureTool.cc.

 {
     const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));
     KDTreeBox searchRegionHits = build_2d_kd_search_region(vertexPosition2D, m_maxHitVertexDisplacement1D, m_maxHitVertexDisplacement1D);
 
     VertexSelectionBaseAlgorithm::HitKDNode2DList found;
     kdTree.search(searchRegionHits, found);
 
     for (const auto &hit : found)
     {
         const CartesianVector displacement(hit.data->GetPositionVector() - vertexPosition2D);
         const float magnitude(displacement.GetMagnitude());
 
         if (magnitude < std::numeric_limits<float>::epsilon())
             continue;
 
         float phi(this->atan2Fast(displacement.GetZ(), displacement.GetX()));
         float weight(1.f / (std::sqrt(magnitude + std::fabs(m_kappa))));
 
         if (m_enableFolding && (phi < 0.f))
         {
             phi += M_PI;
             weight *= -1.f;
         }
 
         kernelEstimate.AddContribution(phi, weight);
     }
 }

float lar_content::RPhiFeatureTool::GetFastScore	(	const KernelEstimate &	kernelEstimateU,
		const KernelEstimate &	kernelEstimateV,
		const KernelEstimate &	kernelEstimateW
	)		const

private

Get the score for a trio of kernel estimations, using fast histogram approach.

Parameters

kernelEstimateU	the kernel estimate for the u view
kernelEstimateV	the kernel estimate for the v view
kernelEstimateW	the kernel estimate for the w view

Returns: the fast score

Definition at line 82 of file RPhiFeatureTool.cc.

 {
     Histogram histogramU(m_fastHistogramNPhiBins, m_fastHistogramPhiMin, m_fastHistogramPhiMax);
     Histogram histogramV(m_fastHistogramNPhiBins, m_fastHistogramPhiMin, m_fastHistogramPhiMax);
     Histogram histogramW(m_fastHistogramNPhiBins, m_fastHistogramPhiMin, m_fastHistogramPhiMax);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateU.GetContributionList())
         histogramU.Fill(contribution.first, contribution.second);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateV.GetContributionList())
         histogramV.Fill(contribution.first, contribution.second);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateW.GetContributionList())
         histogramW.Fill(contribution.first, contribution.second);
 
     // Is the below correct?
     histogramU.Scale(1.f / histogramU.GetCumulativeSum());
     histogramV.Scale(1.f / histogramV.GetCumulativeSum());
     histogramW.Scale(1.f / histogramW.GetCumulativeSum());
 
     // ATTN Need to renormalise histograms if ever want to directly compare fast and full scores
     float figureOfMerit(0.f);
 
     for (int xBin = 0; xBin < histogramU.GetNBinsX(); ++xBin)
     {
         const float binContentU(histogramU.GetBinContent(xBin));
         const float binContentV(histogramV.GetBinContent(xBin));
         const float binContentW(histogramW.GetBinContent(xBin));
         figureOfMerit += binContentU * binContentU + binContentV * binContentV + binContentW * binContentW;
     }
 
     return figureOfMerit;
 }

float lar_content::RPhiFeatureTool::GetFullScore	(	const KernelEstimate &	kernelEstimateU,
		const KernelEstimate &	kernelEstimateV,
		const KernelEstimate &	kernelEstimateW
	)		const

private

Get the score for a trio of kernel estimations, using kernel density estimation and full hit-by-hit sampling.

Parameters

kernelEstimateU	the kernel estimate for the u view
kernelEstimateV	the kernel estimate for the v view
kernelEstimateW	the kernel estimate for the w view

Returns: the full score

Definition at line 148 of file RPhiFeatureTool.cc.

 {
     float figureOfMerit(0.f);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateU.GetContributionList())
         figureOfMerit += contribution.second * kernelEstimateU.Sample(contribution.first);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateV.GetContributionList())
         figureOfMerit += contribution.second * kernelEstimateV.Sample(contribution.first);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateW.GetContributionList())
         figureOfMerit += contribution.second * kernelEstimateW.Sample(contribution.first);
 
     return figureOfMerit;
 }

float lar_content::RPhiFeatureTool::GetMidwayScore	(	const KernelEstimate &	kernelEstimateU,
		const KernelEstimate &	kernelEstimateV,
		const KernelEstimate &	kernelEstimateW
	)		const

private

Get the score for a trio of kernel estimations, using kernel density estimation but with reduced (binned) sampling.

Parameters

kernelEstimateU	the kernel estimate for the u view
kernelEstimateV	the kernel estimate for the v view
kernelEstimateW	the kernel estimate for the w view

Returns: the midway score

Definition at line 118 of file RPhiFeatureTool.cc.

 {
     Histogram histogramU(m_fastHistogramNPhiBins, m_fastHistogramPhiMin, m_fastHistogramPhiMax);
     Histogram histogramV(m_fastHistogramNPhiBins, m_fastHistogramPhiMin, m_fastHistogramPhiMax);
     Histogram histogramW(m_fastHistogramNPhiBins, m_fastHistogramPhiMin, m_fastHistogramPhiMax);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateU.GetContributionList())
         histogramU.Fill(contribution.first, contribution.second);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateV.GetContributionList())
         histogramV.Fill(contribution.first, contribution.second);
 
     for (const KernelEstimate::ContributionList::value_type &contribution : kernelEstimateW.GetContributionList())
         histogramW.Fill(contribution.first, contribution.second);
 
     float figureOfMerit(0.f);
 
     for (int xBin = 0; xBin < histogramU.GetNBinsX(); ++xBin)
     {
         const float binCenter(histogramU.GetXLow() + (static_cast<float>(xBin) + 0.5f) * histogramU.GetXBinWidth());
         figureOfMerit += histogramU.GetBinContent(xBin) * kernelEstimateU.Sample(binCenter);
         figureOfMerit += histogramV.GetBinContent(xBin) * kernelEstimateV.Sample(binCenter);
         figureOfMerit += histogramW.GetBinContent(xBin) * kernelEstimateW.Sample(binCenter);
     }
 
     return figureOfMerit;
 }

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

private

Definition at line 243 of file RPhiFeatureTool.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FastScoreCheck", m_fastScoreCheck));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FastScoreOnly", m_fastScoreOnly));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FullScore", m_fullScore));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "KernelEstimateSigma", m_kernelEstimateSigma));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Kappa", m_kappa));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxHitVertexDisplacement1D", m_maxHitVertexDisplacement1D));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinFastScoreFraction", m_minFastScoreFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FastHistogramNPhiBins", m_fastHistogramNPhiBins));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FastHistogramPhiMin", m_fastHistogramPhiMin));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FastHistogramPhiMax", m_fastHistogramPhiMax));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EnableFolding", m_enableFolding));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::RPhiFeatureTool::Run	(	LArMvaHelper::MvaFeatureVector &	featureVector,
		const VertexSelectionBaseAlgorithm *const	pAlgorithm,
		const pandora::Vertex *const	pVertex,
		const VertexSelectionBaseAlgorithm::SlidingFitDataListMap &	,
		const VertexSelectionBaseAlgorithm::ClusterListMap &	,
		const VertexSelectionBaseAlgorithm::KDTreeMap &	kdTreeMap,
		const VertexSelectionBaseAlgorithm::ShowerClusterListMap &	,
		const float	beamDeweightingScore,
		float &	bestFastScore
	)

Run the tool.

Parameters

pAlgorithm	address of the calling algorithm
pVertex	address of the vertex
kdTreeMap	map of the hit kd trees
beamDeweightingScore	the beam deweighting score for this vertex
bestFastScore	the best fast score

Returns: the r/phi feature

Definition at line 38 of file RPhiFeatureTool.cc.

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     KernelEstimate kernelEstimateU(m_kernelEstimateSigma);
     KernelEstimate kernelEstimateV(m_kernelEstimateSigma);
     KernelEstimate kernelEstimateW(m_kernelEstimateSigma);
 
     this->FillKernelEstimate(pVertex, TPC_VIEW_U, kdTreeMap.at(TPC_VIEW_U), kernelEstimateU);
     this->FillKernelEstimate(pVertex, TPC_VIEW_V, kdTreeMap.at(TPC_VIEW_V), kernelEstimateV);
     this->FillKernelEstimate(pVertex, TPC_VIEW_W, kdTreeMap.at(TPC_VIEW_W), kernelEstimateW);
 
     const float expBeamDeweightingScore = std::exp(beamDeweightingScore);
 
     if (m_fastScoreCheck || m_fastScoreOnly)
     {
         const float fastScore(this->GetFastScore(kernelEstimateU, kernelEstimateV, kernelEstimateW));
 
         if (m_fastScoreOnly)
         {
             featureVector.push_back(fastScore);
             return;
         }
 
         if (expBeamDeweightingScore * fastScore < m_minFastScoreFraction * bestFastScore)
         {
             featureVector.push_back(0.);
             return;
         }
 
         if (expBeamDeweightingScore * fastScore > bestFastScore)
             bestFastScore = expBeamDeweightingScore * fastScore;
     }
 
     featureVector.push_back(m_fullScore ? this->GetFullScore(kernelEstimateU, kernelEstimateV, kernelEstimateW)
                                         : this->GetMidwayScore(kernelEstimateU, kernelEstimateV, kernelEstimateW));
 }

Member Data Documentation

bool lar_content::RPhiFeatureTool::m_enableFolding

private

Whether to enable folding of -pi -> +pi phi distribution into 0 -> +pi region only.

Definition at line 178 of file RPhiFeatureTool.h.

unsigned int lar_content::RPhiFeatureTool::m_fastHistogramNPhiBins

private

Number of bins to use for fast score histograms.

Definition at line 174 of file RPhiFeatureTool.h.

float lar_content::RPhiFeatureTool::m_fastHistogramPhiMax

private

Max value for fast score histograms.

Definition at line 176 of file RPhiFeatureTool.h.

float lar_content::RPhiFeatureTool::m_fastHistogramPhiMin

private

Min value for fast score histograms.

Definition at line 175 of file RPhiFeatureTool.h.

bool lar_content::RPhiFeatureTool::m_fastScoreCheck

private

Whether to use the fast histogram based score to selectively avoid calling full or midway scores.

Definition at line 165 of file RPhiFeatureTool.h.

bool lar_content::RPhiFeatureTool::m_fastScoreOnly

private

Whether to use the fast histogram based score only.

Definition at line 166 of file RPhiFeatureTool.h.

bool lar_content::RPhiFeatureTool::m_fullScore

private

Whether to use the full kernel density estimation score, as opposed to the midway score.

Definition at line 167 of file RPhiFeatureTool.h.

float lar_content::RPhiFeatureTool::m_kappa

private

Hit-deweighting offset, of form: weight = 1 / sqrt(distance + kappa), units cm.

Definition at line 170 of file RPhiFeatureTool.h.

float lar_content::RPhiFeatureTool::m_kernelEstimateSigma

private

The Gaussian width to use for kernel estimation.

Definition at line 169 of file RPhiFeatureTool.h.

float lar_content::RPhiFeatureTool::m_maxHitVertexDisplacement1D

private

Max hit-vertex displacement in any one dimension for contribution to kernel estimation.

Definition at line 171 of file RPhiFeatureTool.h.

float lar_content::RPhiFeatureTool::m_minFastScoreFraction

private

Fast score must be at least this fraction of best fast score to calculate full score.

Definition at line 173 of file RPhiFeatureTool.h.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation