lar_content::NeutrinoIdTool::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 SVM. More...
float	GetNeutrinoProbability (const SupportVectorMachine &supportVectorMachine) 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 SVM feature vector. More...
const NeutrinoIdTool *const	m_pTool
	The tool that owns this. More...

Detailed Description

Slice features class.

Definition at line 44 of file NeutrinoIdTool.h.

Constructor & Destructor Documentation

lar_content::NeutrinoIdTool::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 289 of file NeutrinoIdTool.cc.

References dir, f, GetDirectionFromVertex(), GetLowerDirection(), GetNeutrino(), GetPointsInSphere(), GetSpacePoints(), GetUpperDirection(), lar_content::LArPfoHelper::GetVertex(), m_featureVector, m_isAvailable, max, and lar_content::LArPcaHelper::RunPca().

                                                                                                                          :
    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_isAvailable = true;
    }
    catch (StatusCodeException &)
    {
        return;
    }
}

Member Function Documentation

CartesianVector lar_content::NeutrinoIdTool::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 481 of file NeutrinoIdTool.cc.

References f, and m_pTool.

Referenced by GetDirectionFromVertex(), GetLowerDirection(), and GetUpperDirection().

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

CartesianVector lar_content::NeutrinoIdTool::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 451 of file NeutrinoIdTool.cc.

References GetDirection().

Referenced by SliceFeatures().

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

void lar_content::NeutrinoIdTool::SliceFeatures::GetFeatureVector

(

LArMvaHelper::MvaFeatureVector &

featureVector

)

const

Get the feature vector for the SVM.

Parameters

featuresVector

empty feature vector to populate

Definition at line 399 of file NeutrinoIdTool.cc.

References m_featureVector, and m_isAvailable.

Referenced by GetNeutrinoProbability(), and lar_content::NeutrinoIdTool::SelectOutputPfos().

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

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

CartesianVector lar_content::NeutrinoIdTool::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 471 of file NeutrinoIdTool.cc.

References GetDirection().

Referenced by SliceFeatures().

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

const ParticleFlowObject * lar_content::NeutrinoIdTool::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 421 of file NeutrinoIdTool.cc.

Referenced by SliceFeatures().

{
    // 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();
}

float lar_content::NeutrinoIdTool::SliceFeatures::GetNeutrinoProbability

(

const SupportVectorMachine &

supportVectorMachine

)

const

Get the probability that this slice contains a neutrino interaction.

Parameters

supportVectorMachine

the SVM used to calculate the probability

Returns

the probability that the slice contains a neutrino interaction

Definition at line 409 of file NeutrinoIdTool.cc.

References lar_content::LArMvaHelper::CalculateProbability(), GetFeatureVector(), and IsFeatureVectorAvailable().

{
    // 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(supportVectorMachine, featureVector);
}

void lar_content::NeutrinoIdTool::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 504 of file NeutrinoIdTool.cc.

Referenced by SliceFeatures().

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

void lar_content::NeutrinoIdTool::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 432 of file NeutrinoIdTool.cc.

References lar_content::LArPfoHelper::GetThreeDClusterList().

Referenced by SliceFeatures().

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

CartesianVector lar_content::NeutrinoIdTool::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 461 of file NeutrinoIdTool.cc.

References GetDirection().

Referenced by SliceFeatures().

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

bool lar_content::NeutrinoIdTool::SliceFeatures::IsFeatureVectorAvailable

(

)

const

Check if all features were calculable.

Returns

true if the feature vector is available

Definition at line 392 of file NeutrinoIdTool.cc.

References m_isAvailable.

Referenced by GetNeutrinoProbability().

{
    return m_isAvailable;
}

Member Data Documentation

LArMvaHelper::MvaFeatureVector lar_content::NeutrinoIdTool::SliceFeatures::m_featureVector

private

The SVM feature vector.

Definition at line 144 of file NeutrinoIdTool.h.

Referenced by GetFeatureVector(), and SliceFeatures().

bool lar_content::NeutrinoIdTool::SliceFeatures::m_isAvailable

private

Is the feature vector available.

Definition at line 143 of file NeutrinoIdTool.h.

Referenced by GetFeatureVector(), IsFeatureVectorAvailable(), and SliceFeatures().

const NeutrinoIdTool* const lar_content::NeutrinoIdTool::SliceFeatures::m_pTool

private

The tool that owns this.

Definition at line 145 of file NeutrinoIdTool.h.

Referenced by GetDirection().

---

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

• larpandoracontent/v03_13_02/source/larpandoracontent/LArControlFlow/NeutrinoIdTool.h
• larpandoracontent/v03_13_02/source/larpandoracontent/LArControlFlow/NeutrinoIdTool.cc