DLPrimaryHierarchyTool to apply the primary hierarchy DL networks. More...

#include "DLPrimaryHierarchyTool.h"

Inheritance diagram for lar_dl_content::DLPrimaryHierarchyTool:

Classes
struct	DLPrimaryNetworkParams

struct	NormalisationLimits

Public Member Functions
pandora::StatusCode	Run (const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pNeutrinoPfo, const HierarchyPfoVector &trackPfos, const HierarchyPfo &hierarchyPfo, std::vector< DLPrimaryNetworkParams > &networkParamVector, float &primaryScore)

	DLPrimaryHierarchyTool ()
	Default constructor. More...

void	CalculateConnectionDistances (const ExtremalPoint &parentPoint, const ExtremalPoint &childPoint, float &parentConnectionDistance, float &childConnectionDistance) const
	Calculate the variables describing the extension of a child particle to a given parent (m_parentConnectionDistance, m_childConnectionDistance) 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)

pandora::StatusCode	CalculateNetworkVariables (const pandora::Algorithm const pAlgorithm, const HierarchyPfo &hierarchyPfo, const pandora::ParticleFlowObject const pNeutrinoPfo, const HierarchyPfoVector &trackPfos, const bool useUpstream, DLPrimaryNetworkParams &primaryNetworkParams) const
	Function to calculate the DLPrimaryNetworkParams. More...

void	SetVertexRegionParams (const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pPfo, const pandora::CartesianVector &particleVertex, DLPrimaryNetworkParams &primaryNetworkParams) const
	Set the vertex region DLPrimaryNetworkParams params (m_vertexRegionNHits, m_vertexRegionNParticles) More...

void	SetConnectionParams (const ExtremalPoint &particlePoint, const pandora::CartesianVector &nuVertex, DLPrimaryNetworkParams &primaryNetworkParams) const
	Set the connection region DLPrimaryNetworkParams params (m_dca, m_connectionExtrapDistance) More...

void	SetContextParams (const pandora::ParticleFlowObject *const pPfo, const ExtremalPoint &particlePoint, const pandora::CartesianVector &nuVertex, const HierarchyPfoVector &trackPfos, DLPrimaryNetworkParams &primaryNetworkParams) const
	Set the event context DLPrimaryNetworkParams params (m_parentConnectionDistance, m_childConnectionDistance) More...

void	NormaliseNetworkParams (DLPrimaryNetworkParams &primaryNetworkParams) const
	Shift and normalise the primary network parameters. More...

float	ClassifyTrack (const DLPrimaryNetworkParams &edgeParamsUp, const DLPrimaryNetworkParams &edgeParamsDown)
	Apply the primary track classification network. More...

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

float	ClassifyShower (const DLPrimaryNetworkParams &primaryNetworkParams)
	Apply the primary shower classification network. More...

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

std::string	m_primaryTrackBranchModelName
	the name of the primary track edge model file More...

std::string	m_primaryTrackClassifierModelName
	the name of the primary track classification model file More...

std::string	m_primaryShowerClassifierModelName
	the name of the primary shower classification model file More...

LArDLHelper::TorchModel	m_primaryTrackBranchModel
	the primary track edge model More...

LArDLHelper::TorchModel	m_primaryTrackClassifierModel
	the primary track classification model More...

LArDLHelper::TorchModel	m_primaryShowerClassifierModel
	the primary shower classification model More...

float	m_extrapolationStepSize
	the step size used to trace back a child particle's path More...

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

NormalisationLimits	m_normLimits
	struct of the normalisation limits More...

Detailed Description

DLPrimaryHierarchyTool to apply the primary hierarchy DL networks.

Definition at line 22 of file DLPrimaryHierarchyTool.h.

Constructor & Destructor Documentation

lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryHierarchyTool ( )

Default constructor.

Definition at line 52 of file DLPrimaryHierarchyTool.cc.

                                                :
     DLBaseHierarchyTool(),
     m_trainingMode(false),
     m_extrapolationStepSize(1.f),
     m_normalise(true)
 {
 }

Member Function Documentation

void lar_dl_content::DLPrimaryHierarchyTool::CalculateConnectionDistances	(	const ExtremalPoint &	parentPoint,
		const ExtremalPoint &	childPoint,
		float &	parentConnectionDistance,
		float &	childConnectionDistance
	)		const

Calculate the variables describing the extension of a child particle to a given parent (m_parentConnectionDistance, m_childConnectionDistance)

Parameters

parentPoint	the extremal point of the parent
childPoint	the extremal point of the child
parentConnectionDistance	the DCA to the parent vertex
childConnectionDistance	the extension of the child to the DCA point

Definition at line 206 of file DLPrimaryHierarchyTool.cc.

References lar_dl_content::ExtremalPoint::GetDirection(), lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::DLBaseHierarchyTool::m_detectorBoundaries, and m_extrapolationStepSize.

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

 {
     // Loop things
     float smallestT(std::numeric_limits<float>::max());
     bool isGettingCloser(true);
     bool found(false);
     CartesianVector connectionPoint(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());
 
     // start the seed
     CartesianVector extrapolatedPoint(childPoint.GetPosition());
 
     while (isGettingCloser)
     {
         isGettingCloser = false;
         extrapolatedPoint = extrapolatedPoint + (childPoint.GetDirection() * ((-1.f) * m_extrapolationStepSize));
 
         if (!LArGeometryHelper::IsInDetector(m_detectorBoundaries, extrapolatedPoint))
             break;
 
         const float parentT(
             (parentPoint.GetDirection() * (-1.f)).GetCrossProduct((extrapolatedPoint - parentPoint.GetPosition())).GetMagnitudeSquared());
 
         if (parentT < smallestT)
         {
             smallestT = parentT;
             connectionPoint = extrapolatedPoint;
             isGettingCloser = true;
             found = true;
         }
     }
 
     // Distance from parent end to connection point - need to turn parent direction around
     parentConnectionDistance = found ? (parentPoint.GetDirection() * (-1.f)).GetDotProduct(connectionPoint - parentPoint.GetPosition())
                                      : std::numeric_limits<float>::lowest();
     // Distance from child start to connection point
     childConnectionDistance = found ? (childPoint.GetPosition() - connectionPoint).GetMagnitude() : std::numeric_limits<float>::lowest();
 }

StatusCode lar_dl_content::DLPrimaryHierarchyTool::CalculateNetworkVariables	(	const pandora::Algorithm *const	pAlgorithm,
		const HierarchyPfo &	hierarchyPfo,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfoVector &	trackPfos,
		const bool	useUpstream,
		DLPrimaryNetworkParams &	primaryNetworkParams
	)		const

private

Function to calculate the DLPrimaryNetworkParams.

Parameters

pAlgorithm	a pointer to the pandora algorithm
hierarchyPfo	the input hierarchy pfo object
pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the HierachyPfoVector of track-like particles
useUpstream	whether the POI is the endpoint closest to the nu vertex
primaryNetworkParams	the primary network parameters to fill

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

Definition at line 100 of file DLPrimaryHierarchyTool.cc.

References lar_dl_content::HierarchyPfo::GetDownstreamPoint(), lar_dl_content::HierarchyPfo::GetPfo(), lar_dl_content::HierarchyPfo::GetUpstreamPoint(), lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_isPOIClosestToNu, m_normalise, lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_nSpacepoints, lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_nuSeparation, NormaliseNetworkParams(), SetConnectionParams(), SetContextParams(), and SetVertexRegionParams().

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 extremal point
     const ExtremalPoint &particlePoint(useUpstream ? hierarchyPfo.GetUpstreamPoint() : hierarchyPfo.GetDownstreamPoint());
 
     // Check that we could actually calculate pfo vertex/direction, return if not
     if (!particlePoint.IsSet())
     {
         return STATUS_CODE_NOT_INITIALIZED;
     }
 
     // Set primaryNetworkParams
     primaryNetworkParams.m_isPOIClosestToNu = useUpstream ? 1.f : 0.f;
     primaryNetworkParams.m_nSpacepoints = LArPfoHelper::GetNumberOfThreeDHits(hierarchyPfo.GetPfo());
     primaryNetworkParams.m_nuSeparation = (particlePoint.GetPosition() - nuVertex).GetMagnitude();
     this->SetVertexRegionParams(pAlgorithm, hierarchyPfo.GetPfo(), particlePoint.GetPosition(), primaryNetworkParams);
     this->SetConnectionParams(particlePoint, nuVertex, primaryNetworkParams);
     this->SetContextParams(hierarchyPfo.GetPfo(), particlePoint, nuVertex, trackPfos, primaryNetworkParams);
 
     // Normalise
     if (m_normalise)
         this->NormaliseNetworkParams(primaryNetworkParams);
 
     return STATUS_CODE_SUCCESS;
 }

float lar_dl_content::DLPrimaryHierarchyTool::ClassifyShower ( const DLPrimaryNetworkParams & primaryNetworkParams )

private

Apply the primary shower classification network.

Parameters

primaryNetworkParams the primary network parameters associated with the shower endpoint

Returns: the network score

Definition at line 316 of file DLPrimaryHierarchyTool.cc.

References lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::AddCommonParamsToInput(), lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::AddOrientationParamsToInput(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_primaryShowerClassifierModel.

Referenced by Run().

 {
     LArDLHelper::TorchInput input;
     LArDLHelper::InitialiseInput({1, 9}, input);
 
     // Fill our torch vector
     int insertIndex(0);
     primaryNetworkParams.AddCommonParamsToInput(insertIndex, input);
     primaryNetworkParams.AddOrientationParamsToInput(insertIndex, input);
 
     LArDLHelper::TorchOutput output;
     LArDLHelper::Forward(m_primaryShowerClassifierModel, {input}, output);
     auto outputAccessor = output.accessor<float, 2>();
 
     return outputAccessor[0][0];
 }

float lar_dl_content::DLPrimaryHierarchyTool::ClassifyTrack	(	const DLPrimaryNetworkParams &	edgeParamsUp,
		const DLPrimaryNetworkParams &	edgeParamsDown
	)

private

Apply the primary track classification network.

Parameters

edgeParamsUp	the primary network parameters associated with the upstream endpoint
edgeParamsDown	the primary network parameters associated with the downstream endpoint

Returns: the network score

Definition at line 265 of file DLPrimaryHierarchyTool.cc.

References ClassifyTrackEdge(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_primaryTrackClassifierModel.

Referenced by Run().

 {
     // Invoke branch model for each edge
     const FloatVector outputUp(this->ClassifyTrackEdge(edgeParamsUp, edgeParamsDown));
     const FloatVector outputDown(this->ClassifyTrackEdge(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_primaryTrackClassifierModel, {input}, output);
     torch::TensorAccessor<float, 2> outputAccessor = output.accessor<float, 2>();
 
     return outputAccessor[0][0];
 }

FloatVector lar_dl_content::DLPrimaryHierarchyTool::ClassifyTrackEdge	(	const DLPrimaryNetworkParams &	edgeParams,
		const DLPrimaryNetworkParams &	otherEdgeParams
	)

private

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

Parameters

edgeParams	the primary network parameters associated with the edge to classify
otherEdgeParams	the primary network parameters associated with the other edge

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

Definition at line 295 of file DLPrimaryHierarchyTool.cc.

References lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::AddCommonParamsToInput(), lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::AddOrientationParamsToInput(), lar_dl_content::LArDLHelper::Forward(), lar_dl_content::LArDLHelper::InitialiseInput(), and m_primaryTrackBranchModel.

Referenced by ClassifyTrack().

 {
     LArDLHelper::TorchInput input;
     LArDLHelper::InitialiseInput({1, 17}, input);
 
     // Fill our torch vector
     int insertIndex(0);
     edgeParams.AddCommonParamsToInput(insertIndex, input);
     edgeParams.AddOrientationParamsToInput(insertIndex, input);
     otherEdgeParams.AddOrientationParamsToInput(insertIndex, input);
 
     LArDLHelper::TorchOutput output;
     LArDLHelper::Forward(m_primaryTrackBranchModel, {input}, output);
 
     torch::TensorAccessor<float, 2> outputAccessor(output.accessor<float, 2>());
 
     return {outputAccessor[0][0], outputAccessor[0][1], outputAccessor[0][2]};
 }

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 lar_dl_content::DLLaterTierHierarchyTool::SetEndRegionParams(), and 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});
 }

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 NormaliseNetworkParams(), and lar_dl_content::DLLaterTierHierarchyTool::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::DLPrimaryHierarchyTool::NormaliseNetworkParams ( DLPrimaryNetworkParams & primaryNetworkParams ) const

private

Shift and normalise the primary network parameters.

Parameters

primaryNetworkParam the input primary network parameters

Definition at line 247 of file DLPrimaryHierarchyTool.cc.

Referenced by CalculateNetworkVariables().

 {
     this->NormaliseNetworkParam(m_normLimits.m_nSpacepointsMin, m_normLimits.m_nSpacepointsMax, primaryNetworkParams.m_nSpacepoints);
     this->NormaliseNetworkParam(m_normLimits.m_nuSeparationMin, m_normLimits.m_nuSeparationMax, primaryNetworkParams.m_nuSeparation);
     this->NormaliseNetworkParam(m_normLimits.m_vertexRegionNHitsMin, m_normLimits.m_vertexRegionNHitsMax, primaryNetworkParams.m_vertexRegionNHits);
     this->NormaliseNetworkParam(
         m_normLimits.m_vertexRegionNParticlesMin, m_normLimits.m_vertexRegionNParticlesMax, primaryNetworkParams.m_vertexRegionNParticles);
     this->NormaliseNetworkParam(m_normLimits.m_dcaMin, m_normLimits.m_dcaMax, primaryNetworkParams.m_dca);
     this->NormaliseNetworkParam(m_normLimits.m_connectionExtrapDistanceMin, m_normLimits.m_connectionExtrapDistanceMax,
         primaryNetworkParams.m_connectionExtrapDistance);
     this->NormaliseNetworkParam(m_normLimits.m_parentConnectionDistanceMin, m_normLimits.m_parentConnectionDistanceMax,
         primaryNetworkParams.m_parentConnectionDistance);
     this->NormaliseNetworkParam(m_normLimits.m_childConnectionDistanceMin, m_normLimits.m_childConnectionDistanceMax,
         primaryNetworkParams.m_childConnectionDistance);
 }

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

private

Definition at line 335 of file DLPrimaryHierarchyTool.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::ReadVectorOfValues(xmlHandle, "PfoListNames", m_pfoListNames));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ExtrapolationStepSize", m_extrapolationStepSize));
     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, "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, "NuSeparationMin", m_normLimits.m_nuSeparationMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NuSeparationMax", m_normLimits.m_nuSeparationMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "VertexRegionNHitsMin", m_normLimits.m_vertexRegionNHitsMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "VertexRegionNHitsMax", m_normLimits.m_vertexRegionNHitsMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "VertexRegionNParticlesMin", m_normLimits.m_vertexRegionNParticlesMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "VertexRegionNParticlesMax", m_normLimits.m_vertexRegionNParticlesMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DCAMin", m_normLimits.m_dcaMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DCAMax", m_normLimits.m_dcaMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ConnectionExtrapDistanceMin", m_normLimits.m_connectionExtrapDistanceMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ConnectionExtrapDistanceMax", m_normLimits.m_connectionExtrapDistanceMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentConnectionDistanceMin", m_normLimits.m_parentConnectionDistanceMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ParentConnectionDistanceMax", m_normLimits.m_parentConnectionDistanceMax));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ChildConnectionDistanceMin", m_normLimits.m_childConnectionDistanceMin));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ChildConnectionDistanceMax", m_normLimits.m_childConnectionDistanceMax));
 
     if (!m_trainingMode)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "PrimaryTrackBranchModelName", m_primaryTrackBranchModelName));
         m_primaryTrackBranchModelName = LArFileHelper::FindFileInPath(m_primaryTrackBranchModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_primaryTrackBranchModelName, m_primaryTrackBranchModel));
 
         PANDORA_RETURN_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "PrimaryTrackClassifierModelName", m_primaryTrackClassifierModelName));
         m_primaryTrackClassifierModelName = LArFileHelper::FindFileInPath(m_primaryTrackClassifierModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_primaryTrackClassifierModelName, m_primaryTrackClassifierModel));
 
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
             XmlHelper::ReadValue(xmlHandle, "PrimaryShowerClassifierModelName", m_primaryShowerClassifierModelName));
         m_primaryShowerClassifierModelName = LArFileHelper::FindFileInPath(m_primaryShowerClassifierModelName, "FW_SEARCH_PATH");
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_primaryShowerClassifierModelName, m_primaryShowerClassifierModel));
     }
 
     return DLBaseHierarchyTool::ReadSettings(xmlHandle);
 }

StatusCode lar_dl_content::DLPrimaryHierarchyTool::Run	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfoVector &	trackPfos,
		const HierarchyPfo &	hierarchyPfo,
		std::vector< DLPrimaryNetworkParams > &	networkParamVector,
		float &	primaryScore
	)

Definition at line 62 of file DLPrimaryHierarchyTool.cc.

References CalculateNetworkVariables(), ClassifyShower(), ClassifyTrack(), lar_dl_content::HierarchyPfo::GetPfo(), m_trainingMode, and lar_dl_content::DLBaseHierarchyTool::SetDetectorBoundaries().

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

 {
     networkParamVector.clear();
     primaryScore = std::numeric_limits<float>::lowest();
 
     this->SetDetectorBoundaries();
 
     const bool isTrack(hierarchyPfo.GetPfo()->GetParticleId() == 13);
     std::vector<bool> orientationVector(isTrack ? std::vector<bool>({true, false}) : std::vector<bool>({true}));
 
     for (const bool useUpstream : orientationVector)
     {
         // Set network params
         DLPrimaryNetworkParams primaryNetworkParams;
 
         const StatusCode statusCode(this->CalculateNetworkVariables(pAlgorithm, hierarchyPfo, pNeutrinoPfo, trackPfos, useUpstream, primaryNetworkParams));
 
         if (statusCode != STATUS_CODE_SUCCESS)
             return statusCode;
 
         networkParamVector.emplace_back(primaryNetworkParams);
     }
 
     // Now run the model!
     if (!m_trainingMode)
     {
         if (isTrack)
             primaryScore = this->ClassifyTrack(networkParamVector.at(0), networkParamVector.at(1));
         else
             primaryScore = this->ClassifyShower(networkParamVector.at(0));
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_dl_content::DLPrimaryHierarchyTool::SetConnectionParams	(	const ExtremalPoint &	particlePoint,
		const pandora::CartesianVector &	nuVertex,
		DLPrimaryNetworkParams &	primaryNetworkParams
	)		const

private

Set the connection region DLPrimaryNetworkParams params (m_dca, m_connectionExtrapDistance)

Parameters

particlePoint	the extremal point of the particle
nuVertex	the neutrino vertex
primaryNetworkParams	the primary network parameters

Definition at line 149 of file DLPrimaryHierarchyTool.cc.

References lar_dl_content::ExtremalPoint::GetDirection(), lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_connectionExtrapDistance, and lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_dca.

Referenced by CalculateNetworkVariables().

 {
     // Extrapolate particle to nuVertex
     const float extrapDistance((nuVertex - particlePoint.GetPosition()).GetDotProduct(particlePoint.GetDirection()));
     const CartesianVector extrapolationPoint(particlePoint.GetPosition() + (particlePoint.GetDirection() * extrapDistance));
 
     primaryNetworkParams.m_dca = (nuVertex - extrapolationPoint).GetMagnitude();
     primaryNetworkParams.m_connectionExtrapDistance = (extrapDistance * (-1.f)); // backwards extrap. should be +ve
 }

void lar_dl_content::DLPrimaryHierarchyTool::SetContextParams	(	const pandora::ParticleFlowObject *const	pPfo,
		const ExtremalPoint &	particlePoint,
		const pandora::CartesianVector &	nuVertex,
		const HierarchyPfoVector &	trackPfos,
		DLPrimaryNetworkParams &	primaryNetworkParams
	)		const

private

Set the event context DLPrimaryNetworkParams params (m_parentConnectionDistance, m_childConnectionDistance)

Parameters

pPfo	a pointer to the input pfo
particlePoint	the extremal point of the particle
nuVertex	the neutrino vertex
trackPfos	the HierachyPfoVector of track-like particles
primaryNetworkParams	the primary network parameters

Definition at line 162 of file DLPrimaryHierarchyTool.cc.

References CalculateConnectionDistances(), f, lar_dl_content::ExtremalPoint::GetPosition(), lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_childConnectionDistance, and lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_parentConnectionDistance.

Referenced by CalculateNetworkVariables().

 {
     // What is our nuVertex separation
     const float nuVertexSepSq((particlePoint.GetPosition() - nuVertex).GetMagnitudeSquared());
 
     bool found(false);
     float parentConnectionDistance(std::numeric_limits<float>::max());
     float childConnectionDistance(std::numeric_limits<float>::max());
 
     // Look at potential parents
     for (const HierarchyPfo &hierarchyTrackPfo : trackPfos)
     {
         if (hierarchyTrackPfo == pPfo)
             continue;
 
         // Upstream position should be closer to nu vertex
         const float thisNuVertexSepSq((hierarchyTrackPfo.GetDownstreamPoint().GetPosition() - nuVertex).GetMagnitudeSquared());
 
         if (thisNuVertexSepSq > nuVertexSepSq)
             continue;
 
         float thisParentConnectionDistance(std::numeric_limits<float>::lowest());
         float thisChildConnectionDistance(std::numeric_limits<float>::lowest());
 
         this->CalculateConnectionDistances(hierarchyTrackPfo.GetDownstreamPoint(), particlePoint, thisParentConnectionDistance, thisChildConnectionDistance);
 
         if ((thisChildConnectionDistance > 0.f) && (std::fabs(thisParentConnectionDistance) < std::fabs(parentConnectionDistance)))
         {
             found = true;
             parentConnectionDistance = thisParentConnectionDistance;
             childConnectionDistance = thisChildConnectionDistance;
         }
     }
 
     if (found)
     {
         primaryNetworkParams.m_parentConnectionDistance = parentConnectionDistance;
         primaryNetworkParams.m_childConnectionDistance = childConnectionDistance;
     }
 }

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 lar_dl_content::DLLaterTierHierarchyTool::Run(), and Run().

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

void lar_dl_content::DLPrimaryHierarchyTool::SetVertexRegionParams	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pPfo,
		const pandora::CartesianVector &	particleVertex,
		DLPrimaryNetworkParams &	primaryNetworkParams
	)		const

private

Set the vertex region DLPrimaryNetworkParams params (m_vertexRegionNHits, m_vertexRegionNParticles)

Parameters

pAlgorithm	a pointer to the pandora algorithm
pPfo	a pointer to the input pfo
particleVertex	the position of the pfo vertex
primaryNetworkParams	the primary network parameters

Definition at line 138 of file DLPrimaryHierarchyTool.cc.

References lar_dl_content::DLBaseHierarchyTool::GetParticleInfoAboutPfoPosition(), lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_vertexRegionNHits, and lar_dl_content::DLPrimaryHierarchyTool::DLPrimaryNetworkParams::m_vertexRegionNParticles.

Referenced by CalculateNetworkVariables().

 {
     std::pair<float, float> vertexRegionParams(this->GetParticleInfoAboutPfoPosition(pAlgorithm, pPfo, particleVertex));
 
     primaryNetworkParams.m_vertexRegionNHits = vertexRegionParams.first;
     primaryNetworkParams.m_vertexRegionNParticles = vertexRegionParams.second;
 }

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

LArGeometryHelper::DetectorBoundaries lar_dl_content::DLBaseHierarchyTool::m_detectorBoundaries

protectedinherited

the detector boundaries

Definition at line 67 of file DLBaseHierarchyTool.h.

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

float lar_dl_content::DLPrimaryHierarchyTool::m_extrapolationStepSize

private

the step size used to trace back a child particle's path

Definition at line 198 of file DLPrimaryHierarchyTool.h.

Referenced by CalculateConnectionDistances(), and ReadSettings().

bool lar_dl_content::DLPrimaryHierarchyTool::m_normalise

private

whether to normalise the network parameters

Definition at line 200 of file DLPrimaryHierarchyTool.h.

Referenced by CalculateNetworkVariables(), and ReadSettings().

NormalisationLimits lar_dl_content::DLPrimaryHierarchyTool::m_normLimits

private

struct of the normalisation limits

Definition at line 201 of file DLPrimaryHierarchyTool.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 ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DLPrimaryHierarchyTool::m_primaryShowerClassifierModel

private

the primary shower classification model

Definition at line 196 of file DLPrimaryHierarchyTool.h.

Referenced by ClassifyShower(), and ReadSettings().

std::string lar_dl_content::DLPrimaryHierarchyTool::m_primaryShowerClassifierModelName

private

the name of the primary shower classification model file

Definition at line 193 of file DLPrimaryHierarchyTool.h.

Referenced by ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DLPrimaryHierarchyTool::m_primaryTrackBranchModel

private

the primary track edge model

Definition at line 194 of file DLPrimaryHierarchyTool.h.

Referenced by ClassifyTrackEdge(), and ReadSettings().

std::string lar_dl_content::DLPrimaryHierarchyTool::m_primaryTrackBranchModelName

private

the name of the primary track edge model file

Definition at line 191 of file DLPrimaryHierarchyTool.h.

Referenced by ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DLPrimaryHierarchyTool::m_primaryTrackClassifierModel

private

the primary track classification model

Definition at line 195 of file DLPrimaryHierarchyTool.h.

Referenced by ClassifyTrack(), and ReadSettings().

std::string lar_dl_content::DLPrimaryHierarchyTool::m_primaryTrackClassifierModelName

private

the name of the primary track classification model file

Definition at line 192 of file DLPrimaryHierarchyTool.h.

Referenced by ReadSettings().

bool lar_dl_content::DLPrimaryHierarchyTool::m_trainingMode

private

whether to run the tool in training mode

Definition at line 190 of file DLPrimaryHierarchyTool.h.

Referenced by ReadSettings(), and Run().

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/DLPrimaryHierarchyTool.h
larpandoracontent/v04_15_01/source/larpandoradlcontent/LArThreeDReco/LArEventBuilding/DLPrimaryHierarchyTool.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