lar_content::ThreeDOpeningAngleFeatureTool Class Reference

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

#include <TrackShowerIdFeatureTool.h>

Inheritance diagram for lar_content::ThreeDOpeningAngleFeatureTool:

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

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

ThreeDOpeningAngleFeatureTool class for the calculation of distance to neutrino vertex.

Definition at line 271 of file TrackShowerIdFeatureTool.h.

Constructor & Destructor Documentation

lar_content::ThreeDOpeningAngleFeatureTool::ThreeDOpeningAngleFeatureTool

(

)

Default constructor.

Definition at line 804 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 877 of file TrackShowerIdFeatureTool.cc.

{
    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 923 of file TrackShowerIdFeatureTool.cc.

{
    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 963 of file TrackShowerIdFeatureTool.cc.

{
    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;
}

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

Definition at line 810 of file TrackShowerIdFeatureTool.cc.

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

float lar_content::ThreeDOpeningAngleFeatureTool::m_hitFraction

private

Fraction of hits in start and end of pfo.

Definition at line 308 of file TrackShowerIdFeatureTool.h.

---

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

• TrackShowerIdFeatureTool.h
• TrackShowerIdFeatureTool.cc