lar_content::NeutrinoIdTool< T >::SliceFeatures Class Reference

Slice features class. More...

Public Member Functions
	SliceFeatures (const pandora::PfoList &nuPfos, const pandora::PfoList &crPfos, const NeutrinoIdTool *const pTool)
	Constructor. More...
bool	IsFeatureVectorAvailable () const
	Check if all features were calculable. More...
void	GetFeatureVector (LArMvaHelper::MvaFeatureVector &featureVector) const
	Get the feature vector for the MVA. More...
void	GetFeatureMap (LArMvaHelper::DoubleMap &featureMap) const
	Get the feature map for the MVA. More...
float	GetNeutrinoProbability (const T &t) const
	Get the probability that this slice contains a neutrino interaction. More...

Private Member Functions
const pandora::ParticleFlowObject *	GetNeutrino (const pandora::PfoList &nuPfos) const
	Get the recontructed neutrino the input list of neutrino Pfos. More...
void	GetSpacePoints (const pandora::ParticleFlowObject *const pPfo, pandora::CartesianPointVector &spacePoints) const
	Get the 3D space points in a given pfo. More...
pandora::CartesianVector	GetDirection (const pandora::CartesianPointVector &spacePoints, std::function< bool(const pandora::CartesianVector &pointA, const pandora::CartesianVector &pointB)> fShouldChooseA) const
	Use a sliding fit to get the direction of a collection of spacepoints. More...
pandora::CartesianVector	GetDirectionFromVertex (const pandora::CartesianPointVector &spacePoints, const pandora::CartesianVector &vertex) const
	Use a sliding fit to get the direction of a collection of spacepoint near a vertex position. More...
pandora::CartesianVector	GetUpperDirection (const pandora::CartesianPointVector &spacePoints) const
	Use a sliding fit to get the upper direction of a collection of spacepoints. More...
pandora::CartesianVector	GetLowerDirection (const pandora::CartesianPointVector &spacePoints) const
	Use a sliding fit to get the lower direction of a collection of spacepoints. More...
void	GetPointsInSphere (const pandora::CartesianPointVector &spacePoints, const pandora::CartesianVector &vertex, const float radius, pandora::CartesianPointVector &spacePointsInSphere) const
	Get a vector of spacepoints within a given radius of a vertex point. More...

Private Attributes
bool	m_isAvailable
	Is the feature vector available. More...
LArMvaHelper::MvaFeatureVector	m_featureVector
	The MVA feature vector. More...
LArMvaHelper::DoubleMap	m_featureMap
	A map between MVA features and their names. More...
const NeutrinoIdTool *const	m_pTool
	The tool that owns this. More...

Detailed Description

template<typename T>
class lar_content::NeutrinoIdTool< T >::SliceFeatures

Slice features class.

Definition at line 47 of file NeutrinoIdTool.h.

Constructor & Destructor Documentation

template<typename T>

lar_content::NeutrinoIdTool< T >::SliceFeatures::SliceFeatures	(	const pandora::PfoList &	nuPfos,
		const pandora::PfoList &	crPfos,
		const NeutrinoIdTool *const	pTool
	)

Constructor.

Parameters

nuPfos	input list of Pfos reconstructed under the neutrino hypothesis
crPfos	input list of Pfos reconstructed under the cosmic ray hypothesis
pTool	address of the tool using this class

Definition at line 330 of file NeutrinoIdTool.cc.

                                                                                                                                :
    m_isAvailable(false),
    m_pTool(pTool)
{
    try
    {
        const ParticleFlowObject *const pNeutrino(this->GetNeutrino(nuPfos));
        const CartesianVector &nuVertex(LArPfoHelper::GetVertex(pNeutrino)->GetPosition());
        const PfoList &nuFinalStates(pNeutrino->GetDaughterPfoList());

        // Neutrino features
        CartesianVector nuWeightedDirTotal(0.f, 0.f, 0.f);
        unsigned int nuNHitsUsedTotal(0);
        unsigned int nuNHitsTotal(0);
        CartesianPointVector nuAllSpacePoints;
        for (const ParticleFlowObject *const pPfo : nuFinalStates)
        {
            CartesianPointVector spacePoints;
            this->GetSpacePoints(pPfo, spacePoints);

            nuAllSpacePoints.insert(nuAllSpacePoints.end(), spacePoints.begin(), spacePoints.end());
            nuNHitsTotal += spacePoints.size();

            if (spacePoints.size() < 5)
                continue;

            const CartesianVector dir(this->GetDirectionFromVertex(spacePoints, nuVertex));
            nuWeightedDirTotal += dir * static_cast<float>(spacePoints.size());
            nuNHitsUsedTotal += spacePoints.size();
        }

        if (nuNHitsUsedTotal == 0)
            return;
        const CartesianVector nuWeightedDir(nuWeightedDirTotal * (1.f / static_cast<float>(nuNHitsUsedTotal)));

        CartesianPointVector pointsInSphere;
        this->GetPointsInSphere(nuAllSpacePoints, nuVertex, 10, pointsInSphere);

        CartesianVector centroid(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
        LArPcaHelper::EigenValues eigenValues(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
        LArPcaHelper::EigenVectors eigenVectors;
        LArPcaHelper::RunPca(pointsInSphere, centroid, eigenValues, eigenVectors);

        const float nuNFinalStatePfos(static_cast<float>(nuFinalStates.size()));
        const float nuVertexY(nuVertex.GetY());
        const float nuWeightedDirZ(nuWeightedDir.GetZ());
        const float nuNSpacePointsInSphere(static_cast<float>(pointsInSphere.size()));

        if (eigenValues.GetX() <= std::numeric_limits<float>::epsilon())
            return;
        const float nuEigenRatioInSphere(eigenValues.GetY() / eigenValues.GetX());

        // Cosmic-ray features
        unsigned int nCRHitsMax(0);
        unsigned int nCRHitsTotal(0);
        float crLongestTrackDirY(std::numeric_limits<float>::max());
        float crLongestTrackDeflection(-std::numeric_limits<float>::max());

        for (const ParticleFlowObject *const pPfo : crPfos)
        {
            CartesianPointVector spacePoints;
            this->GetSpacePoints(pPfo, spacePoints);

            nCRHitsTotal += spacePoints.size();

            if (spacePoints.size() < 5)
                continue;

            if (spacePoints.size() > nCRHitsMax)
            {
                nCRHitsMax = spacePoints.size();
                const CartesianVector upperDir(this->GetUpperDirection(spacePoints));
                const CartesianVector lowerDir(this->GetLowerDirection(spacePoints));

                crLongestTrackDirY = upperDir.GetY();
                crLongestTrackDeflection = 1.f - upperDir.GetDotProduct(lowerDir * (-1.f));
            }
        }

        if (nCRHitsMax == 0)
            return;
        if (nCRHitsTotal == 0)
            return;

        const float crFracHitsInLongestTrack = static_cast<float>(nCRHitsMax) / static_cast<float>(nCRHitsTotal);

        // Push the features to the feature vector
        m_featureVector.push_back(nuNFinalStatePfos);
        m_featureVector.push_back(nuNHitsTotal);
        m_featureVector.push_back(nuVertexY);
        m_featureVector.push_back(nuWeightedDirZ);
        m_featureVector.push_back(nuNSpacePointsInSphere);
        m_featureVector.push_back(nuEigenRatioInSphere);
        m_featureVector.push_back(crLongestTrackDirY);
        m_featureVector.push_back(crLongestTrackDeflection);
        m_featureVector.push_back(crFracHitsInLongestTrack);
        m_featureVector.push_back(nCRHitsMax);

        m_featureMap["NuNFinalStatePfos"] = nuNFinalStatePfos;
        m_featureMap["NuNHitsTotal"] = nuNHitsTotal;
        m_featureMap["NuVertexY"] = nuVertexY;
        m_featureMap["NuWeightedDirZ"] = nuWeightedDirZ;
        m_featureMap["NuNSpacePointsInSphere"] = nuNSpacePointsInSphere;
        m_featureMap["NuEigenRatioInSphere"] = nuEigenRatioInSphere;
        m_featureMap["CRLongestTrackDirY"] = crLongestTrackDirY;
        m_featureMap["CRLongestTrackDeflection"] = crLongestTrackDeflection;
        m_featureMap["CRFracHitsInLongestTrack"] = crFracHitsInLongestTrack;
        m_featureMap["CRNHitsMax"] = nCRHitsMax;

        m_isAvailable = true;
    }
    catch (StatusCodeException &)
    {
        return;
    }
}

Member Function Documentation

template<typename T>

CartesianVector lar_content::NeutrinoIdTool< T >::SliceFeatures::GetDirection ( const pandora::CartesianPointVector &  spacePoints, std::function< bool(const pandora::CartesianVector &pointA, const pandora::CartesianVector &pointB)>  fShouldChooseA  ) const

private

Use a sliding fit to get the direction of a collection of spacepoints.

Parameters

spacePoints	the input spacepoints to fit
fShouldChooseA	a function that when given two fitted endpoints A and B, will return true if A is the endpoint at which to calculate the direction

Returns

the direction of the input spacepoints

Definition at line 555 of file NeutrinoIdTool.cc.

{
    // ATTN If wire w pitches vary between TPCs, exception will be raised in initialisation of lar pseudolayer plugin
    const LArTPC *const pFirstLArTPC(m_pTool->GetPandora().GetGeometry()->GetLArTPCMap().begin()->second);
    const float layerPitch(pFirstLArTPC->GetWirePitchW());

    const ThreeDSlidingFitResult fit(&spacePoints, 5, layerPitch);
    const CartesianVector endMin(fit.GetGlobalMinLayerPosition());
    const CartesianVector endMax(fit.GetGlobalMaxLayerPosition());
    const CartesianVector dirMin(fit.GetGlobalMinLayerDirection());
    const CartesianVector dirMax(fit.GetGlobalMaxLayerDirection());

    const bool isMinStart(fShouldChooseA(endMin, endMax));
    const CartesianVector startPoint(isMinStart ? endMin : endMax);
    const CartesianVector endPoint(isMinStart ? endMax : endMin);
    const CartesianVector startDir(isMinStart ? dirMin : dirMax);

    const bool shouldFlip((endPoint - startPoint).GetUnitVector().GetDotProduct(startDir) < 0.f);
    return (shouldFlip ? startDir * (-1.f) : startDir);
}

template<typename T>

CartesianVector lar_content::NeutrinoIdTool< T >::SliceFeatures::GetDirectionFromVertex ( const pandora::CartesianPointVector &  spacePoints, const pandora::CartesianVector &  vertex  ) const

private

Use a sliding fit to get the direction of a collection of spacepoint near a vertex position.

Parameters

spacePoints	the input spacepoints to fit
vertex	the position from which the fitted direction should be calculated

Returns

the direction of the input space points from the vertex supplied

Definition at line 527 of file NeutrinoIdTool.cc.

{
    return this->GetDirection(spacePoints, [&](const CartesianVector &pointA, const CartesianVector &pointB) {
        return ((pointA - vertex).GetMagnitude() < (pointB - vertex).GetMagnitude());
    });
}

template<typename T >

void lar_content::NeutrinoIdTool< T >::SliceFeatures::GetFeatureMap

(

LArMvaHelper::DoubleMap &

featureMap

)

const

Get the feature map for the MVA.

Parameters

featuresMap

empty feature map to populate

Definition at line 469 of file NeutrinoIdTool.cc.

{
    if (!m_isAvailable)
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    featureMap.insert(m_featureMap.begin(), m_featureMap.end());
}

template<typename T >

void lar_content::NeutrinoIdTool< T >::SliceFeatures::GetFeatureVector

(

LArMvaHelper::MvaFeatureVector &

featureVector

)

const

Get the feature vector for the MVA.

Parameters

featuresVector

empty feature vector to populate

Definition at line 458 of file NeutrinoIdTool.cc.

{
    if (!m_isAvailable)
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    featureVector.insert(featureVector.end(), m_featureVector.begin(), m_featureVector.end());
}

template<typename T>

CartesianVector lar_content::NeutrinoIdTool< T >::SliceFeatures::GetLowerDirection ( const pandora::CartesianPointVector &  spacePoints ) const

private

Use a sliding fit to get the lower direction of a collection of spacepoints.

Parameters

spacePoints

the input spacepoints to fit

Returns

the direction of the lower input space points

Definition at line 546 of file NeutrinoIdTool.cc.

{
    return this->GetDirection(
        spacePoints, [&](const CartesianVector &pointA, const CartesianVector &pointB) { return (pointA.GetY() < pointB.GetY()); });
}

template<typename T>

const ParticleFlowObject * lar_content::NeutrinoIdTool< T >::SliceFeatures::GetNeutrino ( const pandora::PfoList &  nuPfos ) const

private

Get the recontructed neutrino the input list of neutrino Pfos.

Parameters

nuPfos

input list of neutrino pfos

Definition at line 494 of file NeutrinoIdTool.cc.

{
    // ATTN we should only ever have one neutrino reconstructed per slice
    if (nuPfos.size() != 1)
        throw StatusCodeException(STATUS_CODE_OUT_OF_RANGE);

    return nuPfos.front();
}

template<typename T >

float lar_content::NeutrinoIdTool< T >::SliceFeatures::GetNeutrinoProbability

(

const T &

t

)

const

Get the probability that this slice contains a neutrino interaction.

Parameters

t	the MVA used to calculate the probability

Returns

the probability that the slice contains a neutrino interaction

Definition at line 480 of file NeutrinoIdTool.cc.

{
    // ATTN if one or more of the features can not be calculated, then default to calling the slice a cosmic ray
    if (!this->IsFeatureVectorAvailable())
        return 0.f;

    LArMvaHelper::MvaFeatureVector featureVector;
    this->GetFeatureVector(featureVector);
    return LArMvaHelper::CalculateProbability(t, featureVector);
}

template<typename T>

void lar_content::NeutrinoIdTool< T >::SliceFeatures::GetPointsInSphere ( const pandora::CartesianPointVector &  spacePoints, const pandora::CartesianVector &  vertex, const float  radius, pandora::CartesianPointVector &  spacePointsInSphere  ) const

private

Get a vector of spacepoints within a given radius of a vertex point.

Parameters

spacePoints	the input spacepoints
vertex	the center of the sphere
radius	the radius of the sphere
spacePointsInSphere	the vector to hold the spacepoint in the sphere

Definition at line 580 of file NeutrinoIdTool.cc.

{
    for (const CartesianVector &point : spacePoints)
    {
        if ((point - vertex).GetMagnitudeSquared() <= radius * radius)
            spacePointsInSphere.push_back(point);
    }
}

template<typename T>

void lar_content::NeutrinoIdTool< T >::SliceFeatures::GetSpacePoints ( const pandora::ParticleFlowObject *const  pPfo, pandora::CartesianPointVector &  spacePoints  ) const

private

Get the 3D space points in a given pfo.

Parameters

pPfo	input pfo
spacePoints	vector to hold the 3D space points associated with the input pfo

Definition at line 506 of file NeutrinoIdTool.cc.

{
    ClusterList clusters3D;
    LArPfoHelper::GetThreeDClusterList(pPfo, clusters3D);

    if (clusters3D.size() > 1)
        throw StatusCodeException(STATUS_CODE_OUT_OF_RANGE);

    if (clusters3D.empty())
        return;

    CaloHitList caloHits;
    clusters3D.front()->GetOrderedCaloHitList().FillCaloHitList(caloHits);

    for (const CaloHit *const pCaloHit : caloHits)
        spacePoints.push_back(pCaloHit->GetPositionVector());
}

template<typename T>

CartesianVector lar_content::NeutrinoIdTool< T >::SliceFeatures::GetUpperDirection ( const pandora::CartesianPointVector &  spacePoints ) const

private

Use a sliding fit to get the upper direction of a collection of spacepoints.

Parameters

spacePoints

the input spacepoints to fit

Returns

the direction of the upper input space points

Definition at line 537 of file NeutrinoIdTool.cc.

{
    return this->GetDirection(
        spacePoints, [&](const CartesianVector &pointA, const CartesianVector &pointB) { return (pointA.GetY() > pointB.GetY()); });
}

template<typename T >

bool lar_content::NeutrinoIdTool< T >::SliceFeatures::IsFeatureVectorAvailable

(

)

const

Check if all features were calculable.

Returns

true if the feature vector is available

Definition at line 450 of file NeutrinoIdTool.cc.

{
    return m_isAvailable;
}

Member Data Documentation

template<typename T>

LArMvaHelper::DoubleMap lar_content::NeutrinoIdTool< T >::SliceFeatures::m_featureMap

private

A map between MVA features and their names.

Definition at line 157 of file NeutrinoIdTool.h.

template<typename T>

LArMvaHelper::MvaFeatureVector lar_content::NeutrinoIdTool< T >::SliceFeatures::m_featureVector

private

The MVA feature vector.

Definition at line 156 of file NeutrinoIdTool.h.

template<typename T>

bool lar_content::NeutrinoIdTool< T >::SliceFeatures::m_isAvailable

private

Is the feature vector available.

Definition at line 155 of file NeutrinoIdTool.h.

template<typename T>

const NeutrinoIdTool* const lar_content::NeutrinoIdTool< T >::SliceFeatures::m_pTool

private

The tool that owns this.

Definition at line 158 of file NeutrinoIdTool.h.

---

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

• NeutrinoIdTool.h
• NeutrinoIdTool.cc