DLNeutrinoHierarchyAlgorithm class. More...

#include "DLNeutrinoHierarchyAlgorithm.h"

Inheritance diagram for lar_dl_content::DLNeutrinoHierarchyAlgorithm:

Public Member Functions
	DLNeutrinoHierarchyAlgorithm ()
	Default constructor. More...

	~DLNeutrinoHierarchyAlgorithm ()
	Default destructor. More...

Private Types
typedef std::map< const pandora::ParticleFlowObject , const pandora::MCParticle >	PfoToMCParticleMap

typedef std::map< const pandora::ParticleFlowObject , std::pair< const pandora::ParticleFlowObject , int > >	ChildToParentPfoMap

typedef std::vector< pandora::PfoVector >	Hierarchy

Private Member Functions
pandora::StatusCode	Run ()

bool	GetNeutrinoPfo (const pandora::ParticleFlowObject *&pNeutrinoPfo) const
	Return the neutrino pfo. More...

void	FillTrackShowerVectors (const pandora::ParticleFlowObject *const pNeutrinoPfo, HierarchyPfoVector &trackPfos, HierarchyPfoVector &showerPfos) const
	Fill the track and shower-like HierarchyPfoVector. More...

bool	GetExtremalVerticesAndDirections (const pandora::ParticleFlowObject const pNeutrinoPfo, const pandora::ParticleFlowObject const pPfo, const ThreeDSlidingFitResult &slidingFitResult, ExtremalPoint &upstreamPoint, ExtremalPoint &downstreamPoint) const
	Identify the upstream (closest to the nu vertex) and downstream (furthest from the nu vertex) endpoints and directions of an input pfo. More...

bool	GetShowerDirection (const pandora::ParticleFlowObject *const pPfo, const pandora::CartesianVector &vertex, pandora::CartesianVector &direction) const
	Obtain the direction of a shower at a given endpoint from the angular decomposition of the shower's 'close' 3D hits. More...

void	SetPrimaryScores (const pandora::ParticleFlowObject *const pNeutrinoPfo, HierarchyPfoVector &trackPfos, HierarchyPfoVector &showerPfos) const
	Set the primary network scores of the HierarchyPfos. More...

float	GetPrimaryScore (const pandora::ParticleFlowObject *const pNeutrinoPfo, const HierarchyPfoVector &trackPfos, const HierarchyPfo &hierarchyPfo) const
	Call the primary network tool to obtain the primary score of a HierarchyPfo. More...

void	UpdateHierarchy (const pandora::ParticleFlowObject *const pNeutrinoPfo, const bool buildPrimaryTier, const bool usePrimaryScore, const float trackThreshold, const float showerThreshold, const bool isLowerThreshold, HierarchyPfoVector &trackPfos, HierarchyPfoVector &showerPfos, Hierarchy &hierarchy) const
	Add particles to the hierarchy if they satisfy a criteria. More...

void	SetLaterTierScores (const pandora::ParticleFlowObject *const pNeutrinoPfo, HierarchyPfoVector &trackPfos, HierarchyPfoVector &showerPfos) const
	Set the predicted parent and later tier score of the HierarchyPfos to be considered for the later tiers. More...

float	GetLaterTierScore (const pandora::ParticleFlowObject *const pNeutrinoPfo, const HierarchyPfo &parentPfo, const HierarchyPfo &childPfo) const
	Call the later tier network tool to obtain the later tier score of a parent-child link. More...

void	BuildPandoraHierarchy (const pandora::ParticleFlowObject *const pNeutrinoPfo, const HierarchyPfoVector &trackPfos, const HierarchyPfoVector &showerPfos) const
	Register the parent-child relationships in Pandora. More...

bool	ShouldTrainOnEvent (const pandora::ParticleFlowObject *const pNeutrinoPfo) const
	Whether the event should be trained on. More...

void	GetParticleIDMap (const HierarchyPfoVector &trackPfos, const HierarchyPfoVector &showerPfos, std::map< const pandora::ParticleFlowObject *, int > &particleIDMap) const
	Obtain the [pfo -> unique ID] map. More...

std::pair< float, float >	GetTrainingCuts (const HierarchyPfo &parentHierarchyPfo, const HierarchyPfo &childHierarchyPfo, const bool trueParentOrientation, const bool trueChildOrientation) const
	Get the training cuts for the later tier parent-child link these describe how well the child points back to the parent. More...

void	FillEventTree (const HierarchyPfoVector &trackPfos, const HierarchyPfoVector &showerPfos, const int nPrimaryTrackLinks, const int nPrimaryShowerLinks, const int nLaterTierTrackTrackLinks, const int nLaterTierTrackShowerLinks) const
	Fill the output event tree (containing event-level info) More...

void	FillPrimaryTrees (const PfoToMCParticleMap &matchingMap, const ChildToParentPfoMap &childToParentPfoMap, const pandora::ParticleFlowObject const pNeutrinoPfo, const HierarchyPfoVector &trackPfos, const HierarchyPfoVector &showerPfos, const std::map< const pandora::ParticleFlowObject , int > &particleIDMap, int &nPrimaryTrackLinks, int &nPrimaryShowerLinks) const
	Fill the primary trees (containing primary link info) More...

void	FillPrimaryTree (const std::string &treeName, const bool isTrainingLink, const bool isTrueLink, const bool isOrientationCorrect, const int trueVisibleGen, const int truePDG, const int trueParentID, const int particleID, const DLPrimaryHierarchyTool::DLPrimaryNetworkParams &primaryNetworkParams) const
	Enter an entry into the specified primary tree. More...

void	FillLaterTierTrees (const PfoToMCParticleMap &matchingMap, const ChildToParentPfoMap &childToParentPfoMap, const pandora::ParticleFlowObject const pNeutrinoPfo, const HierarchyPfoVector &trackPfos, const HierarchyPfoVector &showerPfos, const std::map< const pandora::ParticleFlowObject , int > &particleIDMap, int &nTrackLinks, int &nShowerLinks) const
	Fill the later tier trees (containing later tier link info) More...

void	FillLaterTierTree (const std::string &treeName, const bool isTrainingLink, const bool isTrueLink, const bool isOrientationCorrect, const int childTrueGen, const std::pair< float, float > &trainingCuts, const int parentID, const int childID, const DLLaterTierHierarchyTool::DLLaterTierNetworkParams &networkParams) const
	Enter an entry into the specified later tier tree. More...

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

Private Attributes
int	m_eventID
	the event counter More...

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

std::string	m_trainingFileName
	the name of the output training file More...

std::string	m_eventTreeName
	the name of the output event tree More...

std::string	m_primaryTrackTreeName
	the name of the output primary track link tree More...

std::string	m_primaryShowerTreeName
	the name of the output primary shower link tree More...

std::string	m_laterTierTrackTrackTreeName
	the name of the output track-track later tier link tree More...

std::string	m_laterTierTrackShowerTreeName
	the name of the output track-shower later tier link tree More...

std::string	m_mcParticleListName
	the name of the MCParticle list More...

float	m_trainingVertexAccuracy
	the maximum true-reco nu vertex displacement allowed for training More...

std::string	m_neutrinoPfoListName
	the name of the neutrino pfo list More...

pandora::StringVector	m_pfoListNames
	the name of the pfo lists More...

unsigned int	m_minClusterSize
	the minimum threshold of 3D hits of a considered pfo More...

int	m_slidingFitWindow
	the sliding fit window to use in pfo sliding linear fits More...

float	m_regionForDirFit
	the radius of the region used in shower direction fits More...

int	m_nAngularBins
	the number of angle bins used by the shower direction fitter More...

float	m_primaryRegion
	the radius of the nu vertex region where particles are assumed to be primaries More...

float	m_primaryThresholdTrackPass1
	The threshold applied to tracks in pass 1 primary tier building. More...

float	m_primaryThresholdShowerPass1
	The threshold applied to showers in pass 1 primary tier building. More...

float	m_laterTierThresholdTrackPass1
	The threshold applied to track-track links in pass 1 later tier building. More...

float	m_laterTierThresholdShowerPass1
	The threshold applied to track-shower links in pass 1 later tier building. More...

float	m_primaryThresholdTrackPass2
	The threshold applied to tracks in pass 2 primary tier building. More...

float	m_primaryThresholdShowerPass2
	The threshold applied to showers in pass 2 primary tier building. More...

float	m_laterTierThresholdTrackPass2
	The threshold applied to track-track links in pass 2 later tier building. More...

float	m_laterTierThresholdShowerPass2
	The threshold applied to track-shower links in pass 2 later tier building. More...

DLPrimaryHierarchyTool *	m_primaryHierarchyTool
	The tool used to build the primary tiers. More...

DLLaterTierHierarchyTool *	m_laterTierHierarchyTool
	The tool used to build the later tiers. More...

DLCheatHierarchyTool *	m_cheatHierarchyTool
	The tool used to obtain the true hierarchy. More...

Detailed Description

DLNeutrinoHierarchyAlgorithm class.

Definition at line 31 of file DLNeutrinoHierarchyAlgorithm.h.

Member Typedef Documentation

typedef std::map<const pandora::ParticleFlowObject *, std::pair<const pandora::ParticleFlowObject *, int> > lar_dl_content::DLNeutrinoHierarchyAlgorithm::ChildToParentPfoMap

private

Definition at line 46 of file DLNeutrinoHierarchyAlgorithm.h.

typedef std::vector<pandora::PfoVector> lar_dl_content::DLNeutrinoHierarchyAlgorithm::Hierarchy

private

Definition at line 47 of file DLNeutrinoHierarchyAlgorithm.h.

typedef std::map<const pandora::ParticleFlowObject *, const pandora::MCParticle *> lar_dl_content::DLNeutrinoHierarchyAlgorithm::PfoToMCParticleMap

private

Definition at line 45 of file DLNeutrinoHierarchyAlgorithm.h.

Constructor & Destructor Documentation

lar_dl_content::DLNeutrinoHierarchyAlgorithm::DLNeutrinoHierarchyAlgorithm ( )

Default constructor.

Definition at line 31 of file DLNeutrinoHierarchyAlgorithm.cc.

References f, m_laterTierThresholdShowerPass1, m_laterTierThresholdShowerPass2, m_laterTierThresholdTrackPass1, m_laterTierThresholdTrackPass2, m_minClusterSize, m_nAngularBins, m_primaryRegion, m_primaryThresholdShowerPass1, m_primaryThresholdShowerPass2, m_primaryThresholdTrackPass1, m_primaryThresholdTrackPass2, m_regionForDirFit, and m_slidingFitWindow.

                                                            :
     m_eventID(0),
     m_trainingMode(false),
     m_trainingFileName("DLHierarchyTrainingFile.root"),
     m_eventTreeName("EventTree"),
     m_primaryTrackTreeName("PrimaryTrackTree"),
     m_primaryShowerTreeName("PrimaryShowerTree"),
     m_laterTierTrackTrackTreeName("LaterTierTrackTrackTree"),
     m_laterTierTrackShowerTreeName("LaterTierTrackShowerTree"),
     m_mcParticleListName("Input"),
     m_trainingVertexAccuracy(5.f),
     m_neutrinoPfoListName("NeutrinoParticles3D"),
     m_pfoListNames({"TrackParticles3D", "ShowerParticles3D"}),
     m_minClusterSize(5),
     m_slidingFitWindow(20),
     m_regionForDirFit(25.f),
     m_nAngularBins(180),
     m_primaryRegion(15.f),
     m_primaryThresholdTrackPass1(0.8f),
     m_primaryThresholdShowerPass1(0.45f),
     m_laterTierThresholdTrackPass1(0.8f),
     m_laterTierThresholdShowerPass1(0.8f),
     m_primaryThresholdTrackPass2(0.9f),
     m_primaryThresholdShowerPass2(0.9f),
     m_laterTierThresholdTrackPass2(0.0f),
     m_laterTierThresholdShowerPass2(0.0f)
 {
 }

lar_dl_content::DLNeutrinoHierarchyAlgorithm::~DLNeutrinoHierarchyAlgorithm ( )

Default destructor.

Definition at line 62 of file DLNeutrinoHierarchyAlgorithm.cc.

References m_eventTreeName, m_laterTierTrackShowerTreeName, m_laterTierTrackTrackTreeName, m_primaryShowerTreeName, m_primaryTrackTreeName, m_trainingFileName, and m_trainingMode.

 {
     if (m_trainingMode)
     {
         try
         {
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_eventTreeName.c_str(), m_trainingFileName.c_str(), "UPDATE"));
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_primaryTrackTreeName.c_str(), m_trainingFileName.c_str(), "UPDATE"));
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_primaryShowerTreeName.c_str(), m_trainingFileName.c_str(), "UPDATE"));
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_laterTierTrackTrackTreeName.c_str(), m_trainingFileName.c_str(), "UPDATE"));
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_laterTierTrackShowerTreeName.c_str(), m_trainingFileName.c_str(), "UPDATE"));
         }
         catch (...)
         {
         }
     }
 }

Member Function Documentation

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::BuildPandoraHierarchy	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfoVector &	trackPfos,
		const HierarchyPfoVector &	showerPfos
	)		const

private

Register the parent-child relationships in Pandora.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector

Definition at line 576 of file DLNeutrinoHierarchyAlgorithm.cc.

Referenced by Run().

 {
     PfoVector pfoVector;
 
     // Get All pfos
     for (const std::string &pfoListName : m_pfoListNames)
     {
         const PfoList *pPfoList(nullptr);
 
         if (PandoraContentApi::GetList(*this, pfoListName, pPfoList) != STATUS_CODE_SUCCESS)
             continue;
 
         for (const ParticleFlowObject *const pPfo : *pPfoList)
             pfoVector.emplace_back(pPfo);
     }
 
     // Sort to maintain reproducibility
     std::sort(pfoVector.begin(), pfoVector.end(), LArPfoHelper::SortByNHits);
 
     // Build known hierarchy
     for (const ParticleFlowObject *const pPfo : pfoVector)
     {
         const HierarchyPfo *hierarchyPfo(nullptr);
 
         const auto trackIter(std::find(trackPfos.begin(), trackPfos.end(), pPfo));
         const auto showerIter(std::find(showerPfos.begin(), showerPfos.end(), pPfo));
 
         if (trackIter != trackPfos.end())
         {
             hierarchyPfo = &(*trackIter);
         }
         else if (showerIter != showerPfos.end())
         {
             hierarchyPfo = &(*showerIter);
         }
         else
         {
             // If alg never handled the pfo, assign as primary
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pNeutrinoPfo, pPfo));
             continue;
         }
 
         // If pfo was never assigned to hierarchy, add as primary
         if (!hierarchyPfo->GetIsInHierarchy())
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pNeutrinoPfo, pPfo));
             continue;
         }
 
         // If parent is a neutrino we have to assign its parent
         if (hierarchyPfo->GetParentPfo() == pNeutrinoPfo)
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pNeutrinoPfo, pPfo));
 
         // Assign parent-child links of its children
         PfoVector childPfos(hierarchyPfo->GetChildPfoVector());
         std::sort(childPfos.begin(), childPfos.end(), LArPfoHelper::SortByNHits);
 
         // Demand that showers do not have children
         if ((!childPfos.empty()) && (showerIter != showerPfos.end()))
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         for (const ParticleFlowObject *const pChildPfo : childPfos)
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pPfo, pChildPfo));
     }
 }

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::FillEventTree	(	const HierarchyPfoVector &	trackPfos,
		const HierarchyPfoVector &	showerPfos,
		const int	nPrimaryTrackLinks,
		const int	nPrimaryShowerLinks,
		const int	nLaterTierTrackTrackLinks,
		const int	nLaterTierTrackShowerLinks
	)		const

private

Fill the output event tree (containing event-level info)

Parameters

trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector
nPrimaryTrackLinks	the number of recorded primary track links
nPrimaryShowerLinks	the number of recorded primary shower links
nLaterTierTrackTrackLinks	the number of recorded track-track later tier links
nLaterTierTrackShowerLinks	the number of recorded track-shower later tier links

Referenced by BuildPandoraHierarchy(), and Run().

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::FillLaterTierTree	(	const std::string &	treeName,
		const bool	isTrainingLink,
		const bool	isTrueLink,
		const bool	isOrientationCorrect,
		const int	childTrueGen,
		const std::pair< float, float > &	trainingCuts,
		const int	parentID,
		const int	childID,
		const DLLaterTierHierarchyTool::DLLaterTierNetworkParams &	networkParams
	)		const

private

Enter an entry into the specified later tier tree.

Parameters

treeName	the name of the tree to fill
isTrainingLink	whether the input link is one to train on
isTrueLink	whether the input link is a true parent-child link
isOrientationCorrect	whether the assumed orientation of the particles is correct
trueChildGen	the true visible generation of the child particle
the	training cut pair of the parent-child link
parentID	the unique ID of the parent particle
childID	the unique ID of the child particle
networkParams	the network parameter variable values of the input link

Referenced by BuildPandoraHierarchy().

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::FillLaterTierTrees	(	const PfoToMCParticleMap &	matchingMap,
		const ChildToParentPfoMap &	childToParentPfoMap,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfoVector &	trackPfos,
		const HierarchyPfoVector &	showerPfos,
		const std::map< const pandora::ParticleFlowObject *, int > &	particleIDMap,
		int &	nTrackLinks,
		int &	nShowerLinks
	)		const

private

Fill the later tier trees (containing later tier link info)

Parameters

matchingMap	the [pfo -> mcparticle] matching map
childToParentPfoMap	the [child pfo -> true parent pfo] map
pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector
particleIDMap	the [pfo -> unique ID] map
nTrackLinks	the number of recorded track-track later tier links
nShowerLinks	the number of recorded track-shower later tier links

Referenced by BuildPandoraHierarchy(), and Run().

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::FillPrimaryTree	(	const std::string &	treeName,
		const bool	isTrainingLink,
		const bool	isTrueLink,
		const bool	isOrientationCorrect,
		const int	trueVisibleGen,
		const int	truePDG,
		const int	trueParentID,
		const int	particleID,
		const DLPrimaryHierarchyTool::DLPrimaryNetworkParams &	primaryNetworkParams
	)		const

private

Enter an entry into the specified primary tree.

Parameters

treeName	the name of the tree to fill
isTrainingLink	whether the input link is one to train on
isTrueLink	whether the input link is a true parent-child link
isOrientationCorrect	whether the assumed orientation of the particle is correct
trueVisibleGen	the true visible generation of the particle
truePDG	the PDG of the matched MCParticle
trueParentID	the unique ID of the true parent
particleID	the unique ID of the particle
primaryNetworkParams	the network parameter variable values of the input link

Referenced by BuildPandoraHierarchy().

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::FillPrimaryTrees	(	const PfoToMCParticleMap &	matchingMap,
		const ChildToParentPfoMap &	childToParentPfoMap,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfoVector &	trackPfos,
		const HierarchyPfoVector &	showerPfos,
		const std::map< const pandora::ParticleFlowObject *, int > &	particleIDMap,
		int &	nPrimaryTrackLinks,
		int &	nPrimaryShowerLinks
	)		const

private

Fill the primary trees (containing primary link info)

Parameters

matchingMap	the [pfo -> mcparticle] matching map
childToParentPfoMap	the [child pfo -> true parent pfo] map
pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector
particleIDMap	the [pfo -> unique ID] map
nPrimaryTrackLinks	the number of recorded primary track links
nPrimaryShowerLinks	the number of recorded primary shower links

Referenced by BuildPandoraHierarchy(), and Run().

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::FillTrackShowerVectors	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		HierarchyPfoVector &	trackPfos,
		HierarchyPfoVector &	showerPfos
	)		const

private

Fill the track and shower-like HierarchyPfoVector.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector

Definition at line 178 of file DLNeutrinoHierarchyAlgorithm.cc.

References GetExtremalVerticesAndDirections(), m_minClusterSize, m_pfoListNames, and m_slidingFitWindow.

Referenced by Run().

 {
     // Sliding fit shenanigans
     const float pitchU{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_U)};
     const float pitchV{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_V)};
     const float pitchW{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_W)};
     const float slidingFitPitch(std::max({pitchU, pitchV, pitchW}));
 
     // Get All pfos
     PfoVector pfoVector;
     for (const std::string &pfoListName : m_pfoListNames)
     {
         const PfoList *pPfoList(nullptr);
 
         if (PandoraContentApi::GetList(*this, pfoListName, pPfoList) != STATUS_CODE_SUCCESS)
             continue;
 
         for (const ParticleFlowObject *const pPfo : *pPfoList)
         {
             // Apply hit cut
             if (LArPfoHelper::GetNumberOfThreeDHits(pPfo) >= m_minClusterSize)
                 pfoVector.emplace_back(pPfo);
         }
     }
 
     // Sort to maintain reproducibility
     std::sort(pfoVector.begin(), pfoVector.end(), LArPfoHelper::SortByNHits);
 
     for (const ParticleFlowObject *const pPfo : pfoVector)
     {
         // Attempt sliding linear fit
         try
         {
             ClusterList clusters3D;
             LArPfoHelper::GetThreeDClusterList(pPfo, clusters3D);
 
             if (clusters3D.size() != 1)
                 continue;
 
             const ThreeDSlidingFitResult slidingFitResult(*clusters3D.begin(), m_slidingFitWindow, slidingFitPitch);
 
             // We need directions...
             ExtremalPoint upstreamPoint, downstreamPoint;
 
             if (!this->GetExtremalVerticesAndDirections(pNeutrinoPfo, pPfo, slidingFitResult, upstreamPoint, downstreamPoint))
                 continue;
 
             // Create track/shower objects
             if (pPfo->GetParticleId() == 13)
             {
                 trackPfos.push_back(HierarchyPfo(pPfo, slidingFitResult, upstreamPoint, downstreamPoint));
             }
             else if (pPfo->GetParticleId() == 11)
             {
                 showerPfos.push_back(HierarchyPfo(pPfo, slidingFitResult, upstreamPoint, downstreamPoint));
             }
         }
         catch (...)
         {
             continue;
         }
     }
 }

bool lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetExtremalVerticesAndDirections	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const pandora::ParticleFlowObject *const	pPfo,
		const ThreeDSlidingFitResult &	slidingFitResult,
		ExtremalPoint &	upstreamPoint,
		ExtremalPoint &	downstreamPoint
	)		const

private

Identify the upstream (closest to the nu vertex) and downstream (furthest from the nu vertex) endpoints and directions of an input pfo.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
pPfo	a pointer to the pfo
slidingFitResult	the sliding fit result of the input pfo
upstreamPoint	the upstream endpoint
downstreamPoint	the downstream endpoint

Returns: whether this was successful

Definition at line 245 of file DLNeutrinoHierarchyAlgorithm.cc.

References f, lar_content::LArPointingCluster::Vertex::GetDirection(), lar_content::ThreeDSlidingFitResult::GetGlobalMaxLayerPosition(), lar_content::ThreeDSlidingFitResult::GetGlobalMinLayerPosition(), lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), lar_content::LArPointingCluster::Vertex::GetPosition(), GetShowerDirection(), and lar_dl_content::ExtremalPoint::Set().

Referenced by FillTrackShowerVectors().

 {
     // First, get the neutrino vertex
     const Vertex *const pNeutrinoVertex(LArPfoHelper::GetVertex(pNeutrinoPfo));
     const CartesianVector nuVertex(
         pNeutrinoVertex->GetPosition().GetX(), pNeutrinoVertex->GetPosition().GetY(), pNeutrinoVertex->GetPosition().GetZ());
 
     if (pPfo->GetParticleId() == 13)
     {
         try
         {
             const LArPointingCluster pointingCluster(slidingFitResult); // this could throw an exception
             const CartesianVector innerVertex(pointingCluster.GetInnerVertex().GetPosition().GetX(),
                 pointingCluster.GetInnerVertex().GetPosition().GetY(), pointingCluster.GetInnerVertex().GetPosition().GetZ());
             CartesianVector innerDirection(pointingCluster.GetInnerVertex().GetDirection().GetX(),
                 pointingCluster.GetInnerVertex().GetDirection().GetY(), pointingCluster.GetInnerVertex().GetDirection().GetZ());
             const CartesianVector outerVertex(pointingCluster.GetOuterVertex().GetPosition().GetX(),
                 pointingCluster.GetOuterVertex().GetPosition().GetY(), pointingCluster.GetOuterVertex().GetPosition().GetZ());
             CartesianVector outerDirection(pointingCluster.GetOuterVertex().GetDirection().GetX(),
                 pointingCluster.GetOuterVertex().GetDirection().GetY(), pointingCluster.GetOuterVertex().GetDirection().GetZ());
 
             // want them to both point into the particle
             if (innerDirection.GetDotProduct(outerVertex - innerVertex) < 0.f)
                 innerDirection *= (-1.f);
 
             if (outerDirection.GetDotProduct(innerVertex - outerVertex) < 0.f)
                 outerDirection *= (-1.f);
 
             // determine upstream/downstream
             if ((innerVertex - nuVertex).GetMagnitudeSquared() < (outerVertex - nuVertex).GetMagnitudeSquared())
             {
                 upstreamPoint.Set(innerVertex, innerDirection);
                 downstreamPoint.Set(outerVertex, outerDirection);
             }
             else
             {
                 upstreamPoint.Set(outerVertex, outerDirection);
                 downstreamPoint.Set(innerVertex, innerDirection);
             }
         }
         catch (...)
         {
             return false;
         }
     }
     else
     {
         // find directions, demand that we have at least one
         CartesianVector minLayerDir(0.f, 0.f, 0.f), maxLayerDir(0.f, 0.f, 0.f);
         const bool minLayerDirSet(this->GetShowerDirection(pPfo, slidingFitResult.GetGlobalMinLayerPosition(), minLayerDir));
         const bool maxLayerDirSet(this->GetShowerDirection(pPfo, slidingFitResult.GetGlobalMaxLayerPosition(), maxLayerDir));
 
         if (!minLayerDirSet && !maxLayerDirSet)
             return false;
 
         const float minSepSq((slidingFitResult.GetGlobalMinLayerPosition() - nuVertex).GetMagnitudeSquared());
         const float maxSepSq((slidingFitResult.GetGlobalMaxLayerPosition() - nuVertex).GetMagnitudeSquared());
 
         if (minLayerDirSet)
         {
             ExtremalPoint &toChange = (minSepSq < maxSepSq) ? upstreamPoint : downstreamPoint;
             toChange.Set(slidingFitResult.GetGlobalMinLayerPosition(), minLayerDir);
         }
 
         if (maxLayerDirSet)
         {
             ExtremalPoint &toChange = (minSepSq < maxSepSq) ? downstreamPoint : upstreamPoint;
             toChange.Set(slidingFitResult.GetGlobalMaxLayerPosition(), maxLayerDir);
         }
     }
 
     return true;
 }

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetLaterTierScore	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfo &	parentPfo,
		const HierarchyPfo &	childPfo
	)		const

private

Call the later tier network tool to obtain the later tier score of a parent-child link.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
parentPfo	the HierarchyPfo object of the parent pfo
childPfo	the HierarchyPfo object of the child pfo

Returns: the parent-child network score

Definition at line 562 of file DLNeutrinoHierarchyAlgorithm.cc.

References m_laterTierHierarchyTool, and lar_dl_content::DLLaterTierHierarchyTool::Run().

Referenced by SetLaterTierScores().

 {
     std::vector<DLLaterTierHierarchyTool::DLLaterTierNetworkParams> networkParamVector;
     float laterTierScore(std::numeric_limits<float>::lowest());
 
     if (m_laterTierHierarchyTool->Run(this, pNeutrinoPfo, parentPfo, childPfo, networkParamVector, laterTierScore) != STATUS_CODE_SUCCESS)
         return std::numeric_limits<float>::lowest();
 
     return laterTierScore;
 }

bool lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetNeutrinoPfo ( const pandora::ParticleFlowObject *& pNeutrinoPfo ) const

private

Return the neutrino pfo.

Parameters

the	pointer to the neutrino pfo to fill

Returns: whether the neutrino pfo can be found

Definition at line 157 of file DLNeutrinoHierarchyAlgorithm.cc.

References m_neutrinoPfoListName.

Referenced by Run().

 {
     const PfoList *pPfoList(nullptr);
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_neutrinoPfoListName, pPfoList));
 
     if (!pPfoList || pPfoList->empty())
         return false;
 
     // ATTN Enforces that only one pfo, of neutrino-type, be in the specified input list
     pNeutrinoPfo = (1 == pPfoList->size()) ? *(pPfoList->begin()) : nullptr;
 
     if (!pNeutrinoPfo || !LArPfoHelper::IsNeutrino(pNeutrinoPfo))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     return true;
 }

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetParticleIDMap	(	const HierarchyPfoVector &	trackPfos,
		const HierarchyPfoVector &	showerPfos,
		std::map< const pandora::ParticleFlowObject *, int > &	particleIDMap
	)		const

private

Obtain the [pfo -> unique ID] map.

Parameters

trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector
particleIDMap	the [pfo -> unique ID] map to populate

Referenced by BuildPandoraHierarchy(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetPrimaryScore	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const HierarchyPfoVector &	trackPfos,
		const HierarchyPfo &	hierarchyPfo
	)		const

private

Call the primary network tool to obtain the primary score of a HierarchyPfo.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
hierarchyPfo	the HierarchyPfo object of the input pfo

Returns: the primary network score

Definition at line 404 of file DLNeutrinoHierarchyAlgorithm.cc.

References m_primaryHierarchyTool, and lar_dl_content::DLPrimaryHierarchyTool::Run().

Referenced by SetPrimaryScores().

 {
     std::vector<DLPrimaryHierarchyTool::DLPrimaryNetworkParams> networkParamVector;
     float primaryScore(std::numeric_limits<float>::lowest());
 
     if (m_primaryHierarchyTool->Run(this, pNeutrinoPfo, trackPfos, hierarchyPfo, networkParamVector, primaryScore) != STATUS_CODE_SUCCESS)
         return std::numeric_limits<float>::lowest();
 
     return primaryScore;
 }

bool lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetShowerDirection	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::CartesianVector &	vertex,
		pandora::CartesianVector &	direction
	)		const

private

Obtain the direction of a shower at a given endpoint from the angular decomposition of the shower's 'close' 3D hits.

Parameters

pPfo	a pointer to the pfo
vertex	the position at which to find the direction
direction	the found direction

Returns: whether a shower direction could be found

Definition at line 322 of file DLNeutrinoHierarchyAlgorithm.cc.

References f, m_nAngularBins, and m_regionForDirFit.

Referenced by GetExtremalVerticesAndDirections().

 {
     CartesianPointVector pointVector;
     LArPfoHelper::GetCoordinateVector(pPfo, TPC_3D, pointVector);
 
     if (pointVector.empty())
         return false;
 
     // set direction by angular distribution
     const float angleMin(0.f), angleMax(2.f * M_PI);
     const float binWidth((angleMax - angleMin) / static_cast<float>(m_nAngularBins));
 
     std::vector<std::vector<int>> spatialDist(m_nAngularBins, std::vector<int>(m_nAngularBins, 0));
     std::vector<std::vector<float>> tieBreakerDist(m_nAngularBins, std::vector<float>(m_nAngularBins, 0.f));
 
     int highestSP(0), bestTheta0YZBin(-1), bestTheta0XZBin(-1);
     float tieBreaker(std::numeric_limits<float>::max());
 
     for (const CartesianVector &position3D : pointVector)
     {
         const CartesianVector displacement(position3D - vertex);
         const float mag(displacement.GetMagnitude());
 
         if (mag > m_regionForDirFit)
             continue;
 
         const float magXZ(sqrt((displacement.GetX() * displacement.GetX()) + (displacement.GetZ() * displacement.GetZ())));
 
         float theta0YZ((mag < std::numeric_limits<float>::epsilon()) ? 0.f
                 : (std::fabs(std::fabs(displacement.GetY() / mag) - 1.f) < std::numeric_limits<float>::epsilon())
                 ? 0.f
                 : std::acos(displacement.GetY() / mag));
 
         float theta0XZ((magXZ < std::numeric_limits<float>::epsilon()) ? 0.f
                 : (std::fabs(std::fabs(displacement.GetX() / magXZ) - 1.f) < std::numeric_limits<float>::epsilon())
                 ? 0.f
                 : std::acos(displacement.GetX() / magXZ));
 
         // try do signed-ness
         if (displacement.GetZ() < 0.f)
             theta0XZ = (2.0 * M_PI) - theta0XZ;
 
         const int bin0YZ(std::floor(theta0YZ / binWidth));
         const int bin0XZ(std::floor(theta0XZ / binWidth));
 
         spatialDist[bin0YZ][bin0XZ] += 1;
         tieBreakerDist[bin0YZ][bin0XZ] += (1.f / mag); // tie-breaker
 
         if (((spatialDist[bin0YZ][bin0XZ] == highestSP) && (tieBreakerDist[bin0YZ][bin0XZ] < tieBreaker)) || (spatialDist[bin0YZ][bin0XZ] > highestSP))
         {
             highestSP = spatialDist[bin0YZ][bin0XZ];
             tieBreaker = tieBreakerDist[bin0YZ][bin0XZ];
             bestTheta0YZBin = bin0YZ;
             bestTheta0XZBin = bin0XZ;
         }
     }
 
     if ((bestTheta0YZBin < 0) || (bestTheta0XZBin < 0))
         return false;
 
     const float bestTheta0YZ(angleMin + ((static_cast<float>(bestTheta0YZBin) + 0.5f) * binWidth));
     const float bestTheta0XZ(angleMin + ((static_cast<float>(bestTheta0XZBin) + 0.5f) * binWidth));
 
     direction = CartesianVector(std::sin(bestTheta0YZ) * std::cos(bestTheta0XZ), std::cos(bestTheta0YZ), std::sin(bestTheta0YZ) * std::sin(bestTheta0XZ));
 
     return true;
 }

std::pair<float, float> lar_dl_content::DLNeutrinoHierarchyAlgorithm::GetTrainingCuts	(	const HierarchyPfo &	parentHierarchyPfo,
		const HierarchyPfo &	childHierarchyPfo,
		const bool	trueParentOrientation,
		const bool	trueChildOrientation
	)		const

private

Get the training cuts for the later tier parent-child link these describe how well the child points back to the parent.

Parameters

parentHierarchyPfo	the HierarchyPfo object of the parent
childHierarchyPfo	the HierarchyPfo object of the child
trueParentOrientation	whether the parent POI is in the upstream position
trueChildOrientation	whether the child POI is in the upstream position

Returns: the training cut pair

Referenced by BuildPandoraHierarchy().

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

private

Definition at line 975 of file DLNeutrinoHierarchyAlgorithm.cc.

References m_cheatHierarchyTool, m_eventID, m_eventTreeName, m_laterTierHierarchyTool, m_laterTierThresholdShowerPass1, m_laterTierThresholdShowerPass2, m_laterTierThresholdTrackPass1, m_laterTierThresholdTrackPass2, m_laterTierTrackShowerTreeName, m_laterTierTrackTrackTreeName, m_mcParticleListName, m_minClusterSize, m_nAngularBins, m_neutrinoPfoListName, m_pfoListNames, m_primaryHierarchyTool, m_primaryRegion, m_primaryShowerTreeName, m_primaryThresholdShowerPass1, m_primaryThresholdShowerPass2, m_primaryThresholdTrackPass1, m_primaryThresholdTrackPass2, m_primaryTrackTreeName, m_regionForDirFit, m_slidingFitWindow, m_trainingFileName, m_trainingMode, and m_trainingVertexAccuracy.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EventID", m_eventID));
     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, "MCParticleListName", m_mcParticleListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingVertexAccuracy", m_trainingVertexAccuracy));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingFileName", m_trainingFileName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EventTreeName", m_eventTreeName));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PrimaryTrackTreeName", m_primaryTrackTreeName));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PrimaryShowerTreeName", m_primaryShowerTreeName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LaterTierTrackTrackTreeName", m_laterTierTrackTrackTreeName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LaterTierTrackShowerTreeName", m_laterTierTrackShowerTreeName));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NeutrinoPfoListName", m_neutrinoPfoListName));
     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, "MinClusterSize", m_minClusterSize));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitWindow", m_slidingFitWindow));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "RegionForDirectionFit", m_regionForDirFit));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NAngularBins", m_nAngularBins));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PrimaryRegion", m_primaryRegion));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "PrimaryThresholdTrackPass1", m_primaryThresholdTrackPass1));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "PrimaryThresholdShowerPass1", m_primaryThresholdShowerPass1));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LaterTierThresholdTrackPass1", m_laterTierThresholdTrackPass1));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LaterTierThresholdShowerPass1", m_laterTierThresholdShowerPass1));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "PrimaryThresholdTrackPass2", m_primaryThresholdTrackPass2));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "PrimaryThresholdShowerPass2", m_primaryThresholdShowerPass2));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LaterTierThresholdTrackPass2", m_laterTierThresholdTrackPass2));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LaterTierThresholdShowerPass2", m_laterTierThresholdShowerPass2));
 
     AlgorithmTool *pAlgorithmTool(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "DLPrimaryHierarchyTool", pAlgorithmTool));
     m_primaryHierarchyTool = dynamic_cast<DLPrimaryHierarchyTool *>(pAlgorithmTool);
 
     if (!m_primaryHierarchyTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     pAlgorithmTool = nullptr;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "DLLaterTierHierarchyTool", pAlgorithmTool));
     m_laterTierHierarchyTool = dynamic_cast<DLLaterTierHierarchyTool *>(pAlgorithmTool);
 
     if (!m_laterTierHierarchyTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     if (m_trainingMode)
     {
         pAlgorithmTool = nullptr;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "DLCheatHierarchyTool", pAlgorithmTool));
         m_cheatHierarchyTool = dynamic_cast<DLCheatHierarchyTool *>(pAlgorithmTool);
 
         if (!m_cheatHierarchyTool)
             return STATUS_CODE_INVALID_PARAMETER;
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DLNeutrinoHierarchyAlgorithm::Run ( )

private

Definition at line 82 of file DLNeutrinoHierarchyAlgorithm.cc.

References BuildPandoraHierarchy(), FillEventTree(), lar_dl_content::DLCheatHierarchyTool::FillHierarchyMap(), FillLaterTierTrees(), FillPrimaryTrees(), FillTrackShowerVectors(), GetNeutrinoPfo(), GetParticleIDMap(), m_cheatHierarchyTool, m_eventID, m_laterTierThresholdShowerPass1, m_laterTierThresholdShowerPass2, m_laterTierThresholdTrackPass1, m_laterTierThresholdTrackPass2, m_primaryThresholdShowerPass1, m_primaryThresholdShowerPass2, m_primaryThresholdTrackPass1, m_primaryThresholdTrackPass2, m_trainingMode, SetLaterTierScores(), SetPrimaryScores(), and UpdateHierarchy().

 {
     ++m_eventID;
 
     // Get neutrino pfo
     const ParticleFlowObject *pNeutrinoPfo(nullptr);
     if (!this->GetNeutrinoPfo(pNeutrinoPfo))
         return STATUS_CODE_SUCCESS;
 
     // Ensure neutrino has a vertex
     if (pNeutrinoPfo->GetVertexList().empty())
         return STATUS_CODE_NOT_INITIALIZED;
 
     // Fill the track/shower vectors
     HierarchyPfoVector trackPfos, showerPfos;
     this->FillTrackShowerVectors(pNeutrinoPfo, trackPfos, showerPfos);
 
 #ifdef MONITORING
 
     if (m_trainingMode)
     {
         if ((trackPfos.empty()) && (showerPfos.empty()))
             return STATUS_CODE_SUCCESS;
 
         // Do ID
         std::map<const pandora::ParticleFlowObject *, int> particleIDMap;
         this->GetParticleIDMap(trackPfos, showerPfos, particleIDMap);
 
         // Get truth
         PfoToMCParticleMap matchingMap;
         ChildToParentPfoMap childToParentPfoMap;
         m_cheatHierarchyTool->FillHierarchyMap(this, matchingMap, childToParentPfoMap);
 
         // Fill trees
         int nPrimaryTrackLinks(0), nPrimaryShowerLinks(0);
         int nLaterTierTrackTrackLinks(0), nLaterTierTrackShowerLinks(0);
 
         this->FillPrimaryTrees(matchingMap, childToParentPfoMap, pNeutrinoPfo, trackPfos, showerPfos, particleIDMap, nPrimaryTrackLinks, nPrimaryShowerLinks);
         this->FillLaterTierTrees(matchingMap, childToParentPfoMap, pNeutrinoPfo, trackPfos, showerPfos, particleIDMap,
             nLaterTierTrackTrackLinks, nLaterTierTrackShowerLinks);
         this->FillEventTree(trackPfos, showerPfos, nPrimaryTrackLinks, nPrimaryShowerLinks, nLaterTierTrackTrackLinks, nLaterTierTrackShowerLinks);
 
         return STATUS_CODE_SUCCESS;
     }
 
 #endif
 
     // Calculate primary scores
     this->SetPrimaryScores(pNeutrinoPfo, trackPfos, showerPfos);
 
     // Build initial primary tier
     Hierarchy hierarchy({PfoVector()});
     this->UpdateHierarchy(pNeutrinoPfo, true, true, m_primaryThresholdTrackPass1, m_primaryThresholdShowerPass1, true, trackPfos, showerPfos, hierarchy);
 
     // Set later tier scores
     this->SetLaterTierScores(pNeutrinoPfo, trackPfos, showerPfos);
 
     // Build the later tier
     this->UpdateHierarchy(
         pNeutrinoPfo, false, false, m_laterTierThresholdTrackPass1, m_laterTierThresholdShowerPass1, true, trackPfos, showerPfos, hierarchy);
 
     // Try to recover primaries using laterTierScore
     this->UpdateHierarchy(pNeutrinoPfo, true, false, m_primaryThresholdTrackPass2, m_primaryThresholdShowerPass2, false, trackPfos, showerPfos, hierarchy);
 
     // Try to recover any children using laterTierScore
     this->UpdateHierarchy(
         pNeutrinoPfo, false, false, m_laterTierThresholdTrackPass2, m_laterTierThresholdShowerPass2, true, trackPfos, showerPfos, hierarchy);
 
     this->BuildPandoraHierarchy(pNeutrinoPfo, trackPfos, showerPfos);
 
     return STATUS_CODE_SUCCESS;
 }

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::SetLaterTierScores	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		HierarchyPfoVector &	trackPfos,
		HierarchyPfoVector &	showerPfos
	)		const

private

Set the predicted parent and later tier score of the HierarchyPfos to be considered for the later tiers.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector

Definition at line 508 of file DLNeutrinoHierarchyAlgorithm.cc.

References GetLaterTierScore(), and m_primaryRegion.

Referenced by Run().

 {
     for (bool isTrack : {true, false})
     {
         HierarchyPfoVector &hierarchyPfoVector(isTrack ? trackPfos : showerPfos);
 
         for (HierarchyPfo &childHierarchyPfo : hierarchyPfoVector)
         {
             // Continue if parent already found
             if (childHierarchyPfo.GetIsInHierarchy())
                 continue;
 
             // Only consider for later tier if far away from nu vertex
             const Vertex *const pNeutrinoVertex(LArPfoHelper::GetVertex(pNeutrinoPfo));
             const CartesianVector nuVertex(
                 pNeutrinoVertex->GetPosition().GetX(), pNeutrinoVertex->GetPosition().GetY(), pNeutrinoVertex->GetPosition().GetZ());
 
             if ((childHierarchyPfo.GetUpstreamPoint().GetPosition() - nuVertex).GetMagnitudeSquared() < (m_primaryRegion * m_primaryRegion))
                 continue;
 
             float highestScore(std::numeric_limits<float>::lowest());
 
             for (const HierarchyPfo &parentHierarchyPfo : trackPfos)
             {
                 if (childHierarchyPfo == parentHierarchyPfo)
                     continue;
 
                 const float thisScore(this->GetLaterTierScore(pNeutrinoPfo, parentHierarchyPfo, childHierarchyPfo));
 
                 if ((childHierarchyPfo.GetPredictedParentPfo()) && (std::fabs(thisScore - highestScore) < std::numeric_limits<float>::epsilon()))
                 {
                     // If tie, pick closest
                     const float currentSep(LArPfoHelper::GetThreeDSeparation(childHierarchyPfo.GetPredictedParentPfo(), childHierarchyPfo.GetPfo()));
                     const float thisSep(LArPfoHelper::GetThreeDSeparation(parentHierarchyPfo.GetPfo(), childHierarchyPfo.GetPfo()));
 
                     if (thisSep > currentSep)
                         continue;
                 }
                 else if (thisScore < highestScore)
                 {
                     continue;
                 }
 
                 highestScore = thisScore;
                 childHierarchyPfo.SetLaterTierScore(thisScore);
                 childHierarchyPfo.SetPredictedParentPfo(parentHierarchyPfo.GetPfo());
             }
         }
     }
 }

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::SetPrimaryScores	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		HierarchyPfoVector &	trackPfos,
		HierarchyPfoVector &	showerPfos
	)		const

private

Set the primary network scores of the HierarchyPfos.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector

Definition at line 392 of file DLNeutrinoHierarchyAlgorithm.cc.

References GetPrimaryScore().

Referenced by Run().

 {
     for (HierarchyPfo &hierarchyPfo : trackPfos)
         hierarchyPfo.SetPrimaryScore(this->GetPrimaryScore(pNeutrinoPfo, trackPfos, hierarchyPfo));
 
     for (HierarchyPfo &hierarchyPfo : showerPfos)
         hierarchyPfo.SetPrimaryScore(this->GetPrimaryScore(pNeutrinoPfo, trackPfos, hierarchyPfo));
 }

bool lar_dl_content::DLNeutrinoHierarchyAlgorithm::ShouldTrainOnEvent ( const pandora::ParticleFlowObject *const pNeutrinoPfo ) const

private

Whether the event should be trained on.

Parameters

pNeutrinoPfo a pointer to the neutrino pfo

Returns: whether to train on the links in the event

Referenced by BuildPandoraHierarchy().

void lar_dl_content::DLNeutrinoHierarchyAlgorithm::UpdateHierarchy	(	const pandora::ParticleFlowObject *const	pNeutrinoPfo,
		const bool	buildPrimaryTier,
		const bool	usePrimaryScore,
		const float	trackThreshold,
		const float	showerThreshold,
		const bool	isLowerThreshold,
		HierarchyPfoVector &	trackPfos,
		HierarchyPfoVector &	showerPfos,
		Hierarchy &	hierarchy
	)		const

private

Add particles to the hierarchy if they satisfy a criteria.

Parameters

pNeutrinoPfo	a pointer to the neutrino pfo
buildPrimaryTier	whether to build the primary tier (or the later tier)
usePrimaryScore	whether to assess the primary score (or the later tier score)
trackThreshold	the threshold network score for tracks
showerThreshold	the threshold network score for showers
isLowerThreshold	whether the threshold is a minimum or maximum requirement
trackPfos	the track-like HierarchyPfoVector
showerPfos	the shower-like HierarchyPfoVector
hierarchy	the hierarchy object to modify

Definition at line 418 of file DLNeutrinoHierarchyAlgorithm.cc.

Referenced by Run().

 {
     bool found(true);
     unsigned int tierIndex(buildPrimaryTier ? 0 : 1);
 
     while (found)
     {
         found = false;
 
         // If building later tiers, check that we do have primaries
         if (!buildPrimaryTier && hierarchy.at(0).empty())
             return;
 
         PfoVector &thisTier(hierarchy.at(tierIndex));
 
         for (bool isTrack : {true, false})
         {
             HierarchyPfoVector &hierarchyPfoVector(isTrack ? trackPfos : showerPfos);
 
             for (HierarchyPfo &childHierarchyPfo : hierarchyPfoVector)
             {
                 const ParticleFlowObject *const pChildPfo(childHierarchyPfo.GetPfo());
 
                 // Continue if parent already found
                 if (childHierarchyPfo.GetIsInHierarchy())
                     continue;
 
                 const ParticleFlowObject *pPredictedParent(pNeutrinoPfo);
 
                 // If not buildPrimaryTier correct pPredictedParent
                 if (!buildPrimaryTier)
                 {
                     // Do we have a predicted parent
                     if (!childHierarchyPfo.GetPredictedParentPfo())
                         continue;
 
                     // Is predicted parent in preceeding tier?
                     const PfoVector &preceedingTier(hierarchy.at(tierIndex - 1));
 
                     pPredictedParent = childHierarchyPfo.GetPredictedParentPfo();
 
                     if (std::find(preceedingTier.begin(), preceedingTier.end(), pPredictedParent) == preceedingTier.end())
                         continue;
                 }
 
                 // Does it pass tier cut?
                 const float networkScore(usePrimaryScore ? childHierarchyPfo.GetPrimaryScore() : childHierarchyPfo.GetLaterTierScore());
                 const float thresholdScore(isTrack ? trackThreshold : showerThreshold);
 
                 if ((isLowerThreshold && (networkScore > thresholdScore)) || (!isLowerThreshold && (networkScore < thresholdScore)))
                 {
                     found = true;
 
                     // Add child to hierarchy tier
                     thisTier.emplace_back(pChildPfo);
 
                     // Add info to childHierarchyPfo
                     childHierarchyPfo.SetIsInHierarchy(true);
                     childHierarchyPfo.SetParentPfo(pPredictedParent);
 
                     // Add info to parentPfo
                     if (!buildPrimaryTier)
                     {
                         const auto iter(std::find(trackPfos.begin(), trackPfos.end(), pPredictedParent));
 
                         if (iter == trackPfos.end())
                             throw StatusCodeException(STATUS_CODE_FAILURE);
 
                         iter->AddChildPfo(pChildPfo);
                     }
                 }
             }
         }
 
         // Make sure to add the next tier
         if (hierarchy.size() == (tierIndex + 1))
             hierarchy.push_back(PfoVector());
 
         // If buildPrimaryTier, our work is done!
         if (buildPrimaryTier)
             break;
 
         ++tierIndex;
     }
 }

Member Data Documentation

DLCheatHierarchyTool* lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_cheatHierarchyTool

private

The tool used to obtain the true hierarchy.

Definition at line 312 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and Run().

int lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_eventID

private

the event counter

Definition at line 285 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and Run().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_eventTreeName

private

the name of the output event tree

Definition at line 288 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and ~DLNeutrinoHierarchyAlgorithm().

DLLaterTierHierarchyTool* lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierHierarchyTool

private

The tool used to build the later tiers.

Definition at line 311 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), GetLaterTierScore(), and ReadSettings().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierThresholdShowerPass1

private

The threshold applied to track-shower links in pass 1 later tier building.

Definition at line 305 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierThresholdShowerPass2

private

The threshold applied to track-shower links in pass 2 later tier building.

Definition at line 309 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierThresholdTrackPass1

private

The threshold applied to track-track links in pass 1 later tier building.

Definition at line 304 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierThresholdTrackPass2

private

The threshold applied to track-track links in pass 2 later tier building.

Definition at line 308 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierTrackShowerTreeName

private

the name of the output track-shower later tier link tree

Definition at line 292 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and ~DLNeutrinoHierarchyAlgorithm().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_laterTierTrackTrackTreeName

private

the name of the output track-track later tier link tree

Definition at line 291 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and ~DLNeutrinoHierarchyAlgorithm().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_mcParticleListName

private

the name of the MCParticle list

Definition at line 293 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), and ReadSettings().

unsigned int lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_minClusterSize

private

the minimum threshold of 3D hits of a considered pfo

Definition at line 297 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), FillTrackShowerVectors(), and ReadSettings().

int lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_nAngularBins

private

the number of angle bins used by the shower direction fitter

Definition at line 300 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), GetShowerDirection(), and ReadSettings().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_neutrinoPfoListName

private

the name of the neutrino pfo list

Definition at line 295 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by GetNeutrinoPfo(), and ReadSettings().

pandora::StringVector lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_pfoListNames

private

the name of the pfo lists

Definition at line 296 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), FillTrackShowerVectors(), and ReadSettings().

DLPrimaryHierarchyTool* lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryHierarchyTool

private

The tool used to build the primary tiers.

Definition at line 310 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), GetPrimaryScore(), and ReadSettings().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryRegion

private

the radius of the nu vertex region where particles are assumed to be primaries

Definition at line 301 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and SetLaterTierScores().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryShowerTreeName

private

the name of the output primary shower link tree

Definition at line 290 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and ~DLNeutrinoHierarchyAlgorithm().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryThresholdShowerPass1

private

The threshold applied to showers in pass 1 primary tier building.

Definition at line 303 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryThresholdShowerPass2

private

The threshold applied to showers in pass 2 primary tier building.

Definition at line 307 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryThresholdTrackPass1

private

The threshold applied to tracks in pass 1 primary tier building.

Definition at line 302 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryThresholdTrackPass2

private

The threshold applied to tracks in pass 2 primary tier building.

Definition at line 306 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), ReadSettings(), and Run().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_primaryTrackTreeName

private

the name of the output primary track link tree

Definition at line 289 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), ReadSettings(), and ~DLNeutrinoHierarchyAlgorithm().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_regionForDirFit

private

the radius of the region used in shower direction fits

Definition at line 299 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), GetShowerDirection(), and ReadSettings().

int lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_slidingFitWindow

private

the sliding fit window to use in pfo sliding linear fits

Definition at line 298 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by DLNeutrinoHierarchyAlgorithm(), FillTrackShowerVectors(), and ReadSettings().

std::string lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_trainingFileName

private

the name of the output training file

Definition at line 287 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by ReadSettings(), and ~DLNeutrinoHierarchyAlgorithm().

bool lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_trainingMode

private

whether to run in training mode

Definition at line 286 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by ReadSettings(), Run(), and ~DLNeutrinoHierarchyAlgorithm().

float lar_dl_content::DLNeutrinoHierarchyAlgorithm::m_trainingVertexAccuracy

private

the maximum true-reco nu vertex displacement allowed for training

Definition at line 294 of file DLNeutrinoHierarchyAlgorithm.h.

Referenced by BuildPandoraHierarchy(), and ReadSettings().

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

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation