LArPfoHelper class. More...

#include <LArPfoHelper.h>

Public Member Functions
template<typename T >
void	SlidingFitTrajectoryImpl (const T const pT, const CartesianVector &vertexPosition, const unsigned int layerWindow, const float layerPitch, LArTrackStateVector &trackStateVector, IntVector const pIndexVector)

Static Public Member Functions
static void	GetCoordinateVector (const pandora::ParticleFlowObject *const pPfo, const pandora::HitType &hitType, pandora::CartesianPointVector &coordinateVector)
	Get a list of coordinates of a particular hit type from an input pfos. More...

static void	GetCaloHits (const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::CaloHitList &caloHitList)
	Get a list of calo hits of a particular hit type from a list of pfos. More...

static void	GetCaloHits (const pandora::ParticleFlowObject *const pPfo, const pandora::HitType &hitType, pandora::CaloHitList &caloHitList)
	Get a list of calo hits of a particular hit type from a given pfo. More...

static void	GetIsolatedCaloHits (const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::CaloHitList &caloHitList)
	Get a list of isolated calo hits of a particular hit type from a list of pfos. More...

static void	GetIsolatedCaloHits (const pandora::ParticleFlowObject *const pPfo, const pandora::HitType &hitType, pandora::CaloHitList &caloHitList)
	Get a list of isolated calo hits of a particular hit type from a given pfo. More...

static void	GetAllCaloHits (const pandora::ParticleFlowObject *pPfo, pandora::CaloHitList &caloHitList)
	Get a list of all calo hits (including isolated) of all types from a given pfo. More...

static void	GetClusters (const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::ClusterList &clusterList)
	Get a list of clusters of a particular hit type from a list of pfos. More...

static void	GetClusters (const pandora::ParticleFlowObject *const pPfo, const pandora::HitType &hitType, pandora::ClusterList &clusterList)
	Get a list of clusters of a particular hit type from a given pfo. More...

static unsigned int	GetNumberOfTwoDHits (const pandora::ParticleFlowObject *const pPfo)
	Get the number of 2D hits of a PFO. More...

static void	GetTwoDClusterList (const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
	Get the list of 2D clusters from an input pfo. More...

static void	GetThreeDClusterList (const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
	Get the list of 3D clusters from an input pfo. More...

static void	GetAllConnectedPfos (const pandora::PfoList &inputPfoList, pandora::PfoList &outputPfoList)
	Get a flat list of all pfos, recursively including all daughters and parents associated with those pfos in an input list. More...

static void	GetAllConnectedPfos (const pandora::ParticleFlowObject *const pPfo, pandora::PfoList &outputPfoList)
	Get a flat list of all pfos, recursively including all daughters and parents associated with an input pfo. More...

static void	GetAllDownstreamPfos (const pandora::PfoList &inputPfoList, pandora::PfoList &outputPfoList)
	Get a flat list of all pfos, recursively, of all daughters associated with those pfos in an input list. More...

static void	GetAllDownstreamPfos (const pandora::ParticleFlowObject *const pPfo, pandora::PfoList &outputPfoList)
	Get a flat list of all pfos, recursively, of all daughters and parents associated with an input pfo. More...

static void	GetAllDownstreamPfos (const pandora::ParticleFlowObject *const pPfo, pandora::PfoList &outputTrackPfoList, pandora::PfoList &outputLeadingShowerPfoList)
	Get flat lists of all downstream track pfos and also shower-like pfos. This method collects together all track-like particles downstream of the root particle, stopping at a leading shower and then storing that leading shower in a separate list. More...

static int	GetHierarchyTier (const pandora::ParticleFlowObject *const pPfo)
	Determine the position in the hierarchy for the MCParticle. More...

static float	GetTwoDLengthSquared (const pandora::ParticleFlowObject *const pPfo)
	Calculate length of Pfo using 2D clusters. More...

static float	GetThreeDLengthSquared (const pandora::ParticleFlowObject *const pPfo)
	Calculate length of Pfo using 3D clusters. More...

static float	GetClosestDistance (const pandora::ParticleFlowObject const pPfo, const pandora::Cluster const pCluster)
	Get closest distance between Pfo and cluster. More...

static float	GetThreeDSeparation (const pandora::ParticleFlowObject const pPfo1, const pandora::ParticleFlowObject const pPfo2)
	Get distance between two Pfos using 3D clusters. More...

static bool	IsTwoD (const pandora::ParticleFlowObject *const pPfo)
	Does Pfo contain 2D clusters. More...

static bool	IsThreeD (const pandora::ParticleFlowObject *const pPfo)
	Does Pfo contain 3D clusters. More...

static bool	IsTrack (const pandora::ParticleFlowObject *const pPfo)
	Return track flag based on Pfo Particle ID. More...

static bool	IsShower (const pandora::ParticleFlowObject *const pPfo)
	Return shower flag based on Pfo Particle ID. More...

static int	GetPrimaryNeutrino (const pandora::ParticleFlowObject *const pPfo)
	Get primary neutrino or antineutrino. More...

static bool	IsFinalState (const pandora::ParticleFlowObject *const pPfo)
	Whether a pfo is a primary parent particle. More...

static bool	IsNeutrinoFinalState (const pandora::ParticleFlowObject *const pPfo)
	Whether a pfo is a final-state particle from a neutrino (or antineutrino) interaction. More...

static bool	IsNeutrino (const pandora::ParticleFlowObject *const pPfo)
	Whether a pfo is a neutrino or (antineutrino) More...

static bool	IsTestBeamFinalState (const pandora::ParticleFlowObject *const pPfo)
	Whether a pfo is a final-state particle from a test beam particle interaction. More...

static bool	IsTestBeam (const pandora::ParticleFlowObject *const pPfo)
	Whether a pfo is a test beam particle. More...

static void	GetRecoNeutrinos (const pandora::PfoList *const pPfoList, pandora::PfoList &recoNeutrinos)
	Get neutrino pfos from an input pfo list. More...

static const pandora::ParticleFlowObject *	GetParentPfo (const pandora::ParticleFlowObject *const pPfo)
	Get the primary parent pfo. More...

static const pandora::ParticleFlowObject *	GetParentNeutrino (const pandora::ParticleFlowObject *const pPfo)
	Get primary neutrino or antineutrino. More...

static const pandora::Vertex *	GetVertex (const pandora::ParticleFlowObject *const pPfo)
	Get the pfo vertex. More...

static const pandora::Vertex *	GetTestBeamInteractionVertex (const pandora::ParticleFlowObject *const pPfo)
	Get the pfo test beam interaction vertex. More...

static const pandora::Vertex *	GetVertexWithLabel (const pandora::VertexList &vertexList, const pandora::VertexLabel vertexLabel)
	Get the vertex with a specific vertex label in a given vertex list. More...

static void	GetSlidingFitTrajectory (const pandora::CartesianPointVector &pointVector, const pandora::CartesianVector &vertexPosition, const unsigned int layerWindow, const float layerPitch, LArTrackStateVector &trackStateVector, pandora::IntVector *const pIndexVector=nullptr)
	Apply 3D sliding fit to a set of 3D points and return track trajectory. More...

static void	GetSlidingFitTrajectory (const pandora::ParticleFlowObject const pPfo, const pandora::Vertex const pVertex, const unsigned int slidingFitHalfWindow, const float layerPitch, LArTrackStateVector &trackStateVector)
	Apply 3D sliding fit to Pfo and return track trajectory. More...

static LArShowerPCA	GetPrincipalComponents (const pandora::CartesianPointVector &pointVector, const pandora::CartesianVector &vertexPosition)
	Perform PCA analysis on a set of 3D points and return results. More...

static LArShowerPCA	GetPrincipalComponents (const pandora::ParticleFlowObject const pPfo, const pandora::Vertex const pVertex)
	Perform PCA analysis on Pfo and return results. More...

static bool	SortByHitProjection (const LArTrackTrajectoryPoint &lhs, const LArTrackTrajectoryPoint &rhs)
	Sort pfos by number of constituent hits. More...

static bool	SortByNHits (const pandora::ParticleFlowObject const pLhs, const pandora::ParticleFlowObject const pRhs)
	Sort pfos by number of constituent hits. More...

static void	GetBreadthFirstHierarchyRepresentation (const pandora::ParticleFlowObject *const pPfo, pandora::PfoList &pfoList)
	Retrieve a linearised representation of the PFO hierarchy in breadth first order. This iterates over the PFO hierarchy in a manor that sees primaries at the front of the list, with progressively deeper tiers later in the list. This is useful for some visualisation cases. More...

Static Private Member Functions
template<typename T >
static void	SlidingFitTrajectoryImpl (const T const pT, const pandora::CartesianVector &vertexPosition, const unsigned int layerWindow, const float layerPitch, LArTrackStateVector &trackStateVector, pandora::IntVector const pIndexVector=nullptr)
	Implementation of sliding fit trajectory extraction. More...

Detailed Description

LArPfoHelper class.

Definition at line 23 of file LArPfoHelper.h.

Member Function Documentation

void lar_content::LArPfoHelper::GetAllCaloHits	(	const pandora::ParticleFlowObject *	pPfo,
		pandora::CaloHitList &	caloHitList
	)

static

Get a list of all calo hits (including isolated) of all types from a given pfo.

Parameters

pPfo	the input Pfo
caloHitList	the output list of calo hits

Definition at line 76 of file LArPfoHelper.cc.

 {
     LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_U, caloHitList);
     LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_V, caloHitList);
     LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_W, caloHitList);
     LArPfoHelper::GetIsolatedCaloHits(pPfo, TPC_VIEW_U, caloHitList);
     LArPfoHelper::GetIsolatedCaloHits(pPfo, TPC_VIEW_V, caloHitList);
     LArPfoHelper::GetIsolatedCaloHits(pPfo, TPC_VIEW_W, caloHitList);
 }

static void lar_content::LArPfoHelper::GetAllConnectedPfos	(	const pandora::PfoList &	inputPfoList,
		pandora::PfoList &	outputPfoList
	)

static

Get a flat list of all pfos, recursively including all daughters and parents associated with those pfos in an input list.

Parameters

inputPfoList	the input pfo list
outputPfoList	to receive the output pfo list

static void lar_content::LArPfoHelper::GetAllConnectedPfos	(	const pandora::ParticleFlowObject *const	pPfo,
		pandora::PfoList &	outputPfoList
	)

static

Get a flat list of all pfos, recursively including all daughters and parents associated with an input pfo.

Parameters

pPfo	the input Pfo
outputPfoList	to receive the output pfo list

static void lar_content::LArPfoHelper::GetAllDownstreamPfos	(	const pandora::PfoList &	inputPfoList,
		pandora::PfoList &	outputPfoList
	)

static

Get a flat list of all pfos, recursively, of all daughters associated with those pfos in an input list.

Parameters

inputPfoList	the input pfo list
outputPfoList	to receive the output pfo list

static void lar_content::LArPfoHelper::GetAllDownstreamPfos	(	const pandora::ParticleFlowObject *const	pPfo,
		pandora::PfoList &	outputPfoList
	)

static

Get a flat list of all pfos, recursively, of all daughters and parents associated with an input pfo.

Parameters

pPfo	the input Pfo
outputPfoList	to receive the output pfo list

void lar_content::LArPfoHelper::GetAllDownstreamPfos	(	const pandora::ParticleFlowObject *const	pPfo,
		pandora::PfoList &	outputTrackPfoList,
		pandora::PfoList &	outputLeadingShowerPfoList
	)

static

Get flat lists of all downstream track pfos and also shower-like pfos. This method collects together all track-like particles downstream of the root particle, stopping at a leading shower and then storing that leading shower in a separate list.

Parameters

pPfo	the input pfo
outputTrackPfoList	the output list of descendent track-like particles
outputLeadingShowerParticles	the output list of leading shower particles

Definition at line 188 of file LArPfoHelper.cc.

 {
     if (LArPfoHelper::IsTrack(pPfo))
     {
         outputTrackPfoList.emplace_back(pPfo);
         for (const ParticleFlowObject *pChild : pPfo->GetDaughterPfoList())
         {
             if (std::find(outputTrackPfoList.begin(), outputTrackPfoList.end(), pChild) == outputTrackPfoList.end())
             {
                 const int pdg{std::abs(pChild->GetParticleId())};
                 if (pdg == E_MINUS)
                 {
                     outputLeadingShowerPfoList.emplace_back(pChild);
                 }
                 else
                 {
                     outputTrackPfoList.emplace_back(pChild);
                     LArPfoHelper::GetAllDownstreamPfos(pChild, outputTrackPfoList, outputLeadingShowerPfoList);
                 }
             }
         }
     }
     else
     {
         outputLeadingShowerPfoList.emplace_back(pPfo);
     }
 }

void lar_content::LArPfoHelper::GetBreadthFirstHierarchyRepresentation	(	const pandora::ParticleFlowObject *const	pPfo,
		pandora::PfoList &	pfoList
	)

static

Retrieve a linearised representation of the PFO hierarchy in breadth first order. This iterates over the PFO hierarchy in a manor that sees primaries at the front of the list, with progressively deeper tiers later in the list. This is useful for some visualisation cases.

Parameters

pPfo	a PFO in the hierarchy - can be any PFO
pfoList	the output PFO list

Definition at line 652 of file LArPfoHelper.cc.

 {
     const ParticleFlowObject *pRoot{pPfo};
     PfoList parents{pRoot->GetParentPfoList()};
     while (!parents.empty())
     {
         if (parents.size() > 1)
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
         pRoot = parents.front();
         parents = pRoot->GetParentPfoList();
     }
     PfoList queue;
     pfoList.emplace_back(pRoot);
     queue.emplace_back(pRoot);
 
     while (!queue.empty())
     {
         const PfoList &daughters{queue.front()->GetDaughterPfoList()};
         queue.pop_front();
         for (const ParticleFlowObject *pDaughter : daughters)
         {
             pfoList.emplace_back(pDaughter);
             queue.emplace_back(pDaughter);
         }
     }
 }

static void lar_content::LArPfoHelper::GetCaloHits	(	const pandora::PfoList &	pfoList,
		const pandora::HitType &	hitType,
		pandora::CaloHitList &	caloHitList
	)

static

Get a list of calo hits of a particular hit type from a list of pfos.

Parameters

pfoList	the input list of Pfos
hitType	the cluster hit type
caloHitList	the output list of calo hits

static void lar_content::LArPfoHelper::GetCaloHits	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::HitType &	hitType,
		pandora::CaloHitList &	caloHitList
	)

static

Get a list of calo hits of a particular hit type from a given pfo.

Parameters

pPfo	the input Pfo
hitType	the cluster hit type
caloHitList	the output list of calo hits

float lar_content::LArPfoHelper::GetClosestDistance	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::Cluster *const	pCluster
	)

static

Get closest distance between Pfo and cluster.

Parameters

pPfo	the address of the input Pfo
pCluster	the address of the input cluster

Definition at line 278 of file LArPfoHelper.cc.

 {
     const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
 
     ClusterList clusterList;
     LArPfoHelper::GetClusters(pPfo, hitType, clusterList);
 
     if (clusterList.empty())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     float bestDistance(std::numeric_limits<float>::max());
 
     for (const Cluster *const pPfoCluster : clusterList)
     {
         const float thisDistance(LArClusterHelper::GetClosestDistance(pCluster, pPfoCluster));
 
         if (thisDistance < bestDistance)
             bestDistance = thisDistance;
     }
 
     return bestDistance;
 }

static void lar_content::LArPfoHelper::GetClusters	(	const pandora::PfoList &	pfoList,
		const pandora::HitType &	hitType,
		pandora::ClusterList &	clusterList
	)

static

Get a list of clusters of a particular hit type from a list of pfos.

Parameters

pfoList	the input list of Pfos
hitType	the cluster hit type
clusterList	the output list of clusters

static void lar_content::LArPfoHelper::GetClusters	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::HitType &	hitType,
		pandora::ClusterList &	clusterList
	)

static

Get a list of clusters of a particular hit type from a given pfo.

Parameters

pPfo	the input Pfo
hitType	the cluster hit type
clusterList	the output list of clusters

void lar_content::LArPfoHelper::GetCoordinateVector	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::HitType &	hitType,
		pandora::CartesianPointVector &	coordinateVector
	)

static

Get a list of coordinates of a particular hit type from an input pfos.

Parameters

pPfo	the address of the input Pfo
hitType	the cluster hit type
coordinateVector	the output list of coordinates

Definition at line 27 of file LArPfoHelper.cc.

 {
     ClusterList clusterList;
     LArPfoHelper::GetClusters(pPfo, hitType, clusterList);
 
     for (const Cluster *const pCluster : clusterList)
         LArClusterHelper::GetCoordinateVector(pCluster, coordinateVector);
 }

int lar_content::LArPfoHelper::GetHierarchyTier ( const pandora::ParticleFlowObject *const pPfo )

static

Determine the position in the hierarchy for the MCParticle.

Parameters

pPfo	the input Pfo

Returns: integer

Definition at line 219 of file LArPfoHelper.cc.

 {
     const ParticleFlowObject *pParentPfo = pPfo;
     int tier(0);
 
     while (pParentPfo->GetParentPfoList().empty() == false)
     {
         if (1 != pParentPfo->GetParentPfoList().size())
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
         pParentPfo = *(pParentPfo->GetParentPfoList().begin());
         ++tier;
     }
 
     return tier;
 }

static void lar_content::LArPfoHelper::GetIsolatedCaloHits	(	const pandora::PfoList &	pfoList,
		const pandora::HitType &	hitType,
		pandora::CaloHitList &	caloHitList
	)

static

Get a list of isolated calo hits of a particular hit type from a list of pfos.

Parameters

pfoList	the input list of Pfos
hitType	the cluster hit type
caloHitList	the output list of calo hits

static void lar_content::LArPfoHelper::GetIsolatedCaloHits	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::HitType &	hitType,
		pandora::CaloHitList &	caloHitList
	)

static

Get a list of isolated calo hits of a particular hit type from a given pfo.

Parameters

pPfo	the input Pfo
hitType	the cluster hit type
caloHitList	the output list of isolated calo hits

unsigned int lar_content::LArPfoHelper::GetNumberOfTwoDHits ( const pandora::ParticleFlowObject *const pPfo )

static

Get the number of 2D hits of a PFO.

Parameters

pPfo	the pfo to check

Returns: int of number of 2D hits

Definition at line 109 of file LArPfoHelper.cc.

 {
     unsigned int totalHits(0);
 
     ClusterList clusterList;
     LArPfoHelper::GetTwoDClusterList(pPfo, clusterList);
     for (const Cluster *const pCluster : clusterList)
         totalHits += pCluster->GetNCaloHits();
 
     return totalHits;
 }

const ParticleFlowObject * lar_content::LArPfoHelper::GetParentNeutrino ( const pandora::ParticleFlowObject *const pPfo )

static

Get primary neutrino or antineutrino.

Parameters

pPfo	the address of the Pfo

Returns: address of primary neutrino pfo

Definition at line 459 of file LArPfoHelper.cc.

 {
     const ParticleFlowObject *const pParentPfo = LArPfoHelper::GetParentPfo(pPfo);
 
     if (!LArPfoHelper::IsNeutrino(pParentPfo))
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     return pParentPfo;
 }

const ParticleFlowObject * lar_content::LArPfoHelper::GetParentPfo ( const pandora::ParticleFlowObject *const pPfo )

static

Get the primary parent pfo.

Parameters

pPfo	the address of the Pfo

Returns: address of the primary parent pfo

Definition at line 445 of file LArPfoHelper.cc.

 {
     const ParticleFlowObject *pParentPfo = pPfo;
 
     while (pParentPfo->GetParentPfoList().empty() == false)
     {
         pParentPfo = *(pParentPfo->GetParentPfoList().begin());
     }
 
     return pParentPfo;
 }

int lar_content::LArPfoHelper::GetPrimaryNeutrino ( const pandora::ParticleFlowObject *const pPfo )

static

Get primary neutrino or antineutrino.

Parameters

pPfo	the address of the Pfo

Returns: pdg code of neutrino (or zero, otherwise)

Definition at line 364 of file LArPfoHelper.cc.

 {
     try
     {
         const ParticleFlowObject *const pParentPfo = LArPfoHelper::GetParentNeutrino(pPfo);
         return pParentPfo->GetParticleId();
     }
     catch (const StatusCodeException &)
     {
         return 0;
     }
 }

static LArShowerPCA lar_content::LArPfoHelper::GetPrincipalComponents	(	const pandora::CartesianPointVector &	pointVector,
		const pandora::CartesianVector &	vertexPosition
	)

static

Perform PCA analysis on a set of 3D points and return results.

Parameters

pointVector	the input list of 3D positions
vertexPosition	the input vertex position

static LArShowerPCA lar_content::LArPfoHelper::GetPrincipalComponents	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::Vertex *const	pVertex
	)

static

Perform PCA analysis on Pfo and return results.

Parameters

pPfo	the address of the input Pfo
pVertex	the address of the input vertex

void lar_content::LArPfoHelper::GetRecoNeutrinos	(	const pandora::PfoList *const	pPfoList,
		pandora::PfoList &	recoNeutrinos
	)

static

Get neutrino pfos from an input pfo list.

Parameters

pPfoList	the input pfo list
recoNeutrinos	to receive the list of neutrino pfos

Definition at line 431 of file LArPfoHelper.cc.

 {
     if (!pPfoList)
         return;
 
     for (const ParticleFlowObject *const pPfo : *pPfoList)
     {
         if (LArPfoHelper::IsNeutrino(pPfo))
             recoNeutrinos.push_back(pPfo);
     }
 }

static void lar_content::LArPfoHelper::GetSlidingFitTrajectory	(	const pandora::CartesianPointVector &	pointVector,
		const pandora::CartesianVector &	vertexPosition,
		const unsigned int	layerWindow,
		const float	layerPitch,
		LArTrackStateVector &	trackStateVector,
		pandora::IntVector *const	pIndexVector = `nullptr`
	)

static

Apply 3D sliding fit to a set of 3D points and return track trajectory.

Parameters

pointVector	the input list of 3D positions
vertexPosition	the input vertex position
slidingFitHalfWindow	size of half window for sliding linear fit
layerPitch	size of pitch for sliding linear fit
trackStateVector	the output track trajectory
pIndexVector	lookup vector of spacepoint indices to store trajectory point sorting

static void lar_content::LArPfoHelper::GetSlidingFitTrajectory	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::Vertex *const	pVertex,
		const unsigned int	slidingFitHalfWindow,
		const float	layerPitch,
		LArTrackStateVector &	trackStateVector
	)

static

Apply 3D sliding fit to Pfo and return track trajectory.

Parameters

pPfo	the address of the input Pfo
pVertex	the address of the input vertex
slidingFitHalfWindow	size of half window for sliding linear fit
layerPitch	size of pitch for sliding linear fit
trackStateVector	the output track trajectory

const Vertex * lar_content::LArPfoHelper::GetTestBeamInteractionVertex ( const pandora::ParticleFlowObject *const pPfo )

static

Get the pfo test beam interaction vertex.

Parameters

pPfo	the address of the Pfo

Returns: address of pfo vertex

Definition at line 499 of file LArPfoHelper.cc.

 {
     if (pPfo->GetVertexList().empty() || !pPfo->GetParentPfoList().empty() || !LArPfoHelper::IsTestBeam(pPfo))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     const Vertex *pInteractionVertex(LArPfoHelper::GetVertexWithLabel(pPfo->GetVertexList(), VERTEX_INTERACTION));
 
     if (VERTEX_3D != pInteractionVertex->GetVertexType())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     return pInteractionVertex;
 }

void lar_content::LArPfoHelper::GetThreeDClusterList	(	const pandora::ParticleFlowObject *const	pPfo,
		pandora::ClusterList &	clusterList
	)

static

Get the list of 3D clusters from an input pfo.

Parameters

pPfo	the input Pfo
clusterList	the output list of clusters

Definition at line 136 of file LArPfoHelper.cc.

 {
     for (const Cluster *const pCluster : pPfo->GetClusterList())
     {
         if (TPC_3D != LArClusterHelper::GetClusterHitType(pCluster))
             continue;
 
         clusterList.push_back(pCluster);
     }
 }

float lar_content::LArPfoHelper::GetThreeDLengthSquared ( const pandora::ParticleFlowObject *const pPfo )

static

Calculate length of Pfo using 3D clusters.

Parameters

pPfo	the input Pfo

Returns: length variable

Definition at line 258 of file LArPfoHelper.cc.

 {
     if (!LArPfoHelper::IsThreeD(pPfo))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     float lengthSquared(0.f);
 
     for (const Cluster *const pCluster : pPfo->GetClusterList())
     {
         if (TPC_3D != LArClusterHelper::GetClusterHitType(pCluster))
             continue;
 
         lengthSquared += LArClusterHelper::GetLengthSquared(pCluster);
     }
 
     return lengthSquared;
 }

float lar_content::LArPfoHelper::GetThreeDSeparation	(	const pandora::ParticleFlowObject *const	pPfo1,
		const pandora::ParticleFlowObject *const	pPfo2
	)

static

Get distance between two Pfos using 3D clusters.

Parameters

pPfo	the address of the first Pfo
pPfo	the address of the second Pfo

Definition at line 303 of file LArPfoHelper.cc.

 {
     ClusterList clusterList1, clusterList2;
 
     LArPfoHelper::GetClusters(pPfo1, TPC_3D, clusterList1);
     LArPfoHelper::GetClusters(pPfo2, TPC_3D, clusterList2);
 
     if (clusterList1.empty() || clusterList2.empty())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     return LArClusterHelper::GetClosestDistance(clusterList1, clusterList2);
 }

void lar_content::LArPfoHelper::GetTwoDClusterList	(	const pandora::ParticleFlowObject *const	pPfo,
		pandora::ClusterList &	clusterList
	)

static

Get the list of 2D clusters from an input pfo.

Parameters

pPfo	the input Pfo
clusterList	the output list of clusters

Definition at line 123 of file LArPfoHelper.cc.

 {
     for (const Cluster *const pCluster : pPfo->GetClusterList())
     {
         if (TPC_3D == LArClusterHelper::GetClusterHitType(pCluster))
             continue;
 
         clusterList.push_back(pCluster);
     }
 }

float lar_content::LArPfoHelper::GetTwoDLengthSquared ( const pandora::ParticleFlowObject *const pPfo )

static

Calculate length of Pfo using 2D clusters.

Parameters

pPfo	the input Pfo

Returns: length variable

Definition at line 238 of file LArPfoHelper.cc.

 {
     if (!LArPfoHelper::IsTwoD(pPfo))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     float lengthSquared(0.f);
 
     for (const Cluster *const pCluster : pPfo->GetClusterList())
     {
         if (TPC_3D == LArClusterHelper::GetClusterHitType(pCluster))
             continue;
 
         lengthSquared += LArClusterHelper::GetLengthSquared(pCluster);
     }
 
     return lengthSquared;
 }

const Vertex * lar_content::LArPfoHelper::GetVertex ( const pandora::ParticleFlowObject *const pPfo )

static

Get the pfo vertex.

Parameters

pPfo	the address of the Pfo

Returns: address of pfo vertex

Definition at line 471 of file LArPfoHelper.cc.

 {
     if (pPfo->GetVertexList().empty())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     const Vertex *pVertex(nullptr);
 
     // ATTN : Test beam parent pfos contain an interaction and start vertex
     if (LArPfoHelper::IsTestBeam(pPfo) && pPfo->GetParentPfoList().empty())
     {
         pVertex = LArPfoHelper::GetVertexWithLabel(pPfo->GetVertexList(), VERTEX_START);
     }
     else
     {
         if (pPfo->GetVertexList().size() != 1)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         pVertex = *(pPfo->GetVertexList().begin());
     }
 
     if (VERTEX_3D != pVertex->GetVertexType())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     return pVertex;
 }

const Vertex * lar_content::LArPfoHelper::GetVertexWithLabel	(	const pandora::VertexList &	vertexList,
		const pandora::VertexLabel	vertexLabel
	)

static

Get the vertex with a specific vertex label in a given vertex list.

Parameters

vertexList	vertex list
vertexLabel	target vertex label type

Returns: address of the desired vertex

Definition at line 514 of file LArPfoHelper.cc.

 {
     const Vertex *pTargetVertex(nullptr);
 
     for (const Vertex *pCandidateVertex : vertexList)
     {
         if (pCandidateVertex->GetVertexLabel() == vertexLabel)
         {
             if (!pTargetVertex)
             {
                 pTargetVertex = pCandidateVertex;
             }
             else
             {
                 throw StatusCodeException(STATUS_CODE_FAILURE);
             }
         }
     }
 
     if (!pTargetVertex)
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     return pTargetVertex;
 }

bool lar_content::LArPfoHelper::IsFinalState ( const pandora::ParticleFlowObject *const pPfo )

static

Whether a pfo is a primary parent particle.

Parameters

pPfo	the address of the Pfo

Returns: boolean

Definition at line 379 of file LArPfoHelper.cc.

 {
     if (pPfo->GetParentPfoList().empty() && !LArPfoHelper::IsNeutrino(pPfo))
         return true;
 
     if (LArPfoHelper::IsNeutrinoFinalState(pPfo))
         return true;
 
     return false;
 }

bool lar_content::LArPfoHelper::IsNeutrino ( const pandora::ParticleFlowObject *const pPfo )

static

Whether a pfo is a neutrino or (antineutrino)

Parameters

pPfo	the address of the Pfo

Returns: boolean

Definition at line 399 of file LArPfoHelper.cc.

 {
     const int absoluteParticleId(std::abs(pPfo->GetParticleId()));
 
     if ((NU_E == absoluteParticleId) || (NU_MU == absoluteParticleId) || (NU_TAU == absoluteParticleId))
         return true;
 
     return false;
 }

bool lar_content::LArPfoHelper::IsNeutrinoFinalState ( const pandora::ParticleFlowObject *const pPfo )

static

Whether a pfo is a final-state particle from a neutrino (or antineutrino) interaction.

Parameters

pPfo	the address of the Pfo

Returns: boolean

Definition at line 392 of file LArPfoHelper.cc.

 {
     return ((pPfo->GetParentPfoList().size() == 1) && (LArPfoHelper::IsNeutrino(*(pPfo->GetParentPfoList().begin()))));
 }

bool lar_content::LArPfoHelper::IsShower ( const pandora::ParticleFlowObject *const pPfo )

static

Return shower flag based on Pfo Particle ID.

Parameters

pPfo	the address of the Pfo

Definition at line 354 of file LArPfoHelper.cc.

 {
     const int pdg(pPfo->GetParticleId());
 
     // electron, photon
     return ((E_MINUS == std::abs(pdg)) || (PHOTON == std::abs(pdg)));
 }

bool lar_content::LArPfoHelper::IsTestBeam ( const pandora::ParticleFlowObject *const pPfo )

static

Whether a pfo is a test beam particle.

Parameters

pPfo	the address of the Pfo

Returns: boolean

Definition at line 418 of file LArPfoHelper.cc.

 {
     const PropertiesMap &properties(pPfo->GetPropertiesMap());
     const PropertiesMap::const_iterator iter(properties.find("IsTestBeam"));
 
     if (iter != properties.end())
         return ((iter->second > 0.f) ? true : false);
 
     return false;
 }

bool lar_content::LArPfoHelper::IsTestBeamFinalState ( const pandora::ParticleFlowObject *const pPfo )

static

Whether a pfo is a final-state particle from a test beam particle interaction.

Parameters

pPfo	the address of the Pfo

Returns: boolean

Definition at line 411 of file LArPfoHelper.cc.

 {
     return LArPfoHelper::IsTestBeam(LArPfoHelper::GetParentPfo(pPfo));
 }

bool lar_content::LArPfoHelper::IsThreeD ( const pandora::ParticleFlowObject *const pPfo )

static

Does Pfo contain 3D clusters.

Parameters

pPfo	the address of the Pfo

Definition at line 331 of file LArPfoHelper.cc.

 {
     for (const Cluster *const pCluster : pPfo->GetClusterList())
     {
         if (TPC_3D == LArClusterHelper::GetClusterHitType(pCluster))
             return true;
     }
 
     return false;
 }

bool lar_content::LArPfoHelper::IsTrack ( const pandora::ParticleFlowObject *const pPfo )

static

Return track flag based on Pfo Particle ID.

Parameters

pPfo	the address of the Pfo

Definition at line 344 of file LArPfoHelper.cc.

 {
     const int pdg(pPfo->GetParticleId());
 
     // muon, pion, proton, kaon
     return ((MU_MINUS == std::abs(pdg)) || (PI_PLUS == std::abs(pdg)) || (PROTON == std::abs(pdg)) || (K_PLUS == std::abs(pdg)));
 }

bool lar_content::LArPfoHelper::IsTwoD ( const pandora::ParticleFlowObject *const pPfo )

static

Does Pfo contain 2D clusters.

Parameters

pPfo	the address of the Pfo

Definition at line 318 of file LArPfoHelper.cc.

 {
     for (const Cluster *const pCluster : pPfo->GetClusterList())
     {
         if (TPC_3D != LArClusterHelper::GetClusterHitType(pCluster))
             return true;
     }
 
     return false;
 }

template<typename T >

static void lar_content::LArPfoHelper::SlidingFitTrajectoryImpl	(	const T *const	pT,
		const pandora::CartesianVector &	vertexPosition,
		const unsigned int	layerWindow,
		const float	layerPitch,
		LArTrackStateVector &	trackStateVector,
		pandora::IntVector *const	pIndexVector = `nullptr`
	)

staticprivate

Implementation of sliding fit trajectory extraction.

Parameters

t	the input information
pVertex	the address of the input vertex
slidingFitHalfWindow	size of half window for sliding linear fit
layerPitch	size of pitch for sliding linear fit
trackStateVector	the output track trajectory
pIndexVector	lookup vector of spacepoint indices to store trajectory point sorting

template<typename T >

void lar_content::LArPfoHelper::SlidingFitTrajectoryImpl	(	const T *const	pT,
		const CartesianVector &	vertexPosition,
		const unsigned int	layerWindow,
		const float	layerPitch,
		LArTrackStateVector &	trackStateVector,
		IntVector *const	pIndexVector
	)

Definition at line 682 of file LArPfoHelper.cc.

 {
     CartesianPointVector pointVector;
 
     for (const auto &nextPoint : *pT)
         pointVector.push_back(LArObjectHelper::TypeAdaptor::GetPosition(nextPoint));
 
     if (pointVector.empty())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     std::sort(pointVector.begin(), pointVector.end(), LArClusterHelper::SortCoordinatesByPosition);
 
     LArTrackTrajectory trackTrajectory;
     IntVector indicesWithoutSpacePoints;
     if (pIndexVector)
         pIndexVector->clear();
 
     try
     {
         const ThreeDSlidingFitResult slidingFitResult(&pointVector, layerWindow, layerPitch);
         const CartesianVector minPosition(slidingFitResult.GetGlobalMinLayerPosition());
         const CartesianVector maxPosition(slidingFitResult.GetGlobalMaxLayerPosition());
 
         if ((maxPosition - minPosition).GetMagnitudeSquared() < std::numeric_limits<float>::epsilon())
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         const CartesianVector seedPosition((maxPosition + minPosition) * 0.5f);
         const CartesianVector seedDirection((maxPosition - minPosition).GetUnitVector());
 
         const float scaleFactor((seedDirection.GetDotProduct(seedPosition - vertexPosition) > 0.f) ? +1.f : -1.f);
 
         int index(-1);
         for (const auto &nextPoint : *pT)
         {
             ++index;
 
             try
             {
                 const float rL(slidingFitResult.GetLongitudinalDisplacement(LArObjectHelper::TypeAdaptor::GetPosition(nextPoint)));
 
                 CartesianVector position(0.f, 0.f, 0.f);
                 const StatusCode positionStatusCode(slidingFitResult.GetGlobalFitPosition(rL, position));
 
                 if (positionStatusCode != STATUS_CODE_SUCCESS)
                     throw StatusCodeException(positionStatusCode);
 
                 CartesianVector direction(0.f, 0.f, 0.f);
                 const StatusCode directionStatusCode(slidingFitResult.GetGlobalFitDirection(rL, direction));
 
                 if (directionStatusCode != STATUS_CODE_SUCCESS)
                     throw StatusCodeException(directionStatusCode);
 
                 const float projection(seedDirection.GetDotProduct(position - seedPosition));
 
                 trackTrajectory.push_back(LArTrackTrajectoryPoint(projection * scaleFactor,
                     LArTrackState(position, direction * scaleFactor, LArObjectHelper::TypeAdaptor::GetCaloHit(nextPoint)), index));
             }
             catch (const StatusCodeException &statusCodeException1)
             {
                 indicesWithoutSpacePoints.push_back(index);
 
                 if (STATUS_CODE_FAILURE == statusCodeException1.GetStatusCode())
                     throw statusCodeException1;
             }
         }
     }
     catch (const StatusCodeException &statusCodeException2)
     {
         if (STATUS_CODE_FAILURE == statusCodeException2.GetStatusCode())
             throw statusCodeException2;
     }
 
     // Sort trajectory points by distance along track
     std::sort(trackTrajectory.begin(), trackTrajectory.end(), LArPfoHelper::SortByHitProjection);
 
     for (const LArTrackTrajectoryPoint &larTrackTrajectoryPoint : trackTrajectory)
     {
         trackStateVector.push_back(larTrackTrajectoryPoint.second);
         if (pIndexVector)
             pIndexVector->push_back(larTrackTrajectoryPoint.GetIndex());
     }
 
     // Store indices of spacepoints with no associated trajectory point at the end of pIndexVector
     if (pIndexVector)
     {
         for (const int index : indicesWithoutSpacePoints)
             pIndexVector->push_back(index);
     }
 }

bool lar_content::LArPfoHelper::SortByHitProjection	(	const LArTrackTrajectoryPoint &	lhs,
		const LArTrackTrajectoryPoint &	rhs
	)

static

Sort pfos by number of constituent hits.

Parameters

pLhs	address of first pfo
pRhs	address of second pfo

Definition at line 593 of file LArPfoHelper.cc.

 {
     if (lhs.first != rhs.first)
         return (lhs.first < rhs.first);
 
     // ATTN Removed to support use with CartesianVector only (no CaloHit) input
     // if (lhs.second.GetCaloHit() && rhs.second.GetCaloHit())
     //     return (lhs.second.GetCaloHit()->GetInputEnergy() > rhs.second.GetCaloHit()->GetInputEnergy());
 
     const float dx(lhs.second.GetPosition().GetX() - rhs.second.GetPosition().GetX());
     const float dy(lhs.second.GetPosition().GetY() - rhs.second.GetPosition().GetY());
     const float dz(lhs.second.GetPosition().GetZ() - rhs.second.GetPosition().GetZ());
     return (dx + dy + dz > 0.f);
 }

bool lar_content::LArPfoHelper::SortByNHits	(	const pandora::ParticleFlowObject *const	pLhs,
		const pandora::ParticleFlowObject *const	pRhs
	)

static

Sort pfos by number of constituent hits.

Parameters

pLhs	address of first pfo
pRhs	address of second pfo

Definition at line 610 of file LArPfoHelper.cc.

 {
     unsigned int nTwoDHitsLhs(0), nThreeDHitsLhs(0);
     float energyLhs(0.f);
     for (ClusterList::const_iterator iter = pLhs->GetClusterList().begin(), iterEnd = pLhs->GetClusterList().end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pClusterLhs = *iter;
 
         if (TPC_3D != LArClusterHelper::GetClusterHitType(pClusterLhs))
             nTwoDHitsLhs += pClusterLhs->GetNCaloHits();
         else
             nThreeDHitsLhs += pClusterLhs->GetNCaloHits();
 
         energyLhs += pClusterLhs->GetHadronicEnergy();
     }
 
     unsigned int nTwoDHitsRhs(0), nThreeDHitsRhs(0);
     float energyRhs(0.f);
     for (ClusterList::const_iterator iter = pRhs->GetClusterList().begin(), iterEnd = pRhs->GetClusterList().end(); iter != iterEnd; ++iter)
     {
         const Cluster *const pClusterRhs = *iter;
 
         if (TPC_3D != LArClusterHelper::GetClusterHitType(pClusterRhs))
             nTwoDHitsRhs += pClusterRhs->GetNCaloHits();
         else
             nThreeDHitsRhs += pClusterRhs->GetNCaloHits();
 
         energyRhs += pClusterRhs->GetHadronicEnergy();
     }
 
     if (nTwoDHitsLhs != nTwoDHitsRhs)
         return (nTwoDHitsLhs > nTwoDHitsRhs);
 
     if (nThreeDHitsLhs != nThreeDHitsRhs)
         return (nThreeDHitsLhs > nThreeDHitsRhs);
 
     // ATTN Need an efficient (balance with well-motivated) tie-breaker here. Pfo length, for instance, is extremely slow.
     return (energyLhs > energyRhs);
 }

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

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation