DLLaterTierHierarchyTool to apply the later-tier hierarchy DL networks. More...

#include "DLLaterTierHierarchyTool.h"

Inheritance diagram for lar_dl_content::DLLaterTierHierarchyTool:

Classes
struct	DLLaterTierNetworkParams

struct	NormalisationLimits

Public Member Functions
pandora::StatusCode	Run (const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pNeutrinoPfo, const HierarchyPfo &parentHierarchyPfo, const HierarchyPfo &childHierarchyPfo, std::vector< DLLaterTierNetworkParams > &networkParamVector, float &laterTierScore)

	DLLaterTierHierarchyTool ()
	Default constructor. More...

Protected Member Functions
void	SetDetectorBoundaries ()
	Set the detector boundaries. More...

std::pair< float, float >	GetParticleInfoAboutPfoPosition (const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pPfo, const pandora::CartesianVector &pointOfInterest) const
	Return the number of 3D hits and the number of corresponding pfos of a given pfo about a point. More...

void	NormaliseNetworkParam (const float minLimit, const float maxLimit, float &networkParam) const
	Shift and normalise a network parameter with respect to an input range. More...

Protected Attributes
float	m_vertexRegionRadiusSq
	the radius (squared) in which to search for particle hits More...

pandora::StringVector	m_pfoListNames
	the input pfo list name vector More...

LArGeometryHelper::DetectorBoundaries	m_detectorBoundaries
	the detector boundaries More...

bool	m_areBoundariesSet
	whether the detector boundaries have been set More...

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

bool	IsShowerVertexUpstream (const HierarchyPfo &parentHierarchyPfo, const HierarchyPfo &childHierarchyPfo) const
	Whether the shower POI is the endpoint closest to the neutrino vertex. More...

pandora::StatusCode	CalculateNetworkVariables (const pandora::Algorithm const pAlgorithm, const HierarchyPfo &parentHierarchyPfo, const HierarchyPfo &childHierarchyPfo, const pandora::ParticleFlowObject const pNeutrinoPfo, const bool useUpstreamForParent, const bool useUpstreamForChild, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Function to calculate the DLLaterTierNetworkParams. More...

void	SetCommonParams (const std::pair< float, float > &trackScoreParams, const std::pair< float, float > &nSpacepointsParams, const float separation3D, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the orientation independent DLLaterTierNetworkParams (m_parentTrackScore, m_childTrackScore, m_parentNSpacepoints, m_childNSpacepoints, m_separation3D) More...

void	SetVertexParams (const pandora::CartesianVector &nuVertex, const pandora::CartesianVector &parentStartPos, const pandora::CartesianVector &parentEndPos, const pandora::CartesianVector &childStartPos, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the vertex related DLLaterTierNetworkParams (m_parentNuVertexSep, m_childNuVertexSep, m_vertexSeparation) More...

void	SetEndRegionParams (const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pParentPfo, const pandora::CartesianVector &parentEndPos, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the parent endpoint region DLLaterTierNetworkParams (m_parentEndRegionNHits, m_parentEndRegionNParticles, m_parentEndRegionRToWall) More...

void	SetEndRegionRToWall (const pandora::CartesianVector &parentEndPos, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the m_parentEndRegionRToWall DLLaterTierNetworkParam. More...

void	SetConnectionParams (const HierarchyPfo &parentHierarchyPfo, const pandora::CartesianVector &parentStartPos, const ExtremalPoint &childStart, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the child connection DLLaterTierNetworkParams (m_doesChildConnect, m_connectionPoint, m_connectionDirection, m_childCPDCA, m_childCPExtrapDistance, m_childCPLRatio) More...

std::pair< pandora::CartesianVector, bool >	ExtrapolateChildToParent (const pandora::CartesianVector &parentPosition, const ExtremalPoint &childStart) const
	Project the (parentPos - childStartPos) vector onto the child direction axis to obtain an extrapolation position. More...

bool	DoesConnect (const pandora::CartesianVector &boundary1, const pandora::CartesianVector &boundary2, const pandora::CartesianVector &testPoint) const
	Return whether an input position connects to a line defined by two endpoints. More...

void	SetOvershootParams (const ExtremalPoint &parentStart, const ExtremalPoint &parentEnd, const ExtremalPoint &childStart, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the overshoot DLLaterTierNetworkParams (m_overshootStartDCA, m_overshootStartL, m_overshootEndDCA, m_overshootEndL) More...

void	SetParentConnectionPointVars (const HierarchyPfo &parentHierarchyPfo, DLLaterTierNetworkParams &laterTierNetworkParams) const
	Set the parent connection point DLLaterTierNetworkParams (m_parentCPNUpstreamHits, m_parentCPNDownstreamHits, m_parentCPNHitRatio, m_parentCPEigenvalueRatio, m_parentCPOpeningAngle) More...

void	NormaliseNetworkParams (DLLaterTierNetworkParams &laterTierNetworkParams) const
	Shift and normalise the later tier network parameters. More...

float	ClassifyTrackTrack (const DLLaterTierNetworkParams &edgeParamsUpUp, const DLLaterTierNetworkParams &edgeParamsUpDown, const DLLaterTierNetworkParams &edgeParamsDownUp, const DLLaterTierNetworkParams &edgeParamsDownDown)
	Apply the track-track parent-child classification network. More...

pandora::FloatVector	ClassifyTrackTrackEdge (const DLLaterTierNetworkParams &edgeParams, const DLLaterTierNetworkParams &otherEdgeParams1, const DLLaterTierNetworkParams &otherEdgeParams2, const DLLaterTierNetworkParams &otherEdgeParams3)
	Apply the track-track orientation edge network - determine whether an edge is signal (with correct orientation), signal (with the wrong orientation) or background. More...

float	ClassifyTrackShower (const DLLaterTierNetworkParams &edgeParamsUp, const DLLaterTierNetworkParams &edgeParamsDown)
	Apply the track-shower parent-child classification network. More...

pandora::FloatVector	ClassifyTrackShowerEdge (const DLLaterTierNetworkParams &edgeParams, const DLLaterTierNetworkParams &otherEdgeParams)
	Apply the track-shower orientation edge network - determine whether an edge is signal (with correct orientation), signal (with the wrong orientation) or background. More...

Private Attributes
std::string	m_trackTrackBranchModelName
	the name of the track-track edge model file More...

std::string	m_trackTrackClassifierModelName
	the name of the track-track classification model file More...

std::string	m_trackShowerBranchModelName
	the name of the track-shower edge model file More...

std::string	m_trackShowerClassifierModelName
	the name of the track-shower classification model file More...

LArDLHelper::TorchModel	m_trackTrackBranchModel
	the track-track edge model More...

LArDLHelper::TorchModel	m_trackTrackClassifierModel
	the track-track classification model More...

LArDLHelper::TorchModel	m_trackShowerBranchModel
	the track-shower edge model More...

LArDLHelper::TorchModel	m_trackShowerClassifierModel
	the track-shower classification model More...

bool	m_trainingMode
	whether to run the tool in training mode More...

float	m_trajectoryStepSize
	the size of the steps taken to trace the parent trajectory More...

float	m_connectionBuffer
	the 'is child connected?' threshold More...

float	m_searchRegion
	the dimensions of the box used to obtain the up/downstream 3D hit groups More...

bool	m_normalise
	whether to normalise the network parameters More...

NormalisationLimits	m_normLimits
	struct of the normalisation limits More...

Detailed Description

DLLaterTierHierarchyTool to apply the later-tier hierarchy DL networks.

Definition at line 23 of file DLLaterTierHierarchyTool.h.

Constructor & Destructor Documentation

lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierHierarchyTool ( )

Default constructor.

Definition at line 59 of file DLLaterTierHierarchyTool.cc.

                                                    :
     DLBaseHierarchyTool(),
     m_trainingMode(false),
     m_trajectoryStepSize(1.f),
     m_connectionBuffer(50.f),
     m_searchRegion(10.f),
     m_normalise(true)
 {
 }

Member Function Documentation

StatusCode lar_dl_content::DLLaterTierHierarchyTool::CalculateNetworkVariables	(	const pandora::Algorithm *const	pAlgorithm,
		const HierarchyPfo &	parentHierarchyPfo,
		const HierarchyPfo &	childHierarchyPfo,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const bool	useUpstreamForParent,
		const bool	useUpstreamForChild,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Function to calculate the DLLaterTierNetworkParams.

Parameters

pAlgorithm	a pointer to the pandora algorithm
parentHierarchyPfo	the HierarchyPfo object of the parent pfo
childHierarchyPfo	the HierarchyPfo object of the child pfo
pNeutrinoPfo	a pointer to the neutrino pfo
useUpstreamForParent	whether the parent POI is that closest to the nu vertex
useUpstreamForChild	whether the child POI is that closest to the nu vertex
laterTierNetworkParams	the later tier network parameters to fill

Returns: a StatusCode to signify whether the network variables could be correctly calculated

Definition at line 175 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::HierarchyPfo::GetDownstreamPoint(), lar_dl_content::HierarchyPfo::GetPfo(), lar_dl_content::HierarchyPfo::GetUpstreamPoint(), lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childIsPOIClosestToNu, m_normalise, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentIsPOIClosestToNu, NormaliseNetworkParams(), SetConnectionParams(), SetEndRegionParams(), SetOvershootParams(), SetParentConnectionPointVars(), and SetVertexParams().

Referenced by Run().

 {
     // Pick out neutrino vertex
     if (pNeutrinoPfo->GetVertexList().empty())
         return STATUS_CODE_NOT_INITIALIZED;
 
     const Vertex *const pNeutrinoVertex(LArPfoHelper::GetVertex(pNeutrinoPfo));
     const CartesianVector nuVertex(
         pNeutrinoVertex->GetPosition().GetX(), pNeutrinoVertex->GetPosition().GetY(), pNeutrinoVertex->GetPosition().GetZ());
 
     // Pick out the correct pfo vertex/direction
     // Parent POI is a postulate endpoint
     // Child POI is a postulate startpoint
     const ExtremalPoint &parentStart(useUpstreamForParent ? parentHierarchyPfo.GetDownstreamPoint() : parentHierarchyPfo.GetUpstreamPoint());
     const ExtremalPoint &parentEnd(useUpstreamForParent ? parentHierarchyPfo.GetUpstreamPoint() : parentHierarchyPfo.GetDownstreamPoint());
     const ExtremalPoint &childStart(useUpstreamForChild ? childHierarchyPfo.GetUpstreamPoint() : childHierarchyPfo.GetDownstreamPoint());
 
     // Check that we could actually calculate pfo vertex/direction, return if not
     if (!parentStart.IsSet())
     {
         return STATUS_CODE_NOT_INITIALIZED;
     }
     if (!parentEnd.IsSet())
     {
         return STATUS_CODE_NOT_INITIALIZED;
     }
     if (!childStart.IsSet())
     {
         return STATUS_CODE_NOT_INITIALIZED;
     }
 
     // Set laterTierNetworkParams
     laterTierNetworkParams.m_parentIsPOIClosestToNu = useUpstreamForParent ? 1.f : 0.f;
     laterTierNetworkParams.m_childIsPOIClosestToNu = useUpstreamForChild ? 1.f : 0.f;
     this->SetVertexParams(nuVertex, parentStart.GetPosition(), parentEnd.GetPosition(), childStart.GetPosition(), laterTierNetworkParams);
     this->SetEndRegionParams(pAlgorithm, parentHierarchyPfo.GetPfo(), parentEnd.GetPosition(), laterTierNetworkParams);
     this->SetConnectionParams(parentHierarchyPfo, parentStart.GetPosition(), childStart, laterTierNetworkParams);
     this->SetOvershootParams(parentStart, parentEnd, childStart, laterTierNetworkParams);
     this->SetParentConnectionPointVars(parentHierarchyPfo, laterTierNetworkParams);
 
     // Normalise
     if (m_normalise)
         this->NormaliseNetworkParams(laterTierNetworkParams);
 
     return STATUS_CODE_SUCCESS;
 }

float lar_dl_content::DLLaterTierHierarchyTool::ClassifyTrackShower	(	const DLLaterTierNetworkParams &	edgeParamsUp,
		const DLLaterTierNetworkParams &	edgeParamsDown
	)

private

Apply the track-shower parent-child classification network.

Parameters

edgeParamsUp	the DLLaterTierNetworkParams for the parent upstream POI
edgeParamsDown	the DLLaterTierNetworkParams for the parent upstream POI

Returns: the network score (how likely to be signal)

Definition at line 550 of file DLLaterTierHierarchyTool.cc.

References ClassifyTrackShowerEdge(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_trackShowerClassifierModel.

Referenced by Run().

 {
     // Invoke branch model for each edge
     const FloatVector outputUp(this->ClassifyTrackShowerEdge(edgeParamsUp, edgeParamsDown));
     const FloatVector outputDown(this->ClassifyTrackShowerEdge(edgeParamsDown, edgeParamsUp));
 
     // Invoke classifier model for final output
     LArDLHelper::TorchInput input;
     LArDLHelper::InitialiseInput({1, 6}, input);
 
     int insertIndex(0);
 
     for (const FloatVector &edgeOutput : {outputUp, outputDown})
     {
         for (int i = 0; i < 3; ++i)
         {
             input[0][insertIndex] = edgeOutput.at(i);
             ++insertIndex;
         }
     }
 
     LArDLHelper::TorchOutput output;
     LArDLHelper::Forward(m_trackShowerClassifierModel, {input}, output);
     const torch::TensorAccessor<float, 2> outputAccessor = output.accessor<float, 2>();
 
     return outputAccessor[0][0];
 }

FloatVector lar_dl_content::DLLaterTierHierarchyTool::ClassifyTrackShowerEdge	(	const DLLaterTierNetworkParams &	edgeParams,
		const DLLaterTierNetworkParams &	otherEdgeParams
	)

private

Apply the track-shower orientation edge network - determine whether an edge is signal (with correct orientation), signal (with the wrong orientation) or background.

Parameters

edgeParams	the DLLaterTierNetworkParams of the edge to classify
otherEdgeParams	the DLLaterTierNetworkParams of another edge

Returns: the float vector of (signal, wrong orientation, background) scores

Definition at line 580 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::AddCommonParamsToInput(), lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::AddOrientationParamsToInput(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_trackShowerBranchModel.

Referenced by ClassifyTrackShower().

 {
     LArDLHelper::TorchInput input;
     LArDLHelper::InitialiseInput({1, 47}, input);
 
     int insertIndex(0);
     edgeParams.AddCommonParamsToInput(insertIndex, input);
     edgeParams.AddOrientationParamsToInput(insertIndex, input);
     otherEdgeParams.AddOrientationParamsToInput(insertIndex, input);
 
     LArDLHelper::TorchOutput output;
     LArDLHelper::Forward(m_trackShowerBranchModel, {input}, output);
 
     const torch::TensorAccessor<float, 2> outputAccessor(output.accessor<float, 2>());
 
     return {outputAccessor[0][0], outputAccessor[0][1], outputAccessor[0][2]};
 }

float lar_dl_content::DLLaterTierHierarchyTool::ClassifyTrackTrack	(	const DLLaterTierNetworkParams &	edgeParamsUpUp,
		const DLLaterTierNetworkParams &	edgeParamsUpDown,
		const DLLaterTierNetworkParams &	edgeParamsDownUp,
		const DLLaterTierNetworkParams &	edgeParamsDownDown
	)

private

Apply the track-track parent-child classification network.

Parameters

edgeParamsUpUp	the DLLaterTierNetworkParams for the parent upstream POI and child upstream POI
edgeParamsUpDown	the DLLaterTierNetworkParams for the parent upstream POI and child downstream POI
edgeParamsDownUp	the DLLaterTierNetworkParams for the parent downstream POI and child upstream POI
edgeParamsDownDown	the DLLaterTierNetworkParams for the parent downstream POI and child downstream POI

Returns: the network score (how likely to be signal)

Definition at line 494 of file DLLaterTierHierarchyTool.cc.

References ClassifyTrackTrackEdge(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_trackTrackClassifierModel.

Referenced by Run().

 {
     // Invoke branch model for each edge
     const FloatVector outputUpUp(this->ClassifyTrackTrackEdge(edgeParamsUpUp, edgeParamsUpDown, edgeParamsDownUp, edgeParamsDownDown));
     const FloatVector outputUpDown(this->ClassifyTrackTrackEdge(edgeParamsUpDown, edgeParamsDownUp, edgeParamsDownDown, edgeParamsUpUp));
     const FloatVector outputDownUp(this->ClassifyTrackTrackEdge(edgeParamsDownUp, edgeParamsDownDown, edgeParamsUpUp, edgeParamsUpDown));
     const FloatVector outputDownDown(this->ClassifyTrackTrackEdge(edgeParamsDownDown, edgeParamsUpUp, edgeParamsUpDown, edgeParamsDownUp));
 
     // Invoke classifier model for final output
     LArDLHelper::TorchInput input;
     LArDLHelper::InitialiseInput({1, 12}, input);
 
     int insertIndex(0);
 
     for (const FloatVector &edgeOutput : {outputUpUp, outputUpDown, outputDownUp, outputDownDown})
     {
         for (int i = 0; i < 3; ++i)
         {
             input[0][insertIndex] = edgeOutput.at(i);
             ++insertIndex;
         }
     }
 
     LArDLHelper::TorchOutput output;
     LArDLHelper::Forward(m_trackTrackClassifierModel, {input}, output);
     const torch::TensorAccessor<float, 2> outputAccessor = output.accessor<float, 2>();
 
     return outputAccessor[0][0];
 }

FloatVector lar_dl_content::DLLaterTierHierarchyTool::ClassifyTrackTrackEdge	(	const DLLaterTierNetworkParams &	edgeParams,
		const DLLaterTierNetworkParams &	otherEdgeParams1,
		const DLLaterTierNetworkParams &	otherEdgeParams2,
		const DLLaterTierNetworkParams &	otherEdgeParams3
	)

private

Apply the track-track orientation edge network - determine whether an edge is signal (with correct orientation), signal (with the wrong orientation) or background.

Parameters

edgeParams	the DLLaterTierNetworkParams of the edge to classify
otherEdgeParams1	the DLLaterTierNetworkParams of another edge
otherEdgeParams2	the DLLaterTierNetworkParams of another another edge
otherEdgeParams3	the DLLaterTierNetworkParams of another another another edge

Returns: the float vector of (signal, wrong orientation, background) scores

Definition at line 527 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::AddCommonParamsToInput(), lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::AddOrientationParamsToInput(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_trackTrackBranchModel.

Referenced by ClassifyTrackTrack().

 {
     LArDLHelper::TorchInput input;
     LArDLHelper::InitialiseInput({1, 89}, input);
 
     int insertIndex(0);
     edgeParams.AddCommonParamsToInput(insertIndex, input);
     edgeParams.AddOrientationParamsToInput(insertIndex, input);
     otherEdgeParams1.AddOrientationParamsToInput(insertIndex, input);
     otherEdgeParams2.AddOrientationParamsToInput(insertIndex, input);
     otherEdgeParams3.AddOrientationParamsToInput(insertIndex, input);
 
     LArDLHelper::TorchOutput output;
     LArDLHelper::Forward(m_trackTrackBranchModel, {input}, output);
 
     const torch::TensorAccessor<float, 2> outputAccessor(output.accessor<float, 2>());
 
     return {outputAccessor[0][0], outputAccessor[0][1], outputAccessor[0][2]};
 }

bool lar_dl_content::DLLaterTierHierarchyTool::DoesConnect	(	const pandora::CartesianVector &	boundary1,
		const pandora::CartesianVector &	boundary2,
		const pandora::CartesianVector &	testPoint
	)		const

private

Return whether an input position connects to a line defined by two endpoints.

Parameters

boundary1	one end position
boundary2	the other end position
testPoint	the input position

Returns: whether the input position connects to the line defined by the two input endpoints

Definition at line 353 of file DLLaterTierHierarchyTool.cc.

References f, and m_connectionBuffer.

Referenced by SetConnectionParams().

 {
     const CartesianVector displacement(boundary2 - boundary1);
     const double segmentLength(displacement.GetMagnitude());
     const CartesianVector unitVector(displacement * (1.f / segmentLength));
     const double l(unitVector.GetDotProduct(testPoint - boundary1));
 
     if ((l < 0.f) || (l > segmentLength))
         return false;
 
     const double t(unitVector.GetCrossProduct(testPoint - boundary1).GetMagnitudeSquared());
 
     if (t > (m_connectionBuffer * m_connectionBuffer))
         return false;
 
     return true;
 }

std::pair< CartesianVector, bool > lar_dl_content::DLLaterTierHierarchyTool::ExtrapolateChildToParent	(	const pandora::CartesianVector &	parentPosition,
		const ExtremalPoint &	childStart
	)		const

private

Project the (parentPos - childStartPos) vector onto the child direction axis to obtain an extrapolation position.

Parameters

parentPosition	the parent position
childStart	the assumed child pfo startpoint

Returns: the (extrapolated position, whether the extrpolation was backwards wrt the child direction) pair

Definition at line 342 of file DLLaterTierHierarchyTool.cc.

References f, lar_dl_content::ExtremalPoint::GetDirection(), and lar_dl_content::ExtremalPoint::GetPosition().

Referenced by SetConnectionParams(), and SetOvershootParams().

 {
     const double extrapDistance((parentPos - childStart.GetPosition()).GetDotProduct(childStart.GetDirection()));
     const bool backwardsExtrap(extrapDistance < 0.f);
     const CartesianVector extrapPoint(childStart.GetPosition() + (childStart.GetDirection() * extrapDistance));
 
     return std::pair<CartesianVector, bool>({extrapPoint, backwardsExtrap});
 }

std::pair< float, float > lar_dl_content::DLBaseHierarchyTool::GetParticleInfoAboutPfoPosition	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pPfo,
		const pandora::CartesianVector &	pointOfInterest
	)		const

protectedinherited

Return the number of 3D hits and the number of corresponding pfos of a given pfo about a point.

Parameters

pAlgorithm	a pointer to the pandora algorithm calling the tool
pPfo	a pointer to the pfo
pointOfInterest	the input position

Returns: std::pair of the number of 3D hits and the number of corresponding pfos

Definition at line 47 of file DLBaseHierarchyTool.cc.

References lar_dl_content::DLBaseHierarchyTool::m_pfoListNames, and lar_dl_content::DLBaseHierarchyTool::m_vertexRegionRadiusSq.

Referenced by SetEndRegionParams(), and lar_dl_content::DLPrimaryHierarchyTool::SetVertexRegionParams().

 {
     int hitCount(0);
     int particleCount(0);
 
     for (const std::string &pfoListName : m_pfoListNames)
     {
         const PfoList *pPfoList(nullptr);
         if (PandoraContentApi::GetList(*pAlgorithm, pfoListName, pPfoList) != STATUS_CODE_SUCCESS)
             continue;
 
         for (const ParticleFlowObject *const pOtherPfo : *pPfoList)
         {
             if (pPfo == pOtherPfo)
                 continue;
 
             bool isClose(false);
 
             CartesianPointVector otherPfoPositions3D;
             LArPfoHelper::GetCoordinateVector(pOtherPfo, TPC_3D, otherPfoPositions3D);
 
             for (const CartesianVector &otherPfoPosition : otherPfoPositions3D)
             {
                 const double sepSq((otherPfoPosition - pointOfInterest).GetMagnitudeSquared());
 
                 if (sepSq < m_vertexRegionRadiusSq)
                 {
                     isClose = true;
                     ++hitCount;
                 }
             }
 
             if (isClose)
                 ++particleCount;
         }
     }
 
     return std::pair<float, float>({hitCount, particleCount});
 }

bool lar_dl_content::DLLaterTierHierarchyTool::IsShowerVertexUpstream	(	const HierarchyPfo &	parentHierarchyPfo,
		const HierarchyPfo &	childHierarchyPfo
	)		const

private

Whether the shower POI is the endpoint closest to the neutrino vertex.

Parameters

parentHierarchyPfo	the HierarchyPfo object of the parent pfo
childHierarchyPfo	the HierarchyPfo object of the child pfo

Returns: whether the shower POI is in the upstream position

Definition at line 128 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::HierarchyPfo::GetDownstreamPoint(), lar_dl_content::HierarchyPfo::GetPfo(), lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::HierarchyPfo::GetUpstreamPoint(), and lar_dl_content::ExtremalPoint::IsSet().

Referenced by Run().

 {
     const bool isUpstreamSet(childHierarchyPfo.GetUpstreamPoint().IsSet());
     const bool isDownstreamSet(childHierarchyPfo.GetDownstreamPoint().IsSet());
 
     if (isUpstreamSet && !isDownstreamSet)
         return true;
 
     if (!isUpstreamSet && isDownstreamSet)
         return false;
 
     // By design, showers should have at least one set
     if (!isUpstreamSet && !isDownstreamSet)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     CartesianPointVector parentPositions3D;
     LArPfoHelper::GetCoordinateVector(parentHierarchyPfo.GetPfo(), TPC_3D, parentPositions3D);
 
     float upstreamSepSq(std::numeric_limits<float>::max());
     float downstreamSepSq(std::numeric_limits<float>::max());
 
     for (const CartesianVector &parentPosition3D : parentPositions3D)
     {
         const float thisUpstreamSepSq((parentPosition3D - childHierarchyPfo.GetUpstreamPoint().GetPosition()).GetMagnitudeSquared());
         const float thisDownstreamSepSq((parentPosition3D - childHierarchyPfo.GetDownstreamPoint().GetPosition()).GetMagnitudeSquared());
 
         upstreamSepSq = std::min(upstreamSepSq, thisUpstreamSepSq);
         downstreamSepSq = std::min(downstreamSepSq, thisDownstreamSepSq);
     }
 
     return (upstreamSepSq < downstreamSepSq);
 }

void lar_dl_content::DLBaseHierarchyTool::NormaliseNetworkParam	(	const float	minLimit,
		const float	maxLimit,
		float &	networkParam
	)		const

protectedinherited

Shift and normalise a network parameter with respect to an input range.

Parameters

minLimit	the minimum allowed value of the variable
maxLimit	the maximum allowed value of the variable
networkParam	the input network parameter value

Definition at line 90 of file DLBaseHierarchyTool.cc.

Referenced by lar_dl_content::DLPrimaryHierarchyTool::NormaliseNetworkParams(), and NormaliseNetworkParams().

 {
     const float interval(std::fabs(maxLimit - minLimit));
 
     if (interval < std::numeric_limits<float>::epsilon())
     {
         networkParam = minLimit;
         return;
     }
 
     if (networkParam < minLimit)
         networkParam = minLimit;
 
     if (networkParam > maxLimit)
         networkParam = maxLimit;
 
     networkParam /= interval;
 }

void lar_dl_content::DLLaterTierHierarchyTool::NormaliseNetworkParams ( DLLaterTierNetworkParams & laterTierNetworkParams ) const

private

Shift and normalise the later tier network parameters.

Parameters

laterTierNetworkParam the input later tier network parameters

Definition at line 460 of file DLLaterTierHierarchyTool.cc.

Referenced by CalculateNetworkVariables().

 {
     this->NormaliseNetworkParam(m_normLimits.m_trackScoreMin, m_normLimits.m_trackScoreMax, laterTierNetworkParams.m_parentTrackScore);
     this->NormaliseNetworkParam(m_normLimits.m_trackScoreMin, m_normLimits.m_trackScoreMax, laterTierNetworkParams.m_childTrackScore);
     this->NormaliseNetworkParam(m_normLimits.m_nSpacepointsMin, m_normLimits.m_nSpacepointsMax, laterTierNetworkParams.m_parentNSpacepoints);
     this->NormaliseNetworkParam(m_normLimits.m_nSpacepointsMin, m_normLimits.m_nSpacepointsMax, laterTierNetworkParams.m_childNSpacepoints);
     this->NormaliseNetworkParam(m_normLimits.m_separation3DMin, m_normLimits.m_separation3DMax, laterTierNetworkParams.m_separation3D);
     this->NormaliseNetworkParam(m_normLimits.m_nuVertexSepMin, m_normLimits.m_nuVertexSepMax, laterTierNetworkParams.m_parentNuVertexSep);
     this->NormaliseNetworkParam(m_normLimits.m_nuVertexSepMin, m_normLimits.m_nuVertexSepMax, laterTierNetworkParams.m_childNuVertexSep);
     this->NormaliseNetworkParam(m_normLimits.m_parentEndRegionNHitsMin, m_normLimits.m_parentEndRegionNHitsMax, laterTierNetworkParams.m_parentEndRegionNHits);
     this->NormaliseNetworkParam(m_normLimits.m_parentEndRegionNParticlesMin, m_normLimits.m_parentEndRegionNParticlesMax,
         laterTierNetworkParams.m_parentEndRegionNParticles);
     this->NormaliseNetworkParam(
         m_normLimits.m_parentEndRegionRToWallMin, m_normLimits.m_parentEndRegionRToWallMax, laterTierNetworkParams.m_parentEndRegionRToWall);
     this->NormaliseNetworkParam(m_normLimits.m_vertexSepMin, m_normLimits.m_vertexSepMax, laterTierNetworkParams.m_vertexSeparation);
     this->NormaliseNetworkParam(m_normLimits.m_doesChildConnectMin, m_normLimits.m_doesChildConnectMax, laterTierNetworkParams.m_doesChildConnect);
     this->NormaliseNetworkParam(m_normLimits.m_overshootDCAMin, m_normLimits.m_overshootDCAMax, laterTierNetworkParams.m_overshootStartDCA);
     this->NormaliseNetworkParam(m_normLimits.m_overshootLMin, m_normLimits.m_overshootLMax, laterTierNetworkParams.m_overshootStartL);
     this->NormaliseNetworkParam(m_normLimits.m_overshootDCAMin, m_normLimits.m_overshootDCAMax, laterTierNetworkParams.m_overshootEndDCA);
     this->NormaliseNetworkParam(m_normLimits.m_overshootLMin, m_normLimits.m_overshootLMax, laterTierNetworkParams.m_overshootEndL);
     this->NormaliseNetworkParam(m_normLimits.m_childCPDCAMin, m_normLimits.m_childCPDCAMax, laterTierNetworkParams.m_childCPDCA);
     this->NormaliseNetworkParam(
         m_normLimits.m_childCPExtrapDistanceMin, m_normLimits.m_childCPExtrapDistanceMax, laterTierNetworkParams.m_childCPExtrapDistance);
     this->NormaliseNetworkParam(m_normLimits.m_childCPLRatioMin, m_normLimits.m_childCPLRatioMax, laterTierNetworkParams.m_childCPLRatio);
     this->NormaliseNetworkParam(m_normLimits.m_parentCPNHitsMin, m_normLimits.m_parentCPNHitsMax, laterTierNetworkParams.m_parentCPNUpstreamHits);
     this->NormaliseNetworkParam(m_normLimits.m_parentCPNHitsMin, m_normLimits.m_parentCPNHitsMax, laterTierNetworkParams.m_parentCPNDownstreamHits);
     this->NormaliseNetworkParam(m_normLimits.m_parentCPNHitRatioMin, m_normLimits.m_parentCPNHitRatioMax, laterTierNetworkParams.m_parentCPNHitRatio);
     this->NormaliseNetworkParam(m_normLimits.m_parentCPEigenvalueRatioMin, m_normLimits.m_parentCPEigenvalueRatioMax,
         laterTierNetworkParams.m_parentCPEigenvalueRatio);
     this->NormaliseNetworkParam(m_normLimits.m_parentCPOpeningAngleMin, m_normLimits.m_parentCPOpeningAngleMax, laterTierNetworkParams.m_parentCPOpeningAngle);
 }

StatusCode lar_dl_content::DLLaterTierHierarchyTool::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 600 of file DLLaterTierHierarchyTool.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingMode", m_trainingMode));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrajectoryStepSize", m_trajectoryStepSize));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConnectionBuffer", m_connectionBuffer));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SearchRegion", m_searchRegion));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Normalise", m_normalise));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrackScoreMin", m_normLimits.m_trackScoreMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrackScoreMax", m_normLimits.m_trackScoreMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NSpacepointsMin", m_normLimits.m_nSpacepointsMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NSpacepointsMax", m_normLimits.m_nSpacepointsMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Separation3DMin", m_normLimits.m_separation3DMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Separation3DMax", m_normLimits.m_separation3DMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NuVertexSepMin", m_normLimits.m_nuVertexSepMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NuVertexSepMax", m_normLimits.m_nuVertexSepMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentEndRegionNHitsMin", m_normLimits.m_parentEndRegionNHitsMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentEndRegionNHitsMax", m_normLimits.m_parentEndRegionNHitsMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentEndRegionNParticlesMin", m_normLimits.m_parentEndRegionNParticlesMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentEndRegionNParticlesMax", m_normLimits.m_parentEndRegionNParticlesMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentEndRegionRToWallMin", m_normLimits.m_parentEndRegionRToWallMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentEndRegionRToWallMax", m_normLimits.m_parentEndRegionRToWallMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexSepMin", m_normLimits.m_vertexSepMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexSepMax", m_normLimits.m_vertexSepMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "DoesChildConnectMin", m_normLimits.m_doesChildConnectMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "DoesChildConnectMax", m_normLimits.m_doesChildConnectMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OvershootDCAMin", m_normLimits.m_overshootDCAMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OvershootDCAMax", m_normLimits.m_overshootDCAMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OvershootLMin", m_normLimits.m_overshootLMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "OvershootLMax", m_normLimits.m_overshootLMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ChildCPDCAMin", m_normLimits.m_childCPDCAMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ChildCPDCAMax", m_normLimits.m_childCPDCAMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ChildCPExtrapDistanceMin", m_normLimits.m_childCPExtrapDistanceMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ChildCPExtrapDistanceMax", m_normLimits.m_childCPExtrapDistanceMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ChildCPLRatioMin", m_normLimits.m_childCPLRatioMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ChildCPLRatioMax", m_normLimits.m_childCPLRatioMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPNHitsMin", m_normLimits.m_parentCPNHitsMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPNHitsMax", m_normLimits.m_parentCPNHitsMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPNHitRatioMin", m_normLimits.m_parentCPNHitRatioMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPNHitRatioMax", m_normLimits.m_parentCPNHitRatioMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPEigenvalueRatioMin", m_normLimits.m_parentCPEigenvalueRatioMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPEigenvalueRatioMax", m_normLimits.m_parentCPEigenvalueRatioMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPOpeningAngleMin", m_normLimits.m_parentCPOpeningAngleMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentCPOpeningAngleMax", m_normLimits.m_parentCPOpeningAngleMax));
 
     if (!m_trainingMode)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrackTrackBranchModelName", m_trackTrackBranchModelName));
         m_trackTrackBranchModelName = LArFileHelper::FindFileInPath(m_trackTrackBranchModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_trackTrackBranchModelName, m_trackTrackBranchModel));
 
         PANDORA_RETURN_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrackTrackClassifierModelName", m_trackTrackClassifierModelName));
         m_trackTrackClassifierModelName = LArFileHelper::FindFileInPath(m_trackTrackClassifierModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_trackTrackClassifierModelName, m_trackTrackClassifierModel));
 
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrackShowerBranchModelName", m_trackShowerBranchModelName));
         m_trackShowerBranchModelName = LArFileHelper::FindFileInPath(m_trackShowerBranchModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_trackShowerBranchModelName, m_trackShowerBranchModel));
 
         PANDORA_RETURN_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrackShowerClassifierModelName", m_trackShowerClassifierModelName));
         m_trackShowerClassifierModelName = LArFileHelper::FindFileInPath(m_trackShowerClassifierModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_trackShowerClassifierModelName, m_trackShowerClassifierModel));
     }
 
     return DLBaseHierarchyTool::ReadSettings(xmlHandle);
 }

StatusCode lar_dl_content::DLLaterTierHierarchyTool::Run	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfo &	parentHierarchyPfo,
		const HierarchyPfo &	childHierarchyPfo,
		std::vector< DLLaterTierNetworkParams > &	networkParamVector,
		float &	laterTierScore
	)

Definition at line 71 of file DLLaterTierHierarchyTool.cc.

References CalculateNetworkVariables(), ClassifyTrackShower(), ClassifyTrackTrack(), lar_dl_content::HierarchyPfo::GetPfo(), IsShowerVertexUpstream(), m_trainingMode, SetCommonParams(), and lar_dl_content::DLBaseHierarchyTool::SetDetectorBoundaries().

Referenced by lar_dl_content::DLNeutrinoHierarchyAlgorithm::BuildPandoraHierarchy(), and lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetLaterTierScore().

 {
     networkParamVector.clear();
     laterTierScore = std::numeric_limits<float>::lowest();
 
     this->SetDetectorBoundaries();
 
     // Get the common params i.e. independent of postulated orientation
     const std::pair<float, float> trackScoreParams(
         {LArPfoHelper::GetTrackScore(parentHierarchyPfo.GetPfo()), LArPfoHelper::GetTrackScore(childHierarchyPfo.GetPfo())});
     const std::pair<float, float> nSpacepointsParams(
         {LArPfoHelper::GetNumberOfThreeDHits(parentHierarchyPfo.GetPfo()), LArPfoHelper::GetNumberOfThreeDHits(childHierarchyPfo.GetPfo())});
     const float separation3D(LArPfoHelper::GetThreeDSeparation(parentHierarchyPfo.GetPfo(), childHierarchyPfo.GetPfo()));
 
     const bool isChildTrack(childHierarchyPfo.GetPfo()->GetParticleId() == 13);
     std::vector<bool> childOrientationVector(
         isChildTrack ? std::vector<bool>({true, false}) : std::vector<bool>({this->IsShowerVertexUpstream(parentHierarchyPfo, childHierarchyPfo)}));
 
     // Set network params
     for (const bool &useUpstreamForParent : {true, false})
     {
         for (const bool &useUpstreamForChild : childOrientationVector)
         {
             DLLaterTierNetworkParams edgeParams;
 
             // Set common params
             this->SetCommonParams(trackScoreParams, nSpacepointsParams, separation3D, edgeParams);
 
             // Get orientation dependent params
             const StatusCode statusCode(this->CalculateNetworkVariables(
                 pAlgorithm, parentHierarchyPfo, childHierarchyPfo, pNeutrinoPfo, useUpstreamForParent, useUpstreamForChild, edgeParams));
 
             if (statusCode != STATUS_CODE_SUCCESS)
                 return statusCode;
 
             // Add these to our output vector
             networkParamVector.emplace_back(edgeParams);
         }
     }
 
     // Now run the model!
     if (!m_trainingMode)
     {
         if (isChildTrack)
             laterTierScore =
                 this->ClassifyTrackTrack(networkParamVector.at(0), networkParamVector.at(1), networkParamVector.at(2), networkParamVector.at(3));
         else
             laterTierScore = this->ClassifyTrackShower(networkParamVector.at(0), networkParamVector.at(1));
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetCommonParams	(	const std::pair< float, float > &	trackScoreParams,
		const std::pair< float, float > &	nSpacepointsParams,
		const float	separation3D,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the orientation independent DLLaterTierNetworkParams (m_parentTrackScore, m_childTrackScore, m_parentNSpacepoints, m_childNSpacepoints, m_separation3D)

Parameters

trackScoreParams	the track score (parent, child) pair
nSpacepointsParams	the number of 3D hit (parent, child) pair
separation3D	the smallest 3D distance between the parent and child 3D hits
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 163 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childNSpacepoints, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childTrackScore, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentNSpacepoints, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentTrackScore, and lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_separation3D.

Referenced by Run().

 {
     laterTierNetworkParams.m_parentTrackScore = trackScoreParams.first;
     laterTierNetworkParams.m_childTrackScore = trackScoreParams.second;
     laterTierNetworkParams.m_parentNSpacepoints = nSpacepointsParams.first;
     laterTierNetworkParams.m_childNSpacepoints = nSpacepointsParams.second;
     laterTierNetworkParams.m_separation3D = separation3D;
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetConnectionParams	(	const HierarchyPfo &	parentHierarchyPfo,
		const pandora::CartesianVector &	parentStartPos,
		const ExtremalPoint &	childStart,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the child connection DLLaterTierNetworkParams (m_doesChildConnect, m_connectionPoint, m_connectionDirection, m_childCPDCA, m_childCPExtrapDistance, m_childCPLRatio)

Parameters

parentHierarchyPfo	the HierarchyPfo object of the parent pfo
parentStartPos	the assumed parent pfo start position
childStart	the assumed child startpoint
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 269 of file DLLaterTierHierarchyTool.cc.

References DoesConnect(), ExtrapolateChildToParent(), f, lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::HierarchyPfo::GetSlidingFitResult(), lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childCPDCA, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childCPExtrapDistance, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childCPLRatio, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_connectionDirection, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_connectionPoint, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_doesChildConnect, and m_trajectoryStepSize.

Referenced by CalculateNetworkVariables().

 {
     // Get fit of parent
     const ThreeDSlidingFitResult &slidingFitResult(parentHierarchyPfo.GetSlidingFitResult());
 
     // Now walk along track, starting from parentStartPos
     // I want this to be interpreted as l = 0 so have to alter pandora def
     const bool startFromMin((parentStartPos - slidingFitResult.GetGlobalMinLayerPosition()).GetMagnitudeSquared() <
         (parentStartPos - slidingFitResult.GetGlobalMaxLayerPosition()).GetMagnitudeSquared());
     const float minL(slidingFitResult.GetLongitudinalDisplacement(slidingFitResult.GetGlobalMinLayerPosition()));
     const float maxL(slidingFitResult.GetLongitudinalDisplacement(slidingFitResult.GetGlobalMaxLayerPosition()));
 
     if (std::fabs(minL - maxL) < std::numeric_limits<float>::epsilon())
         return;
 
     const int nSteps(std::floor(std::fabs(maxL - minL) / m_trajectoryStepSize));
 
     // Keep track of these in loop
     float slidingL(startFromMin ? minL : 0.f);
     float trackLength(0.f);
     float minDCA(std::numeric_limits<float>::max());
     float lengthAtConnection(0.f);
 
     laterTierNetworkParams.m_doesChildConnect = 0.f;
 
     for (int i = 0; i < nSteps; i++)
     {
         float firstL(slidingL), secondL(slidingL + m_trajectoryStepSize);
         float firstEvalL(startFromMin ? firstL : (maxL - firstL));
         float secondEvalL(startFromMin ? secondL : (maxL - secondL));
         CartesianVector firstPosition(0.f, 0.f, 0.f);
         CartesianVector secondPosition(0.f, 0.f, 0.f);
 
         if ((slidingFitResult.GetGlobalFitPosition(firstEvalL, firstPosition) != STATUS_CODE_SUCCESS) ||
             (slidingFitResult.GetGlobalFitPosition(secondEvalL, secondPosition) != STATUS_CODE_SUCCESS))
         {
             slidingL += m_trajectoryStepSize;
             continue;
         }
 
         // Get trajectory position
         const CartesianVector midPoint((secondPosition + firstPosition) * 0.5f);
 
         // Extrap child vertex to parent position
         const std::pair<CartesianVector, bool> extrap(this->ExtrapolateChildToParent(midPoint, childStart));
         const float thisDCA((midPoint - extrap.first).GetMagnitude());
 
         if (thisDCA < minDCA)
         {
             if (this->DoesConnect(firstPosition, secondPosition, extrap.first))
             {
                 minDCA = thisDCA;
                 laterTierNetworkParams.m_doesChildConnect = 1.f;
                 laterTierNetworkParams.m_connectionPoint = midPoint;
                 laterTierNetworkParams.m_connectionDirection = (secondPosition - firstPosition).GetUnitVector();
                 laterTierNetworkParams.m_childCPDCA = thisDCA;
                 laterTierNetworkParams.m_childCPExtrapDistance =
                     (extrap.first - childStart.GetPosition()).GetMagnitude() * (extrap.second ? 1.f : (-1.f));
                 lengthAtConnection = trackLength + (midPoint - firstPosition).GetMagnitude();
             }
         }
 
         slidingL += m_trajectoryStepSize;
         trackLength += (secondPosition - firstPosition).GetMagnitude();
     }
 
     if (std::fabs(laterTierNetworkParams.m_doesChildConnect - 1.f) < std::numeric_limits<float>::epsilon())
         laterTierNetworkParams.m_childCPLRatio = lengthAtConnection / trackLength;
 }

void lar_dl_content::DLBaseHierarchyTool::SetDetectorBoundaries ( )

protectedinherited

Set the detector boundaries.

Definition at line 36 of file DLBaseHierarchyTool.cc.

References lar_dl_content::DLBaseHierarchyTool::m_areBoundariesSet, and lar_dl_content::DLBaseHierarchyTool::m_detectorBoundaries.

Referenced by Run(), and lar_dl_content::DLPrimaryHierarchyTool::Run().

 {
     if (m_areBoundariesSet)
         return;
 
     m_detectorBoundaries = LArGeometryHelper::GetDetectorBoundaries(this->GetPandora());
     m_areBoundariesSet = true;
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetEndRegionParams	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pParentPfo,
		const pandora::CartesianVector &	parentEndPos,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the parent endpoint region DLLaterTierNetworkParams (m_parentEndRegionNHits, m_parentEndRegionNParticles, m_parentEndRegionRToWall)

Parameters

pAlgorithm	a pointer to the pandora algorithm
pParentPfo	a pointer to the parent pfo
parentEndPos	the assumed parent pfo end position
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 236 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::DLBaseHierarchyTool::GetParticleInfoAboutPfoPosition(), lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentEndRegionNHits, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentEndRegionNParticles, and SetEndRegionRToWall().

Referenced by CalculateNetworkVariables().

 {
     std::pair<float, float> endRegionParams(this->GetParticleInfoAboutPfoPosition(pAlgorithm, pParentPfo, parentEndPos));
 
     laterTierNetworkParams.m_parentEndRegionNHits = endRegionParams.first;
     laterTierNetworkParams.m_parentEndRegionNParticles = endRegionParams.second;
 
     this->SetEndRegionRToWall(parentEndPos, laterTierNetworkParams);
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetEndRegionRToWall	(	const pandora::CartesianVector &	parentEndPos,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the m_parentEndRegionRToWall DLLaterTierNetworkParam.

Parameters

parentEndPos	the assumed parent pfo end position
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 249 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::DLBaseHierarchyTool::m_detectorBoundaries, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentEndRegionRToWall, lar_content::LArGeometryHelper::DetectorBoundaries::m_xBoundaries, lar_content::LArGeometryHelper::DetectorBoundaries::m_yBoundaries, and lar_content::LArGeometryHelper::DetectorBoundaries::m_zBoundaries.

Referenced by SetEndRegionParams().

 {
     float closestDistance(std::numeric_limits<float>::max());
 
     for (int iAxis : {0, 1, 2})
     {
         const float parentCoord(iAxis == 0 ? parentEndPos.GetX() : iAxis == 1 ? parentEndPos.GetY() : parentEndPos.GetZ());
         const std::pair<float, float> &boundary(iAxis == 0 ? m_detectorBoundaries.m_xBoundaries
                 : iAxis == 1                               ? m_detectorBoundaries.m_yBoundaries
                                                            : m_detectorBoundaries.m_zBoundaries);
         const float dimensionMin(std::min((parentCoord - boundary.first), (boundary.second - parentCoord)));
 
         closestDistance = std::min(closestDistance, dimensionMin);
     }
 
     laterTierNetworkParams.m_parentEndRegionRToWall = closestDistance;
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetOvershootParams	(	const ExtremalPoint &	parentStart,
		const ExtremalPoint &	parentEnd,
		const ExtremalPoint &	childStart,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the overshoot DLLaterTierNetworkParams (m_overshootStartDCA, m_overshootStartL, m_overshootEndDCA, m_overshootEndL)

Parameters

parentStart	the assumed parent pfo startpoint
parentEnd	the assumed parent pfo endpoint
childStart	the assumed child pfo startpoint
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 373 of file DLLaterTierHierarchyTool.cc.

References ExtrapolateChildToParent(), lar_dl_content::ExtremalPoint::GetDirection(), lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_doesChildConnect, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_overshootEndDCA, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_overshootEndL, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_overshootStartDCA, and lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_overshootStartL.

Referenced by CalculateNetworkVariables().

 {
     if (std::fabs(laterTierNetworkParams.m_doesChildConnect - 1.f) < std::numeric_limits<float>::epsilon())
         return;
 
     // Let's start at the very beginning, a very good place to start
     const std::pair<CartesianVector, bool> extrapStart(this->ExtrapolateChildToParent(parentStart.GetPosition(), childStart));
     laterTierNetworkParams.m_overshootStartDCA =
         (extrapStart.first - parentStart.GetPosition()).GetMagnitude() * (extrapStart.second ? 1.f : (-1.f));
     laterTierNetworkParams.m_overshootStartL =
         std::fabs((childStart.GetPosition() - parentStart.GetPosition()).GetDotProduct(parentStart.GetDirection()));
 
     // Now end
     const std::pair<CartesianVector, bool> extrapEnd(this->ExtrapolateChildToParent(parentEnd.GetPosition(), childStart));
     laterTierNetworkParams.m_overshootEndDCA = (extrapEnd.first - parentEnd.GetPosition()).GetMagnitude() * (extrapEnd.second ? 1.f : (-1.f));
     laterTierNetworkParams.m_overshootEndL =
         std::fabs((childStart.GetPosition() - parentEnd.GetPosition()).GetDotProduct(parentEnd.GetDirection()));
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetParentConnectionPointVars	(	const HierarchyPfo &	parentHierarchyPfo,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the parent connection point DLLaterTierNetworkParams (m_parentCPNUpstreamHits, m_parentCPNDownstreamHits, m_parentCPNHitRatio, m_parentCPEigenvalueRatio, m_parentCPOpeningAngle)

Parameters

parentHierarchyPfo	the HierarchyPfo object of the parent pfo
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 395 of file DLLaterTierHierarchyTool.cc.

Referenced by CalculateNetworkVariables().

 {
     if (std::fabs(laterTierNetworkParams.m_doesChildConnect - 1.f) > std::numeric_limits<float>::epsilon())
         return;
 
     // Use direction to current direction to split spacepoints into two groups
     CartesianPointVector parentPositions3D;
     LArPfoHelper::GetCoordinateVector(parentHierarchyPfo.GetPfo(), TPC_3D, parentPositions3D);
 
     CartesianPointVector upstreamGroup, downstreamGroup;
 
     for (const CartesianVector &parentPosition : parentPositions3D)
     {
         const CartesianVector displacement(parentPosition - laterTierNetworkParams.m_connectionPoint);
 
         // Do box as quicker than circle with mag.
         if ((std::fabs(displacement.GetX()) > m_searchRegion) || (std::fabs(displacement.GetY()) > m_searchRegion) ||
             (std::fabs(displacement.GetZ()) > m_searchRegion))
         {
             continue;
         }
 
         // Assign to group
         const float thisL(laterTierNetworkParams.m_connectionDirection.GetDotProduct(displacement));
         CartesianPointVector &group(thisL > 0.f ? downstreamGroup : upstreamGroup);
         group.emplace_back(parentPosition);
     }
 
     laterTierNetworkParams.m_parentCPNUpstreamHits = upstreamGroup.size();
     laterTierNetworkParams.m_parentCPNDownstreamHits = downstreamGroup.size();
 
     if (upstreamGroup.empty() || downstreamGroup.empty())
         return;
 
     laterTierNetworkParams.m_parentCPNHitRatio = laterTierNetworkParams.m_parentCPNDownstreamHits / laterTierNetworkParams.m_parentCPNUpstreamHits;
 
     // Now PCA magic
     try
     {
         CartesianVector centroidUp(0.f, 0.f, 0.f);
         CartesianVector centroidDown(0.f, 0.f, 0.f);
         LArPcaHelper::EigenVectors eigenVecsUp, eigenVecsDown;
         LArPcaHelper::EigenValues eigenValuesUp(0.f, 0.f, 0.f);
         LArPcaHelper::EigenValues eigenValuesDown(0.f, 0.f, 0.f);
 
         LArPcaHelper::RunPca(upstreamGroup, centroidUp, eigenValuesUp, eigenVecsUp);
         LArPcaHelper::RunPca(downstreamGroup, centroidDown, eigenValuesDown, eigenVecsDown);
 
         // Get opening angle from first eigenvectors (this is the longitudinal one) - straight would be around 180
         laterTierNetworkParams.m_parentCPOpeningAngle = eigenVecsUp.at(0).GetOpeningAngle(eigenVecsDown.at(0)) * (180.f / 3.14);
 
         // Get average transverse eigenvalues, get ratio
         const float avTransEVaUp((eigenValuesUp.GetY() + eigenValuesUp.GetZ()) * 0.5f);
         const float avTransEVaDown((eigenValuesDown.GetY() + eigenValuesDown.GetZ()) * 0.5f);
 
         laterTierNetworkParams.m_parentCPEigenvalueRatio = avTransEVaUp < std::numeric_limits<double>::epsilon() ? 0.f : avTransEVaDown / avTransEVaUp;
     }
     catch (...)
     {
         return;
     }
 }

void lar_dl_content::DLLaterTierHierarchyTool::SetVertexParams	(	const pandora::CartesianVector &	nuVertex,
		const pandora::CartesianVector &	parentStartPos,
		const pandora::CartesianVector &	parentEndPos,
		const pandora::CartesianVector &	childStartPos,
		DLLaterTierNetworkParams &	laterTierNetworkParams
	)		const

private

Set the vertex related DLLaterTierNetworkParams (m_parentNuVertexSep, m_childNuVertexSep, m_vertexSeparation)

Parameters

nuVertex	the neutrino vertex position
parentStartPos	the assumed parent pfo start position
parentEndPos	the assumed parent pfo end position
childStartPos	the assumed child pfo start position
laterTierNetworkParams	the later tier network parameters to fill

Definition at line 226 of file DLLaterTierHierarchyTool.cc.

References lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_childNuVertexSep, lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_parentNuVertexSep, and lar_dl_content::DLLaterTierHierarchyTool::DLLaterTierNetworkParams::m_vertexSeparation.

Referenced by CalculateNetworkVariables().

 {
     laterTierNetworkParams.m_parentNuVertexSep = (parentStartPos - nuVertex).GetMagnitude();
     laterTierNetworkParams.m_childNuVertexSep = (childStartPos - nuVertex).GetMagnitude();
     laterTierNetworkParams.m_vertexSeparation = (parentEndPos - childStartPos).GetMagnitude();
 }

Member Data Documentation

bool lar_dl_content::DLBaseHierarchyTool::m_areBoundariesSet

protectedinherited

whether the detector boundaries have been set

Definition at line 68 of file DLBaseHierarchyTool.h.

Referenced by lar_dl_content::DLBaseHierarchyTool::DLBaseHierarchyTool(), and lar_dl_content::DLBaseHierarchyTool::SetDetectorBoundaries().

float lar_dl_content::DLLaterTierHierarchyTool::m_connectionBuffer

private

the 'is child connected?' threshold

Definition at line 326 of file DLLaterTierHierarchyTool.h.

Referenced by DoesConnect(), and ReadSettings().

LArGeometryHelper::DetectorBoundaries lar_dl_content::DLBaseHierarchyTool::m_detectorBoundaries

protectedinherited

the detector boundaries

Definition at line 67 of file DLBaseHierarchyTool.h.

Referenced by lar_dl_content::DLPrimaryHierarchyTool::CalculateConnectionDistances(), lar_dl_content::DLBaseHierarchyTool::SetDetectorBoundaries(), and SetEndRegionRToWall().

bool lar_dl_content::DLLaterTierHierarchyTool::m_normalise

private

whether to normalise the network parameters

Definition at line 329 of file DLLaterTierHierarchyTool.h.

Referenced by CalculateNetworkVariables(), and ReadSettings().

NormalisationLimits lar_dl_content::DLLaterTierHierarchyTool::m_normLimits

private

struct of the normalisation limits

Definition at line 330 of file DLLaterTierHierarchyTool.h.

Referenced by NormaliseNetworkParams(), and ReadSettings().

pandora::StringVector lar_dl_content::DLBaseHierarchyTool::m_pfoListNames

protectedinherited

the input pfo list name vector

Definition at line 66 of file DLBaseHierarchyTool.h.

Referenced by lar_dl_content::DLBaseHierarchyTool::GetParticleInfoAboutPfoPosition(), lar_dl_content::DLBaseHierarchyTool::ReadSettings(), and lar_dl_content::DLPrimaryHierarchyTool::ReadSettings().

float lar_dl_content::DLLaterTierHierarchyTool::m_searchRegion

private

the dimensions of the box used to obtain the up/downstream 3D hit groups

Definition at line 327 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings(), and SetParentConnectionPointVars().

LArDLHelper::TorchModel lar_dl_content::DLLaterTierHierarchyTool::m_trackShowerBranchModel

private

the track-shower edge model

Definition at line 321 of file DLLaterTierHierarchyTool.h.

Referenced by ClassifyTrackShowerEdge(), and ReadSettings().

std::string lar_dl_content::DLLaterTierHierarchyTool::m_trackShowerBranchModelName

private

the name of the track-shower edge model file

Definition at line 317 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DLLaterTierHierarchyTool::m_trackShowerClassifierModel

private

the track-shower classification model

Definition at line 322 of file DLLaterTierHierarchyTool.h.

Referenced by ClassifyTrackShower(), and ReadSettings().

std::string lar_dl_content::DLLaterTierHierarchyTool::m_trackShowerClassifierModelName

private

the name of the track-shower classification model file

Definition at line 318 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DLLaterTierHierarchyTool::m_trackTrackBranchModel

private

the track-track edge model

Definition at line 319 of file DLLaterTierHierarchyTool.h.

Referenced by ClassifyTrackTrackEdge(), and ReadSettings().

std::string lar_dl_content::DLLaterTierHierarchyTool::m_trackTrackBranchModelName

private

the name of the track-track edge model file

Definition at line 315 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DLLaterTierHierarchyTool::m_trackTrackClassifierModel

private

the track-track classification model

Definition at line 320 of file DLLaterTierHierarchyTool.h.

Referenced by ClassifyTrackTrack(), and ReadSettings().

std::string lar_dl_content::DLLaterTierHierarchyTool::m_trackTrackClassifierModelName

private

the name of the track-track classification model file

Definition at line 316 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings().

bool lar_dl_content::DLLaterTierHierarchyTool::m_trainingMode

private

whether to run the tool in training mode

Definition at line 324 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings(), and Run().

float lar_dl_content::DLLaterTierHierarchyTool::m_trajectoryStepSize

private

the size of the steps taken to trace the parent trajectory

Definition at line 325 of file DLLaterTierHierarchyTool.h.

Referenced by ReadSettings(), and SetConnectionParams().

float lar_dl_content::DLBaseHierarchyTool::m_vertexRegionRadiusSq

protectedinherited

the radius (squared) in which to search for particle hits

Definition at line 65 of file DLBaseHierarchyTool.h.

Referenced by lar_dl_content::DLBaseHierarchyTool::GetParticleInfoAboutPfoPosition(), and lar_dl_content::DLBaseHierarchyTool::ReadSettings().

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

larpandoracontent/v04_15_01/source/larpandoradlcontent/LArThreeDReco/LArEventBuilding/DLLaterTierHierarchyTool.h
larpandoracontent/v04_15_01/source/larpandoradlcontent/LArThreeDReco/LArEventBuilding/DLLaterTierHierarchyTool.cc

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation