ThreeDOpeningAngleFeatureTool class for the calculation of distance to neutrino vertex. More...

#include "TrackShowerIdFeatureTool.h"

Inheritance diagram for lar_content::ThreeDOpeningAngleFeatureTool:

Public Types
typedef std::vector< MvaFeatureTool< Ts... > * >	FeatureToolVector

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

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

void	Run (LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pInputPfo)

void	Run (LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName, const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pInputPfo)

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...)

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

void	Divide3DCaloHitList (const pandora::Algorithm *const pAlgorithm, const pandora::CaloHitList &threeDCaloHitList, pandora::CartesianPointVector &pointVectorStart, pandora::CartesianPointVector &pointVectorEnd)
	Obtain positions at the vertex and non-vertex end of a list of three dimensional calo hits. More...

float	OpeningAngle (const pandora::CartesianVector &principal, const pandora::CartesianVector &secondary, const pandora::CartesianVector &eigenValues) const
	Use the results of principal component analysis to calculate an opening angle. More...

Private Attributes
float	m_hitFraction
	Fraction of hits in start and end of pfo. More...

float	m_defaultValue
	Default value to return, in case calculation not feasible. More...

Detailed Description

ThreeDOpeningAngleFeatureTool class for the calculation of distance to neutrino vertex.

Definition at line 271 of file TrackShowerIdFeatureTool.h.

Member Typedef Documentation

template<typename... Ts>

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

inherited

Definition at line 37 of file LArMvaHelper.h.

template<typename... Ts>

typedef std::vector<MvaFeatureTool<Ts...> *> lar_content::MvaFeatureTool< Ts >::FeatureToolVector

inherited

Definition at line 36 of file LArMvaHelper.h.

Constructor & Destructor Documentation

lar_content::ThreeDOpeningAngleFeatureTool::ThreeDOpeningAngleFeatureTool ( )

Default constructor.

Definition at line 811 of file TrackShowerIdFeatureTool.cc.

                                                              :
     m_hitFraction(0.5f),
     m_defaultValue(0.1f)
 {
 }

Member Function Documentation

void lar_content::ThreeDOpeningAngleFeatureTool::Divide3DCaloHitList	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::CaloHitList &	threeDCaloHitList,
		pandora::CartesianPointVector &	pointVectorStart,
		pandora::CartesianPointVector &	pointVectorEnd
	)

private

Obtain positions at the vertex and non-vertex end of a list of three dimensional calo hits.

Parameters

threeDCaloHitList	the list of three dimensional calo hits
pointVectorStart	to receive the positions at the start/vertex region
pointVectorEnd	to receive the positions at the end region (opposite end to vertex)

Definition at line 886 of file TrackShowerIdFeatureTool.cc.

References f, and m_hitFraction.

Referenced by Run().

 {
     const VertexList *pVertexList(nullptr);
     (void)PandoraContentApi::GetCurrentList(*pAlgorithm, pVertexList);
 
     if (threeDCaloHitList.empty() || !pVertexList || pVertexList->empty())
         return;
 
     unsigned int nInteractionVertices(0);
     const Vertex *pInteractionVertex(nullptr);
 
     for (const Vertex *pVertex : *pVertexList)
     {
         if ((pVertex->GetVertexLabel() == VERTEX_INTERACTION) && (pVertex->GetVertexType() == VERTEX_3D))
         {
             ++nInteractionVertices;
             pInteractionVertex = pVertex;
         }
     }
 
     if (pInteractionVertex && (1 == nInteractionVertices))
     {
         // Order by distance to vertex, so first ones are closer to nuvertex
         CaloHitVector threeDCaloHitVector(threeDCaloHitList.begin(), threeDCaloHitList.end());
         std::sort(threeDCaloHitVector.begin(), threeDCaloHitVector.end(),
             ThreeDChargeFeatureTool::VertexComparator(pInteractionVertex->GetPosition()));
 
         unsigned int iHit(1);
         const unsigned int nHits(threeDCaloHitVector.size());
 
         for (const CaloHit *const pCaloHit : threeDCaloHitVector)
         {
             if (static_cast<float>(iHit) / static_cast<float>(nHits) <= m_hitFraction)
                 pointVectorStart.push_back(pCaloHit->GetPositionVector());
 
             if (static_cast<float>(iHit) / static_cast<float>(nHits) >= 1.f - m_hitFraction)
                 pointVectorEnd.push_back(pCaloHit->GetPositionVector());
 
             ++iHit;
         }
     }
 }

float lar_content::ThreeDOpeningAngleFeatureTool::OpeningAngle	(	const pandora::CartesianVector &	principal,
		const pandora::CartesianVector &	secondary,
		const pandora::CartesianVector &	eigenValues
	)		const

private

Use the results of principal component analysis to calculate an opening angle.

Parameters

principal	the principal axis
secondary	the secondary axis
eigenValues	the eigenvalues

Returns: the opening angle

Definition at line 932 of file TrackShowerIdFeatureTool.cc.

References f.

Referenced by Run().

 {
     const float principalMagnitude(principal.GetMagnitude());
     const float secondaryMagnitude(secondary.GetMagnitude());
 
     if (std::fabs(principalMagnitude) < std::numeric_limits<float>::epsilon())
     {
         std::cout << "ThreeDOpeningAngleFeatureTool::OpeningAngle - The principal eigenvector is 0." << std::endl;
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
     }
     else if (std::fabs(secondaryMagnitude) < std::numeric_limits<float>::epsilon())
     {
         return 0.f;
     }
 
     const float cosTheta(principal.GetDotProduct(secondary) / (principalMagnitude * secondaryMagnitude));
 
     if (cosTheta > 1.f)
     {
         std::cout << "PcaShowerParticleBuildingAlgorithm::OpeningAngle - cos(theta) reportedly greater than 1." << std::endl;
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
     }
 
     const float sinTheta(std::sqrt(1.f - cosTheta * cosTheta));
 
     if (eigenValues.GetX() < std::numeric_limits<float>::epsilon())
     {
         std::cout << "PcaShowerParticleBuildingAlgorithm::OpeningAngle - principal eigenvalue less than or equal to 0." << std::endl;
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
     }
     else if (eigenValues.GetY() < std::numeric_limits<float>::epsilon())
     {
         return 0.f;
     }
 
     return std::atan(std::sqrt(eigenValues.GetY()) * sinTheta / std::sqrt(eigenValues.GetX()));
 }

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

private

Definition at line 972 of file TrackShowerIdFeatureTool.cc.

References m_defaultValue, and m_hitFraction.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "HitFraction", m_hitFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DefaultValue", m_defaultValue));
 
     return STATUS_CODE_SUCCESS;
 }

template<typename... Ts>

virtual void lar_content::MvaFeatureTool< Ts >::Run	(	MvaTypes::MvaFeatureVector &	featureVector,
		Ts...	args
	)

pure virtualinherited

Run the algorithm tool.

Parameters

featureVector	the vector of features to append
args	arguments to pass to the tool

template<typename... Ts>

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

inlinevirtualinherited

Definition at line 51 of file LArMvaHelper.h.

     {
         (void)featureMap;
         (void)featureOrder;
         (void)featureToolName;
         return;
     };

void lar_content::ThreeDOpeningAngleFeatureTool::Run	(	LArMvaHelper::MvaFeatureVector &	featureVector,
		const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pInputPfo
	)

Definition at line 819 of file TrackShowerIdFeatureTool.cc.

References Divide3DCaloHitList(), f, lar_content::LArPfoHelper::GetCaloHits(), m_defaultValue, OpeningAngle(), and lar_content::LArPcaHelper::RunPca().

Referenced by lar_content::ThreeDPCAFeatureTool::Run().

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     // Need the 3D hits to calculate PCA components
     CaloHitList threeDCaloHitList;
     LArPfoHelper::GetCaloHits(pInputPfo, TPC_3D, threeDCaloHitList);
 
     LArMvaHelper::MvaFeature diffAngle;
     if (!threeDCaloHitList.empty())
     {
         CartesianPointVector pointVectorStart, pointVectorEnd;
         this->Divide3DCaloHitList(pAlgorithm, threeDCaloHitList, pointVectorStart, pointVectorEnd);
 
         // Able to calculate angles only if > 1 point provided
         if ((pointVectorStart.size() > 1) && (pointVectorEnd.size() > 1))
         {
             try
             {
                 // Run the PCA analysis twice
                 CartesianVector centroidStart(0.f, 0.f, 0.f), centroidEnd(0.f, 0.f, 0.f);
                 LArPcaHelper::EigenVectors eigenVecsStart, eigenVecsEnd;
                 LArPcaHelper::EigenValues eigenValuesStart(0.f, 0.f, 0.f), eigenValuesEnd(0.f, 0.f, 0.f);
 
                 LArPcaHelper::RunPca(pointVectorStart, centroidStart, eigenValuesStart, eigenVecsStart);
                 LArPcaHelper::RunPca(pointVectorEnd, centroidEnd, eigenValuesEnd, eigenVecsEnd);
 
                 const float openingAngle(this->OpeningAngle(eigenVecsStart.at(0), eigenVecsStart.at(1), eigenValuesStart));
                 const float closingAngle(this->OpeningAngle(eigenVecsEnd.at(0), eigenVecsEnd.at(1), eigenValuesEnd));
                 diffAngle = std::fabs(openingAngle - closingAngle);
             }
             catch (const StatusCodeException &)
             {
             }
         }
         else
         {
             diffAngle = m_defaultValue;
         }
     }
 
     featureVector.push_back(diffAngle);
 }

void lar_content::ThreeDOpeningAngleFeatureTool::Run	(	LArMvaHelper::MvaFeatureMap &	featureMap,
		pandora::StringVector &	featureOrder,
		const std::string &	featureToolName,
		const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pInputPfo
	)

Member Data Documentation

float lar_content::ThreeDOpeningAngleFeatureTool::m_defaultValue

private

Default value to return, in case calculation not feasible.

Definition at line 309 of file TrackShowerIdFeatureTool.h.

Referenced by ReadSettings(), and Run().

float lar_content::ThreeDOpeningAngleFeatureTool::m_hitFraction

private

Fraction of hits in start and end of pfo.

Definition at line 308 of file TrackShowerIdFeatureTool.h.

Referenced by Divide3DCaloHitList(), and ReadSettings().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArTrackShowerId/TrackShowerIdFeatureTool.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArTrackShowerId/TrackShowerIdFeatureTool.cc

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation