AmbiguousRegionFeatureTool to calculate variables related to the shower region. More...

#include "ConnectionPathwayFeatureTool.h"

Inheritance diagram for lar_content::AmbiguousRegionFeatureTool:

Public Types
typedef std::vector< MvaFeatureTool< Ts... > * >	FeatureToolVector

typedef std::map< std::string, MvaFeatureTool< Ts... > * >	FeatureToolMap

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

void	Run (LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pShowerPfo, const pandora::CartesianVector &nuVertex3D, const ProtoShowerMatch &protoShowerMatch, const pandora::CartesianPointVector &showerStarts3D)

void	Run (LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName, const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pShowerPfo, const pandora::CartesianVector &nuVertex3D, const ProtoShowerMatch &protoShowerMatch, const pandora::CartesianPointVector &showerStarts3D)

virtual void	Run (MvaTypes::MvaFeatureVector &featureVector, Ts...args)=0
	Run the algorithm tool. More...

virtual void	Run (MvaTypes::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName, Ts...)

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

void	CalculateNAmbiguousViews (const ProtoShowerMatch &protoShowerMatch, float &nAmbiguousViews)
	Count the number of views with ambiguous hits. More...

bool	GetViewAmbiguousHitVariables (const pandora::Algorithm *const pAlgorithm, const ProtoShowerMatch &protoShowerMatch, const pandora::HitType hitType, const pandora::CartesianVector &nuVertex3D, float &unaccountedHitEnergy)
	Calculate the ambiguous region variables for the input view. More...

void	BuildAmbiguousSpines (const pandora::Algorithm *const pAlgorithm, const pandora::HitType hitType, const ProtoShower &protoShower, const pandora::CartesianVector &nuVertex2D, std::map< int, pandora::CaloHitList > &ambiguousHitSpines, pandora::CaloHitList &hitsToExcludeInEnergyCalcs)
	Determine the spine hits of the particles with which the ambiguous hits are shared. More...

pandora::StatusCode	GetHitListOfType (const pandora::Algorithm const pAlgorithm, const pandora::HitType hitType, const pandora::CaloHitList &pCaloHitList) const
	Obtain the event hit list of a given view. More...

pandora::CaloHitList	FindAmbiguousContinuousSpine (const pandora::CaloHitList &caloHitList, const pandora::CaloHitList &ambiguousHitList, const pandora::CartesianVector &nuVertex2D)
	Determine a continuous pathway of an ambigous particle's spine hits. More...

Private Attributes
float	m_defaultFloat
	Default float value. More...

std::string	m_caloHitListNameU
	The event U view hit list. More...

std::string	m_caloHitListNameV
	The event V view hit list. More...

std::string	m_caloHitListNameW
	The event W view hit list. More...

float	m_maxTransverseDistance
	The max. proximity of a hits, included in a trajectory energy calcs. More...

unsigned int	m_maxSampleHits
	The max. number of hits considered in the spine energy calcs. More...

float	m_maxHitSeparation
	The max. separation of connected hits. More...

float	m_maxTrackFraction
	The fraction of found hits which are considered in the energy calcs. More...

Detailed Description

AmbiguousRegionFeatureTool to calculate variables related to the shower region.

Definition at line 268 of file ConnectionPathwayFeatureTool.h.

Member Typedef Documentation

template<typename... Ts>

typedef std::map<std::string, MvaFeatureTool<Ts...> *> lar_content::MvaFeatureTool< Ts >::FeatureToolMap

inherited

Definition at line 37 of file LArMvaHelper.h.

template<typename... Ts>

typedef std::vector<MvaFeatureTool<Ts...> *> lar_content::MvaFeatureTool< Ts >::FeatureToolVector

inherited

Definition at line 36 of file LArMvaHelper.h.

Constructor & Destructor Documentation

lar_content::AmbiguousRegionFeatureTool::AmbiguousRegionFeatureTool ( )

Default constructor.

Definition at line 870 of file ConnectionPathwayFeatureTool.cc.

References CalculateNAmbiguousViews(), f, GetViewAmbiguousHitVariables(), m_defaultFloat, and Run().

                                                        :
     m_defaultFloat(-10.f),
     m_caloHitListNameU("CaloHitListU"),
     m_caloHitListNameV("CaloHitListV"),
     m_caloHitListNameW("CaloHitListW"),
     m_maxTransverseDistance(0.75f),
     m_maxSampleHits(3),
     m_maxHitSeparation(1.f),
     m_maxTrackFraction(0.8f)
 {
 }

Member Function Documentation

void lar_content::AmbiguousRegionFeatureTool::BuildAmbiguousSpines	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::HitType	hitType,
		const ProtoShower &	protoShower,
		const pandora::CartesianVector &	nuVertex2D,
		std::map< int, pandora::CaloHitList > &	ambiguousHitSpines,
		pandora::CaloHitList &	hitsToExcludeInEnergyCalcs
	)

private

Determine the spine hits of the particles with which the ambiguous hits are shared.

Parameters

pAlgorithm	the algorithm
hitType	the 2D view
protoShower	the ProtoShower
nuVertex2D	the 2D neutrino vertex
ambiguousHitSpines	the output [particle index -> shower spine hits] map
hitsToExcludeInEnergyCalcs	the list of hits to exclude in energy calculations

Definition at line 1040 of file ConnectionPathwayFeatureTool.cc.

References f, FindAmbiguousContinuousSpine(), lar_content::ProtoShower::GetAmbiguousDirectionVector(), lar_content::ProtoShower::GetAmbiguousHitList(), GetHitListOfType(), and m_maxTransverseDistance.

Referenced by GetViewAmbiguousHitVariables().

 {
     const CaloHitList *pCaloHitList;
 
     if (this->GetHitListOfType(pAlgorithm, hitType, pCaloHitList) != STATUS_CODE_SUCCESS)
         return;
 
     std::map<int, CaloHitList> ambiguousHitSpinesTemp;
 
     for (const CaloHit *const pCaloHit : *pCaloHitList)
     {
         if (std::find(protoShower.GetAmbiguousHitList().begin(), protoShower.GetAmbiguousHitList().end(), pCaloHit) !=
             protoShower.GetAmbiguousHitList().end())
             continue;
 
         int count(0);
 
         // A hit can be in more than one spine
         for (unsigned int i = 0; i < protoShower.GetAmbiguousDirectionVector().size(); ++i)
         {
             const CartesianVector &significantDirection(protoShower.GetAmbiguousDirectionVector()[i]);
             const CartesianVector displacement(pCaloHit->GetPositionVector() - nuVertex2D);
             const float thisT(significantDirection.GetCrossProduct(displacement).GetMagnitude());
             const float thisL(significantDirection.GetDotProduct(displacement));
 
             if ((thisL > 0.f) && (thisT < m_maxTransverseDistance))
             {
                 ++count;
                 ambiguousHitSpinesTemp[i].push_back(pCaloHit);
             }
 
             if (count == 2)
                 hitsToExcludeInEnergyCalcs.push_back(pCaloHit);
         }
     }
 
     if (ambiguousHitSpinesTemp.empty())
         return;
 
     // Make sure the pathways are continuous
     for (const auto &entry : ambiguousHitSpinesTemp)
     {
         CaloHitList continuousSpine(this->FindAmbiguousContinuousSpine(entry.second, protoShower.GetAmbiguousHitList(), nuVertex2D));
 
         if (continuousSpine.size() > 0)
             ambiguousHitSpines[entry.first] = continuousSpine;
     }
 }

void lar_content::AmbiguousRegionFeatureTool::CalculateNAmbiguousViews	(	const ProtoShowerMatch &	protoShowerMatch,
		float &	nAmbiguousViews
	)

private

Count the number of views with ambiguous hits.

Parameters

protoShowerMatch	the ProtoShower match
nAmbiguousViews	the output number of ambiguous views

Definition at line 937 of file ConnectionPathwayFeatureTool.cc.

References f, lar_content::ProtoShower::GetAmbiguousHitList(), lar_content::ProtoShowerMatch::GetProtoShowerU(), lar_content::ProtoShowerMatch::GetProtoShowerV(), and lar_content::ProtoShowerMatch::GetProtoShowerW().

Referenced by AmbiguousRegionFeatureTool().

 {
     nAmbiguousViews = 0.f;
 
     const int nAmbiguousHitsU(protoShowerMatch.GetProtoShowerU().GetAmbiguousHitList().size());
     nAmbiguousViews += (nAmbiguousHitsU == 0) ? 0.f : 1.f;
 
     const int nAmbiguousHitsV(protoShowerMatch.GetProtoShowerV().GetAmbiguousHitList().size());
     nAmbiguousViews += (nAmbiguousHitsV == 0) ? 0.f : 1.f;
 
     const int nAmbiguousHitsW(protoShowerMatch.GetProtoShowerW().GetAmbiguousHitList().size());
     nAmbiguousViews += (nAmbiguousHitsW == 0) ? 0.f : 1.f;
 }

CaloHitList lar_content::AmbiguousRegionFeatureTool::FindAmbiguousContinuousSpine	(	const pandora::CaloHitList &	caloHitList,
		const pandora::CaloHitList &	ambiguousHitList,
		const pandora::CartesianVector &	nuVertex2D
	)

private

Determine a continuous pathway of an ambigous particle's spine hits.

Parameters

caloHitList	the input ambiguous particle spine hit list
ambiguousHitList	the ambiguous hit list
nuVertex2D	the 2D neutrino vertex

Returns: a continuous hit pathway

Definition at line 1109 of file ConnectionPathwayFeatureTool.cc.

References lar_content::LArClusterHelper::GetClosestDistance(), m_maxHitSeparation, and m_maxTrackFraction.

Referenced by BuildAmbiguousSpines().

 {
     CaloHitList continuousHitList;
 
     CaloHitVector caloHitVector(caloHitList.begin(), caloHitList.end());
     std::sort(caloHitVector.begin(), caloHitVector.end(), LArConnectionPathwayHelper::SortByDistanceToPoint(nuVertex2D));
 
     for (unsigned int i = 0; i < caloHitVector.size(); ++i)
     {
         CaloHitList connectedHitList;
         connectedHitList.push_back(caloHitVector[i]);
 
         if (LArClusterHelper::GetClosestDistance(connectedHitList.front()->GetPositionVector(), ambiguousHitList) > m_maxHitSeparation)
             continue;
 
         bool found(true);
 
         while (found)
         {
             found = false;
 
             for (unsigned int j = (i + 1); j < caloHitVector.size(); ++j)
             {
                 const CaloHit *const pCaloHit(caloHitVector[j]);
 
                 if (std::find(connectedHitList.begin(), connectedHitList.end(), pCaloHit) != connectedHitList.end())
                     continue;
 
                 if (LArClusterHelper::GetClosestDistance(pCaloHit->GetPositionVector(), connectedHitList) < m_maxHitSeparation)
                 {
                     // to avoid ends of tracks
                     if (static_cast<float>(connectedHitList.size()) < static_cast<float>(caloHitVector.size() * m_maxTrackFraction))
                     {
                         found = true;
                         connectedHitList.push_back(pCaloHit);
                     }
 
                     break;
                 }
             }
         }
 
         if (connectedHitList.size() >= 2)
         {
             continuousHitList.insert(continuousHitList.begin(), connectedHitList.begin(), connectedHitList.end());
             break;
         }
     }
 
     return continuousHitList;
 }

StatusCode lar_content::AmbiguousRegionFeatureTool::GetHitListOfType	(	const pandora::Algorithm *const	pAlgorithm,
		const pandora::HitType	hitType,
		const pandora::CaloHitList *&	pCaloHitList
	)		const

private

Obtain the event hit list of a given view.

Parameters

pAlgorithm	the algorithm
hitType	the 2D view
pCaloHitList	the output 2D hit list

Returns: whether a valid 2D hit list could be found

Definition at line 1092 of file ConnectionPathwayFeatureTool.cc.

References m_caloHitListNameU, m_caloHitListNameV, and m_caloHitListNameW.

Referenced by BuildAmbiguousSpines().

 {
     const std::string typeHitListName(hitType == TPC_VIEW_U ? m_caloHitListNameU
             : hitType == TPC_VIEW_V                         ? m_caloHitListNameV
                                                             : m_caloHitListNameW);
 
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*pAlgorithm, typeHitListName, pCaloHitList));
 
     if (!pCaloHitList || pCaloHitList->empty())
         return STATUS_CODE_NOT_INITIALIZED;
 
     return STATUS_CODE_SUCCESS;
 }

bool lar_content::AmbiguousRegionFeatureTool::GetViewAmbiguousHitVariables	(	const pandora::Algorithm *const	pAlgorithm,
		const ProtoShowerMatch &	protoShowerMatch,
		const pandora::HitType	hitType,
		const pandora::CartesianVector &	nuVertex3D,
		float &	unaccountedHitEnergy
	)

private

Calculate the ambiguous region variables for the input view.

Parameters

pAlgorithm	the algorithm
protoShowerMatch	the ProtoShower match
hitType	the 2D view
nuVertex3D	the 3D neutrino vertex
unaccountedHitEnergy	the output unaccounted hit energy

Returns: whether the ambiguous region variables could be calculated

Definition at line 953 of file ConnectionPathwayFeatureTool.cc.

References BuildAmbiguousSpines(), f, lar_content::ProtoShower::GetAmbiguousHitList(), lar_content::ProtoShower::GetConnectionPathway(), lar_content::ProtoShowerMatch::GetProtoShowerU(), lar_content::ProtoShowerMatch::GetProtoShowerV(), lar_content::ProtoShowerMatch::GetProtoShowerW(), lar_content::ProtoShower::GetSpineHitList(), lar_content::ConnectionPathway::GetStartDirection(), m_maxSampleHits, m_maxTransverseDistance, and lar_content::LArGeometryHelper::ProjectPosition().

Referenced by AmbiguousRegionFeatureTool().

 {
     std::map<int, CaloHitList> ambiguousHitSpines;
     CaloHitList hitsToExcludeInEnergyCalcs; // to avoid double  counting
     const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(pAlgorithm->GetPandora(), nuVertex3D, hitType));
     const ProtoShower &protoShower(hitType == TPC_VIEW_U
             ? protoShowerMatch.GetProtoShowerU()
             : (hitType == TPC_VIEW_V ? protoShowerMatch.GetProtoShowerV() : protoShowerMatch.GetProtoShowerW()));
 
     this->BuildAmbiguousSpines(pAlgorithm, hitType, protoShower, nuVertex2D, ambiguousHitSpines, hitsToExcludeInEnergyCalcs);
 
     if (ambiguousHitSpines.empty())
         return false;
 
     const CartesianVector &startDirection(protoShower.GetConnectionPathway().GetStartDirection());
     float startL(-std::numeric_limits<float>::max());
     float ambiguousHitEnergyMean(0.f);
 
     // Get average energy of the ambiguous hits
     for (const CaloHit *const pAmbiguousCaloHit : protoShower.GetAmbiguousHitList())
     {
         const float thisT(startDirection.GetCrossProduct(pAmbiguousCaloHit->GetPositionVector() - nuVertex2D).GetMagnitude());
         const float thisL(startDirection.GetDotProduct(pAmbiguousCaloHit->GetPositionVector() - nuVertex2D));
 
         if ((thisL > startL) && (thisT < m_maxTransverseDistance))
             startL = thisL;
 
         ambiguousHitEnergyMean += pAmbiguousCaloHit->GetElectromagneticEnergy() * 1000.f;
     }
 
     ambiguousHitEnergyMean /= protoShower.GetAmbiguousHitList().size();
 
     // Get mean energy of other pathways, avoiding the float counting hits
     float otherEnergyMeanSum(0.f);
 
     for (const auto &entry : ambiguousHitSpines)
     {
         int nOtherEnergyHits(0);
         float otherEnergyMean(0.f);
 
         for (const CaloHit *const pOtherCaloHit : entry.second)
         {
             if (std::find(hitsToExcludeInEnergyCalcs.begin(), hitsToExcludeInEnergyCalcs.end(), pOtherCaloHit) != hitsToExcludeInEnergyCalcs.end())
                 continue;
 
             otherEnergyMean += pOtherCaloHit->GetElectromagneticEnergy() * 1000.f;
             ++nOtherEnergyHits;
         }
 
         if (nOtherEnergyHits == 0)
             continue;
 
         otherEnergyMean /= static_cast<float>(nOtherEnergyHits);
         otherEnergyMeanSum += otherEnergyMean;
     }
 
     // Get the spine mean energy, only consider a limited number of  non-ambiguous hits
     float spineEnergyMean(0.f);
     unsigned int nSpineEnergyHits(0);
 
     for (const CaloHit *const pSpineCaloHit : protoShower.GetSpineHitList())
     {
         if (std::find(protoShower.GetAmbiguousHitList().begin(), protoShower.GetAmbiguousHitList().end(), pSpineCaloHit) !=
             protoShower.GetAmbiguousHitList().end())
             continue;
 
         const float thisL(startDirection.GetDotProduct(pSpineCaloHit->GetPositionVector() - nuVertex2D));
 
         if ((thisL > startL) && (nSpineEnergyHits < m_maxSampleHits))
         {
             spineEnergyMean += pSpineCaloHit->GetElectromagneticEnergy() * 1000.f;
             ++nSpineEnergyHits;
         }
     }
 
     if (nSpineEnergyHits == 0)
         return false;
 
     spineEnergyMean /= static_cast<float>(nSpineEnergyHits);
     unaccountedHitEnergy = ambiguousHitEnergyMean - otherEnergyMeanSum - spineEnergyMean;
 
     return true;
 }

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

private

Definition at line 1164 of file ConnectionPathwayFeatureTool.cc.

References m_caloHitListNameU, m_caloHitListNameV, m_caloHitListNameW, m_defaultFloat, m_maxHitSeparation, m_maxSampleHits, m_maxTrackFraction, and m_maxTransverseDistance.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DefaultFloat", m_defaultFloat));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListNameU", m_caloHitListNameU));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListNameV", m_caloHitListNameV));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListNameW", m_caloHitListNameW));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxTransverseDistance", m_maxTransverseDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxSampleHits", m_maxSampleHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxHitSeparation", m_maxHitSeparation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxTrackFraction", m_maxTrackFraction));
 
     return STATUS_CODE_SUCCESS;
 }

template<typename... Ts>

virtual void lar_content::MvaFeatureTool< Ts >::Run	(	MvaTypes::MvaFeatureVector &	featureVector,
		Ts...	args
	)

pure virtualinherited

Run the algorithm tool.

Parameters

featureVector	the vector of features to append
args	arguments to pass to the tool

template<typename... Ts>

virtual void lar_content::MvaFeatureTool< Ts >::Run	(	MvaTypes::MvaFeatureMap &	featureMap,
		pandora::StringVector &	featureOrder,
		const std::string &	featureToolName,
		Ts...
	)

inlinevirtualinherited

Definition at line 51 of file LArMvaHelper.h.

     {
         (void)featureMap;
         (void)featureOrder;
         (void)featureToolName;
         return;
     };

void lar_content::AmbiguousRegionFeatureTool::Run	(	LArMvaHelper::MvaFeatureVector &	featureVector,
		const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CartesianVector &	nuVertex3D,
		const ProtoShowerMatch &	protoShowerMatch,
		const pandora::CartesianPointVector &	showerStarts3D
	)

Referenced by AmbiguousRegionFeatureTool().

void lar_content::AmbiguousRegionFeatureTool::Run	(	LArMvaHelper::MvaFeatureMap &	featureMap,
		pandora::StringVector &	featureOrder,
		const std::string &	featureToolName,
		const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CartesianVector &	nuVertex3D,
		const ProtoShowerMatch &	protoShowerMatch,
		const pandora::CartesianPointVector &	showerStarts3D
	)

Member Data Documentation

std::string lar_content::AmbiguousRegionFeatureTool::m_caloHitListNameU

private

The event U view hit list.

Definition at line 348 of file ConnectionPathwayFeatureTool.h.

Referenced by GetHitListOfType(), and ReadSettings().

std::string lar_content::AmbiguousRegionFeatureTool::m_caloHitListNameV

private

The event V view hit list.

Definition at line 349 of file ConnectionPathwayFeatureTool.h.

Referenced by GetHitListOfType(), and ReadSettings().

std::string lar_content::AmbiguousRegionFeatureTool::m_caloHitListNameW

private

The event W view hit list.

Definition at line 350 of file ConnectionPathwayFeatureTool.h.

Referenced by GetHitListOfType(), and ReadSettings().

float lar_content::AmbiguousRegionFeatureTool::m_defaultFloat

private

Default float value.

Definition at line 347 of file ConnectionPathwayFeatureTool.h.

Referenced by AmbiguousRegionFeatureTool(), and ReadSettings().

float lar_content::AmbiguousRegionFeatureTool::m_maxHitSeparation

private

The max. separation of connected hits.

Definition at line 353 of file ConnectionPathwayFeatureTool.h.

Referenced by FindAmbiguousContinuousSpine(), and ReadSettings().

unsigned int lar_content::AmbiguousRegionFeatureTool::m_maxSampleHits

private

The max. number of hits considered in the spine energy calcs.

Definition at line 352 of file ConnectionPathwayFeatureTool.h.

Referenced by GetViewAmbiguousHitVariables(), and ReadSettings().

float lar_content::AmbiguousRegionFeatureTool::m_maxTrackFraction

private

The fraction of found hits which are considered in the energy calcs.

Definition at line 354 of file ConnectionPathwayFeatureTool.h.

Referenced by FindAmbiguousContinuousSpine(), and ReadSettings().

float lar_content::AmbiguousRegionFeatureTool::m_maxTransverseDistance

private

The max. proximity of a hits, included in a trajectory energy calcs.

Definition at line 351 of file ConnectionPathwayFeatureTool.h.

Referenced by BuildAmbiguousSpines(), GetViewAmbiguousHitVariables(), and ReadSettings().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArShowerRefinement/ConnectionPathwayFeatureTool.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArShowerRefinement/ConnectionPathwayFeatureTool.cc

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation