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

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

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 309 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_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 512 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 484 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::GetFeatureVector ( LArMvaHelper::MvaFeatureVector & featureVector ) const

Get the feature vector for the MVA.

Parameters

featuresVector empty feature vector to populate

Definition at line 426 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 503 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 451 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 437 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 537 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 463 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 494 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 418 of file NeutrinoIdTool.cc.

 {
     return m_isAvailable;
 }

Member Data Documentation

template<typename T>

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

private

The MVA feature vector.

Definition at line 149 of file NeutrinoIdTool.h.

template<typename T>

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

private

Is the feature vector available.

Definition at line 148 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 150 of file NeutrinoIdTool.h.

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

larpandoracontent/larpandoracontent/LArControlFlow/NeutrinoIdTool.h
larpandoracontent/larpandoracontent/LArControlFlow/NeutrinoIdTool.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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