SvmVertexSelectionAlgorithm class. More...

#include "SvmVertexSelectionAlgorithm.h"

Inheritance diagram for lar_content::SvmVertexSelectionAlgorithm:

Classes
class	EventFeatureInfo
	Event feature info class. More...

class	VertexFeatureInfo
	Vertex feature info class. More...

Public Types
typedef std::map< const pandora::Vertex *const, VertexFeatureInfo >	VertexFeatureInfoMap

typedef std::vector< VertexScore >	VertexScoreList

typedef std::vector< SlidingFitData >	SlidingFitDataList

typedef std::vector< ShowerCluster >	ShowerClusterList

typedef std::map< pandora::HitType, const pandora::ClusterList & >	ClusterListMap
	Map array of cluster lists for passing to tools. More...

typedef std::map< pandora::HitType, const SlidingFitDataList >	SlidingFitDataListMap
	Map of sliding fit data lists for passing to tools. More...

typedef std::map< pandora::HitType, const ShowerClusterList >	ShowerClusterListMap
	Map of shower cluster lists for passing to tools. More...

typedef std::map< pandora::HitType, const std::reference_wrapper< HitKDTree2D > >	KDTreeMap
	Map array of hit kd trees for passing to tools. More...

typedef MvaFeatureTool< const VertexSelectionBaseAlgorithm const, const pandora::Vertex const, const SlidingFitDataListMap &, const ClusterListMap &, const KDTreeMap &, const ShowerClusterListMap &, const float, float & >	VertexFeatureTool
	The base type for the vertex feature tools. More...

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

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

virtual void	FilterVertexList (const pandora::VertexList *const pInputVertexList, HitKDTree2D &kdTreeU, HitKDTree2D &kdTreeV, HitKDTree2D &kdTreeW, pandora::VertexVector &filteredVertices) const
	Filter the input list of vertices to obtain a reduced number of vertex candidates. More...

virtual void	GetBeamConstants (const pandora::VertexVector &vertexVector, BeamConstants &beamConstants) const
	Get the beam score constants for a provided list of candidate vertices. More...

void	GetClusterLists (const pandora::StringVector &inputClusterListNames, pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the cluster lists. More...

void	CalculateClusterSlidingFits (const pandora::ClusterList &inputClusterList, const unsigned int minClusterCaloHits, const unsigned int slidingFitWindow, SlidingFitDataList &slidingFitDataList) const
	Calculate the cluster sliding fits. More...

float	GetBeamDeweightingScore (const BeamConstants &beamConstants, const pandora::Vertex *const pVertex) const
	Get the beam deweighting score for a vertex. More...

bool	IsBeamModeOn () const
	Whether algorithm is running in beam mode, assuming neutrinos travel in positive z-direction. More...

Private Types
typedef std::pair< pandora::CartesianVector, pandora::CartesianVector >	ClusterEndPoints

typedef std::map< const pandora::Cluster *const, ClusterEndPoints >	ClusterEndPointsMap

typedef std::vector< LArMvaHelper::MvaFeatureVector >	FeatureListVector

typedef std::vector< pandora::VertexVector >	VectorOfVertexVectors

typedef KDTreeLinkerAlgo< const pandora::CaloHit *, 2 >	HitKDTree2D

typedef KDTreeNodeInfoT< const pandora::CaloHit *, 2 >	HitKDNode2D

typedef std::vector< HitKDNode2D >	HitKDNode2DList

typedef std::unordered_map< const pandora::CaloHit , const pandora::Cluster >	HitToClusterMap

Private Member Functions
void	GetVertexScoreList (const pandora::VertexVector &vertexVector, const BeamConstants &beamConstants, HitKDTree2D &kdTreeU, HitKDTree2D &kdTreeV, HitKDTree2D &kdTreeW, VertexScoreList &vertexScoreList) const
	Get the vertex score list. More...

void	CalculateShowerClusterList (const pandora::ClusterList &inputClusterList, ShowerClusterList &showerClusterList) const
	Calculate the shower cluster map for a cluster list. More...

void	GetShowerLikeClusterEndPoints (const pandora::ClusterList &clusterList, pandora::ClusterList &showerLikeClusters, ClusterEndPointsMap &clusterEndPointsMap) const
	Add the endpoints of any shower-like clusters to the map. More...

void	PopulateKdTree (const pandora::ClusterList &clusterList, HitKDTree2D &kdTree, HitToClusterMap &hitToClusterMap) const
	Populate kd tree with information about hits in a provided list of clusters. More...

bool	AddClusterToShower (const ClusterEndPointsMap &clusterEndPointsMap, pandora::ClusterList &availableShowerLikeClusters, const pandora::Cluster *const pCluster, pandora::ClusterList &showerCluster) const
	Try to add an available cluster to a given shower cluster, using shower clustering approximation. More...

bool	AddClusterToShower (HitKDTree2D &kdTree, const HitToClusterMap &hitToClusterMap, pandora::ClusterList &availableShowerLikeClusters, const pandora::Cluster *const pCluster, pandora::ClusterList &showerCluster) const
	Try to add an available cluster to a given shower cluster, using cluster hit positions cached in kd tree. More...

EventFeatureInfo	CalculateEventFeatures (const pandora::ClusterList &clusterListU, const pandora::ClusterList &clusterListV, const pandora::ClusterList &clusterListW, const pandora::VertexVector &vertexVector) const
	Calculate the event parameters. More...

void	IncrementShoweryParameters (const pandora::ClusterList &clusterList, unsigned int &nShoweryHits, unsigned int &nHits, float &eventEnergy) const
	Increment the showery hit parameters for a cluster list. More...

bool	IsClusterShowerLike (const pandora::Cluster *const pCluster) const
	Find whether a cluster is shower-like. More...

void	GetEventShapeFeatures (const pandora::ClusterList &clusterList, float &eventVolume, float &longitudinality) const
	Get the event shape features. More...

void	UpdateSpanCoordinate (const float minPositionCoord, const float maxPositionCoord, pandora::InputFloat &minCoord, pandora::InputFloat &maxCoord) const
	Update the min/max coordinate spans. More...

float	GetCoordinateSpan (const pandora::InputFloat &minCoord, const pandora::InputFloat &maxCoord) const
	Get the coordinate span. More...

void	AddEventFeaturesToVector (const EventFeatureInfo &eventFeatureInfo, LArMvaHelper::MvaFeatureVector &featureVector) const
	Add the event features to a vector in the correct order. More...

void	PopulateVertexFeatureInfoMap (const BeamConstants &beamConstants, const ClusterListMap &clusterListMap, const SlidingFitDataListMap &slidingFitDataListMap, const ShowerClusterListMap &showerClusterListMap, const KDTreeMap &kdTreeMap, const pandora::Vertex *const pVertex, VertexFeatureInfoMap &vertexFeatureInfoMap) const
	Populate the vertex feature info map for a given vertex. More...

void	PopulateInitialScoreList (VertexFeatureInfoMap &vertexFeatureInfoMap, const pandora::Vertex *const pVertex, VertexScoreList &initialScoreList) const
	Populate the initial vertex score list for a given vertex. More...

void	GetBestRegionVertices (VertexScoreList &initialScoreList, pandora::VertexVector &bestRegionVertices) const
	Get the list of top-N separated vertices. More...

void	ProduceTrainingSets (const pandora::VertexVector &vertexVector, const pandora::VertexVector &bestRegionVertices, VertexFeatureInfoMap &vertexFeatureInfoMap, const LArMvaHelper::MvaFeatureVector &eventFeatureList, const KDTreeMap &kdTreeMap) const
	Produce the region and vertex training sets. More...

void	CalculateRPhiScores (pandora::VertexVector &vertexVector, VertexFeatureInfoMap &vertexFeatureInfoMap, const KDTreeMap &kdTreeMap) const
	Calculate the r/phi scores for the vertices in a vector, possibly erasing those that fail the fast score test. More...

std::string	GetInteractionType () const
	Get the interaction type string. More...

const pandora::Vertex *	ProduceTrainingExamples (const pandora::VertexVector &vertexVector, const VertexFeatureInfoMap &vertexFeatureInfoMap, std::bernoulli_distribution &coinFlip, std::mt19937 &generator, const std::string &interactionType, const std::string &trainingOutputFile, const LArMvaHelper::MvaFeatureVector &eventFeatureList, const float maxRadius, const bool useRPhi) const
	Produce a set of training examples for a binary classifier. More...

void	GetBestVertex (const pandora::VertexVector &vertexVector, const pandora::Vertex *&pBestVertex, float &bestVertexDr) const
	Use the MC information to get the best vertex from a list. More...

void	AddVertexFeaturesToVector (const VertexFeatureInfo &vertexFeatureInfo, LArMvaHelper::MvaFeatureVector &featureVector, const bool useRPhi) const
	Add the vertex features to a vector in the correct order. More...

const pandora::Vertex *	CompareVertices (const pandora::VertexVector &vertexVector, const VertexFeatureInfoMap &vertexFeatureInfoMap, const LArMvaHelper::MvaFeatureVector &eventFeatureList, const SupportVectorMachine &supportVectorMachine, const bool useRPhi) const
	Used a binary classifier to compare a set of vertices and pick the best one. More...

void	PopulateFinalVertexScoreList (const VertexFeatureInfoMap &vertexFeatureInfoMap, const pandora::Vertex *const pFavouriteVertex, const pandora::VertexVector &vertexVector, VertexScoreList &finalVertexScoreList) const
	Populate the final vertex score list using the r/phi score to find the best vertex in the vicinity. More...

Private Attributes
VertexFeatureTool::FeatureToolVector	m_featureToolVector
	The feature tool vector. More...

std::string	m_filePathEnvironmentVariable
	The environment variable providing a list of paths to svm files. More...

std::string	m_svmFileName
	The Svm file name. More...

std::string	m_regionSvmName
	The name of the region Svm to find. More...

std::string	m_vertexSvmName
	The name of the vertex Svm to find. More...

SupportVectorMachine	m_svMachineRegion
	The region support vector machine. More...

SupportVectorMachine	m_svMachineVertex
	The vertex support vector machine. More...

bool	m_trainingSetMode
	Whether to train. More...

bool	m_allowClassifyDuringTraining
	Whether classification is allowed during training. More...

float	m_mcVertexXCorrection
	The correction to the x-coordinate of the MC vertex position. More...

std::string	m_trainingOutputFileRegion
	The training output file for the region Svm. More...

std::string	m_trainingOutputFileVertex
	The training output file for the vertex Svm. More...

std::string	m_mcParticleListName
	The MC particle list for creating training examples. More...

std::string	m_caloHitListName
	The 2D CaloHit list name. More...

pandora::StringVector	m_inputClusterListNames
	The list of cluster list names. More...

unsigned int	m_minClusterCaloHits
	The min number of hits parameter in the energy score. More...

unsigned int	m_slidingFitWindow
	The layer window for the sliding linear fits. More...

float	m_minShowerSpineLength
	The minimum length at which all are considered to be tracks. More...

float	m_beamDeweightingConstant
	The beam deweighting constant for the initial region score list. More...

float	m_localAsymmetryConstant
	The local asymmetry constant for the initial region score list. More...

float	m_globalAsymmetryConstant
	The global asymmetry constant for the initial region score list. More...

float	m_showerAsymmetryConstant
	The shower asymmetry constant for the initial region score list. More...

float	m_energyKickConstant
	The energy kick constant for the initial region score list. More...

float	m_showerClusteringDistance
	The shower clustering distance. More...

unsigned int	m_minShowerClusterHits
	The minimum number of shower cluster hits. More...

bool	m_useShowerClusteringApproximation
	Whether to use the shower clustering distance approximation. More...

float	m_regionRadius
	The radius for a vertex region. More...

float	m_rPhiFineTuningRadius
	The maximum distance the r/phi tune can move a vertex. More...

float	m_maxTrueVertexRadius
	The maximum distance at which a vertex candidate can be considered the 'true' vertex. More...

bool	m_useRPhiFeatureForRegion
	Whether to use the r/phi feature for the region vertex. More...

bool	m_dropFailedRPhiFastScoreCandidates
	Whether to drop candidates that fail the r/phi fast score test. More...

Detailed Description

SvmVertexSelectionAlgorithm class.

Definition at line 33 of file SvmVertexSelectionAlgorithm.h.

Member Typedef Documentation

typedef std::pair<pandora::CartesianVector, pandora::CartesianVector> lar_content::SvmVertexSelectionAlgorithm::ClusterEndPoints

private

Definition at line 107 of file SvmVertexSelectionAlgorithm.h.

typedef std::map<const pandora::Cluster *const, ClusterEndPoints> lar_content::SvmVertexSelectionAlgorithm::ClusterEndPointsMap

private

Definition at line 108 of file SvmVertexSelectionAlgorithm.h.

typedef std::map<pandora::HitType, const pandora::ClusterList &> lar_content::VertexSelectionBaseAlgorithm::ClusterListMap

inherited

Map array of cluster lists for passing to tools.

Definition at line 224 of file VertexSelectionBaseAlgorithm.h.

typedef std::vector<LArMvaHelper::MvaFeatureVector> lar_content::SvmVertexSelectionAlgorithm::FeatureListVector

private

Definition at line 109 of file SvmVertexSelectionAlgorithm.h.

typedef KDTreeNodeInfoT<const pandora::CaloHit*, 2> lar_content::SvmVertexSelectionAlgorithm::HitKDNode2D

private

Definition at line 144 of file SvmVertexSelectionAlgorithm.h.

typedef std::vector<HitKDNode2D> lar_content::SvmVertexSelectionAlgorithm::HitKDNode2DList

private

Definition at line 145 of file SvmVertexSelectionAlgorithm.h.

typedef KDTreeLinkerAlgo<const pandora::CaloHit*, 2> lar_content::SvmVertexSelectionAlgorithm::HitKDTree2D

private

Definition at line 143 of file SvmVertexSelectionAlgorithm.h.

typedef std::unordered_map<const pandora::CaloHit*, const pandora::Cluster*> lar_content::SvmVertexSelectionAlgorithm::HitToClusterMap

private

Definition at line 147 of file SvmVertexSelectionAlgorithm.h.

typedef std::map<pandora::HitType, const std::reference_wrapper<HitKDTree2D> > lar_content::VertexSelectionBaseAlgorithm::KDTreeMap

inherited

Map array of hit kd trees for passing to tools.

Definition at line 227 of file VertexSelectionBaseAlgorithm.h.

typedef std::vector<ShowerCluster> lar_content::VertexSelectionBaseAlgorithm::ShowerClusterList

inherited

Definition at line 218 of file VertexSelectionBaseAlgorithm.h.

typedef std::map<pandora::HitType, const ShowerClusterList> lar_content::VertexSelectionBaseAlgorithm::ShowerClusterListMap

inherited

Map of shower cluster lists for passing to tools.

Definition at line 226 of file VertexSelectionBaseAlgorithm.h.

typedef std::vector<SlidingFitData> lar_content::VertexSelectionBaseAlgorithm::SlidingFitDataList

inherited

Definition at line 172 of file VertexSelectionBaseAlgorithm.h.

typedef std::map<pandora::HitType, const SlidingFitDataList> lar_content::VertexSelectionBaseAlgorithm::SlidingFitDataListMap

inherited

Map of sliding fit data lists for passing to tools.

Definition at line 225 of file VertexSelectionBaseAlgorithm.h.

typedef std::vector<pandora::VertexVector> lar_content::SvmVertexSelectionAlgorithm::VectorOfVertexVectors

private

Definition at line 110 of file SvmVertexSelectionAlgorithm.h.

typedef std::map<const pandora::Vertex *const, VertexFeatureInfo> lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfoMap

Definition at line 63 of file SvmVertexSelectionAlgorithm.h.

typedef MvaFeatureTool<const VertexSelectionBaseAlgorithm *const, const pandora::Vertex * const, const SlidingFitDataListMap &, const ClusterListMap &, const KDTreeMap &, const ShowerClusterListMap &, const float, float &> lar_content::VertexSelectionBaseAlgorithm::VertexFeatureTool

inherited

The base type for the vertex feature tools.

Definition at line 230 of file VertexSelectionBaseAlgorithm.h.

typedef std::vector<VertexScore> lar_content::VertexSelectionBaseAlgorithm::VertexScoreList

inherited

Definition at line 79 of file VertexSelectionBaseAlgorithm.h.

Constructor & Destructor Documentation

lar_content::SvmVertexSelectionAlgorithm::SvmVertexSelectionAlgorithm ( )

Default constructor.

Definition at line 34 of file SvmVertexSelectionAlgorithm.cc.

                                                          :
     VertexSelectionBaseAlgorithm(),
     m_filePathEnvironmentVariable("FW_SEARCH_PATH"),
     m_trainingSetMode(false),
     m_allowClassifyDuringTraining(false),
     m_mcVertexXCorrection(0.f),
     m_minClusterCaloHits(12),
     m_slidingFitWindow(100),
     m_minShowerSpineLength(15.f),
     m_beamDeweightingConstant(0.4),
     m_localAsymmetryConstant(3.f),
     m_globalAsymmetryConstant(1.f),
     m_showerAsymmetryConstant(1.f),
     m_energyKickConstant(0.06),
     m_showerClusteringDistance(3.f),
     m_minShowerClusterHits(1),
     m_useShowerClusteringApproximation(false),
     m_regionRadius(10.f),
     m_rPhiFineTuningRadius(2.f),
     m_maxTrueVertexRadius(1.f),
     m_useRPhiFeatureForRegion(false),
     m_dropFailedRPhiFastScoreCandidates(true)
 {
 }

Member Function Documentation

bool lar_content::SvmVertexSelectionAlgorithm::AddClusterToShower	(	const ClusterEndPointsMap &	clusterEndPointsMap,
		pandora::ClusterList &	availableShowerLikeClusters,
		const pandora::Cluster *const	pCluster,
		pandora::ClusterList &	showerCluster
	)		const

private

Try to add an available cluster to a given shower cluster, using shower clustering approximation.

Parameters

clusterEndPointsMap	the map of shower-like cluster endpoints
availableShowerLikeClusters	the list of shower-like clusters still available
pCluster	the cluster in the shower cluster from which to consider distances
showerCluster	the shower cluster

Returns: boolean

Referenced by CalculateShowerClusterList(), and PopulateKdTree().

bool lar_content::SvmVertexSelectionAlgorithm::AddClusterToShower	(	HitKDTree2D &	kdTree,
		const HitToClusterMap &	hitToClusterMap,
		pandora::ClusterList &	availableShowerLikeClusters,
		const pandora::Cluster *const	pCluster,
		pandora::ClusterList &	showerCluster
	)		const

private

Try to add an available cluster to a given shower cluster, using cluster hit positions cached in kd tree.

Parameters

kdTree	the kd tree, used purely for efficiency in events with large hit multiplicity
hitToClusterMap	the hit to cluster map, used to interpret kd tree findings
availableShowerLikeClusters	the list of shower-like clusters still available
pCluster	the cluster in the shower cluster from which to consider distances
showerCluster	the shower cluster

Returns: boolean

void lar_content::SvmVertexSelectionAlgorithm::AddEventFeaturesToVector	(	const EventFeatureInfo &	eventFeatureInfo,
		LArMvaHelper::MvaFeatureVector &	featureVector
	)		const

private

Add the event features to a vector in the correct order.

Parameters

eventFeatureInfo	the event feature info
featureVector	the vector of doubles to append

Definition at line 432 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_eventEnergy, lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_eventShoweryness, lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_eventVolume, lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_longitudinality, lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_nCandidates, lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_nClusters, and lar_content::SvmVertexSelectionAlgorithm::EventFeatureInfo::m_nHits.

Referenced by GetVertexScoreList().

 {
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_eventShoweryness));
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_eventEnergy));
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_eventVolume));
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_longitudinality));
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_nHits));
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_nClusters));
     featureVector.push_back(static_cast<double>(eventFeatureInfo.m_nCandidates));
 }

void lar_content::SvmVertexSelectionAlgorithm::AddVertexFeaturesToVector	(	const VertexFeatureInfo &	vertexFeatureInfo,
		LArMvaHelper::MvaFeatureVector &	featureVector,
		const bool	useRPhi
	)		const

private

Add the vertex features to a vector in the correct order.

Parameters

vertexFeatureInfo	the vertex feature info
featureVector	the vector of floats to append
useRPhi	whether to include the r/phi feature

Definition at line 687 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_beamDeweighting, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_energyKick, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_globalAsymmetry, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_localAsymmetry, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_rPhiFeature, and lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_showerAsymmetry.

Referenced by CompareVertices(), and ProduceTrainingExamples().

 {
     featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_beamDeweighting));
     featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_energyKick));
     featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_globalAsymmetry));
     featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_localAsymmetry));
     featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_showerAsymmetry));
 
     if (useRPhi)
         featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_rPhiFeature));
 }

void lar_content::VertexSelectionBaseAlgorithm::CalculateClusterSlidingFits	(	const pandora::ClusterList &	inputClusterList,
		const unsigned int	minClusterCaloHits,
		const unsigned int	slidingFitWindow,
		SlidingFitDataList &	slidingFitDataList
	)		const

protectedinherited

Calculate the cluster sliding fits.

Parameters

inputClusterList	the input cluster list
minClusterCaloHits	the minimum number of cluster calo hits
slidingFitWindow	the sliding fit window
slidingFitDataList	the list of sliding fits to fill

Definition at line 119 of file VertexSelectionBaseAlgorithm.cc.

References lar_content::LArGeometryHelper::GetWireZPitch(), min, and lar_content::LArClusterHelper::SortByNHits().

Referenced by lar_content::EnergyKickVertexSelectionAlgorithm::GetVertexScoreList(), and GetVertexScoreList().

 {
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     ClusterVector sortedClusters(inputClusterList.begin(), inputClusterList.end());
     std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);
 
     for (const Cluster * const pCluster : sortedClusters)
     {
         if (pCluster->GetNCaloHits() < minClusterCaloHits)
             continue;
 
         // Make sure the window size is such that there are not more layers than hits (following TwoDSlidingLinearFit calculation).
         const unsigned int newSlidingFitWindow(std::min(static_cast<int>(pCluster->GetNCaloHits()), static_cast<int>(slidingFitPitch * slidingFitWindow)));
         slidingFitDataList.emplace_back(pCluster, newSlidingFitWindow, slidingFitPitch);
     }
 }

SvmVertexSelectionAlgorithm::EventFeatureInfo lar_content::SvmVertexSelectionAlgorithm::CalculateEventFeatures	(	const pandora::ClusterList &	clusterListU,
		const pandora::ClusterList &	clusterListV,
		const pandora::ClusterList &	clusterListW,
		const pandora::VertexVector &	vertexVector
	)		const

private

Calculate the event parameters.

Parameters

clusterListU	the U-view cluster list
clusterListV	the V-view cluster list
clusterListW	the W-view cluster list
vertexVector	the vector of vertex candidates

Returns: the EventFeatureInfo object

Definition at line 323 of file SvmVertexSelectionAlgorithm.cc.

References f, GetEventShapeFeatures(), and IncrementShoweryParameters().

Referenced by GetVertexScoreList().

 {
     float eventEnergy(0.f);
     unsigned int nShoweryHits(0), nHits(0);
 
     this->IncrementShoweryParameters(clusterListU, nShoweryHits, nHits, eventEnergy);
     this->IncrementShoweryParameters(clusterListV, nShoweryHits, nHits, eventEnergy);
     this->IncrementShoweryParameters(clusterListW, nShoweryHits, nHits, eventEnergy);
 
     const unsigned int nClusters(clusterListU.size() + clusterListV.size() + clusterListW.size());
     const float eventShoweryness((nHits > 0) ? static_cast<float>(nShoweryHits) / static_cast<float>(nHits) : 0.f);
 
     ClusterList allClusters(clusterListU);
     allClusters.insert(allClusters.end(), clusterListV.begin(), clusterListV.end());
     allClusters.insert(allClusters.end(), clusterListW.begin(), clusterListW.end());
 
     float eventVolume(0.f), longitudinality(0.f);
     this->GetEventShapeFeatures(allClusters, eventVolume, longitudinality);
 
     return EventFeatureInfo(eventShoweryness, eventEnergy, eventVolume, longitudinality, nHits, nClusters, vertexVector.size());
 }

void lar_content::SvmVertexSelectionAlgorithm::CalculateRPhiScores	(	pandora::VertexVector &	vertexVector,
		VertexFeatureInfoMap &	vertexFeatureInfoMap,
		const KDTreeMap &	kdTreeMap
	)		const

private

Calculate the r/phi scores for the vertices in a vector, possibly erasing those that fail the fast score test.

Parameters

vertexVector	the vector of vertices
vertexFeatureInfoMap	the vertex feature info map
kdTreeMap	the kd tree map

Definition at line 564 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_beamDeweighting, m_dropFailedRPhiFastScoreCandidates, m_featureToolVector, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_rPhiFeature, and max.

Referenced by GetVertexScoreList(), and ProduceTrainingSets().

 {
     float bestFastScore(-std::numeric_limits<float>::max());
 
     for (auto iter = vertexVector.begin(); iter != vertexVector.end(); /* no increment */)
     {
         VertexFeatureInfo &vertexFeatureInfo = vertexFeatureInfoMap.at(*iter);
         vertexFeatureInfo.m_rPhiFeature = static_cast<float>(LArMvaHelper::CalculateFeaturesOfType<RPhiFeatureTool>(m_featureToolVector, this, *iter,
             SlidingFitDataListMap(), ClusterListMap(), kdTreeMap, ShowerClusterListMap(), vertexFeatureInfo.m_beamDeweighting,
             bestFastScore).at(0).Get());
 
         if (m_dropFailedRPhiFastScoreCandidates && (vertexFeatureInfo.m_rPhiFeature <= std::numeric_limits<float>::epsilon()))
             iter = vertexVector.erase(iter);
 
         else
             ++iter;
     }
 }

void lar_content::SvmVertexSelectionAlgorithm::CalculateShowerClusterList	(	const pandora::ClusterList &	inputClusterList,
		ShowerClusterList &	showerClusterList
	)		const

private

Calculate the shower cluster map for a cluster list.

Parameters

inputClusterList	the input cluster list
showerClusterList	the shower cluster list to populate

Definition at line 148 of file SvmVertexSelectionAlgorithm.cc.

References AddClusterToShower(), GetShowerLikeClusterEndPoints(), lar_content::LArGeometryHelper::GetWireZPitch(), m_minClusterCaloHits, m_slidingFitWindow, m_useShowerClusteringApproximation, and PopulateKdTree().

Referenced by GetVertexScoreList().

 {
     ClusterEndPointsMap clusterEndPointsMap;
     ClusterList showerLikeClusters;
     this->GetShowerLikeClusterEndPoints(inputClusterList, showerLikeClusters, clusterEndPointsMap);
 
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
     ClusterList availableShowerLikeClusters(showerLikeClusters.begin(), showerLikeClusters.end());
 
     HitKDTree2D kdTree;
     HitToClusterMap hitToClusterMap;
 
     if (!m_useShowerClusteringApproximation)
         this->PopulateKdTree(availableShowerLikeClusters, kdTree, hitToClusterMap);
 
     while (!availableShowerLikeClusters.empty())
     {
         ClusterList showerCluster;
         showerCluster.push_back(availableShowerLikeClusters.back());
         availableShowerLikeClusters.pop_back();
 
         bool addedCluster(true);
         while (addedCluster && !availableShowerLikeClusters.empty())
         {
             addedCluster = false;
             for (const Cluster *const pCluster : showerCluster)
             {
                 if (!m_useShowerClusteringApproximation)
                 {
                     addedCluster = this->AddClusterToShower(kdTree, hitToClusterMap, availableShowerLikeClusters, pCluster, showerCluster);
                 }
                 else
                 {
                     addedCluster = this->AddClusterToShower(clusterEndPointsMap, availableShowerLikeClusters, pCluster, showerCluster);
                 }
 
                 if (addedCluster)
                     break;
             }
         }
 
         unsigned int totHits(0);
         for (const Cluster *const pCluster : showerCluster)
             totHits += pCluster->GetNCaloHits();
 
         if (totHits < m_minClusterCaloHits)
             continue;
 
         showerClusterList.emplace_back(showerCluster, slidingFitPitch, m_slidingFitWindow);
     }
 }

const pandora::Vertex * lar_content::SvmVertexSelectionAlgorithm::CompareVertices	(	const pandora::VertexVector &	vertexVector,
		const VertexFeatureInfoMap &	vertexFeatureInfoMap,
		const LArMvaHelper::MvaFeatureVector &	eventFeatureList,
		const SupportVectorMachine &	supportVectorMachine,
		const bool	useRPhi
	)		const

private

Used a binary classifier to compare a set of vertices and pick the best one.

Parameters

vertexVector	the vector of vertices
vertexFeatureInfoMap	the vertex feature info map
eventFeatureList	the event feature list
supportVectorMachine	the support vector machine classifier
useRPhi	whether to include the r/phi feature

Returns: address of the best vertex

Definition at line 702 of file SvmVertexSelectionAlgorithm.cc.

References AddVertexFeaturesToVector(), and lar_content::LArMvaHelper::Classify().

Referenced by GetVertexScoreList().

 {
     const Vertex *pBestVertex(vertexVector.front());
     LArMvaHelper::MvaFeatureVector chosenFeatureList;
 
     VertexFeatureInfo chosenVertexFeatureInfo(vertexFeatureInfoMap.at(pBestVertex));
     this->AddVertexFeaturesToVector(chosenVertexFeatureInfo, chosenFeatureList, useRPhi);
 
     for (const Vertex *const pVertex : vertexVector)
     {
         if (pVertex == pBestVertex)
             continue;
 
         LArMvaHelper::MvaFeatureVector featureList;
         VertexFeatureInfo vertexFeatureInfo(vertexFeatureInfoMap.at(pVertex));
         this->AddVertexFeaturesToVector(vertexFeatureInfo, featureList, useRPhi);
 
         if (LArMvaHelper::Classify(supportVectorMachine, eventFeatureList, featureList, chosenFeatureList))
         {
             pBestVertex = pVertex;
             chosenFeatureList = featureList;
         }
     }
 
     return pBestVertex;
 }

void lar_content::VertexSelectionBaseAlgorithm::FilterVertexList	(	const pandora::VertexList *const	pInputVertexList,
		HitKDTree2D &	kdTreeU,
		HitKDTree2D &	kdTreeV,
		HitKDTree2D &	kdTreeW,
		pandora::VertexVector &	filteredVertices
	)		const

protectedvirtualinherited

Filter the input list of vertices to obtain a reduced number of vertex candidates.

Parameters

pInputVertexList	the address of the input vertex list
kdTreeU	the kd tree for u hits
kdTreeV	the kd tree for v hits
kdTreeW	the kd tree for w hits
filteredVertices	to receive the filtered vertex list

Definition at line 40 of file VertexSelectionBaseAlgorithm.cc.

References lar_content::KDTreeLinkerAlgo< DATA, DIM >::empty(), lar_content::VertexSelectionBaseAlgorithm::IsVertexInGap(), lar_content::VertexSelectionBaseAlgorithm::IsVertexOnHit(), lar_content::VertexSelectionBaseAlgorithm::m_isEmptyViewAcceptable, lar_content::VertexSelectionBaseAlgorithm::m_minVertexAcceptableViews, and lar_content::VertexSelectionBaseAlgorithm::SortByVertexZPosition().

Referenced by lar_content::VertexSelectionBaseAlgorithm::Run().

 {
     for (const Vertex *const pVertex : *pInputVertexList)
     {
         unsigned int nAcceptableViews(0);
 
         if ((m_isEmptyViewAcceptable && kdTreeU.empty()) || this->IsVertexOnHit(pVertex, TPC_VIEW_U, kdTreeU) || this->IsVertexInGap(pVertex, TPC_VIEW_U))
             ++nAcceptableViews;
 
         if ((m_isEmptyViewAcceptable && kdTreeV.empty()) || this->IsVertexOnHit(pVertex, TPC_VIEW_V, kdTreeV) || this->IsVertexInGap(pVertex, TPC_VIEW_V))
             ++nAcceptableViews;
 
         if ((m_isEmptyViewAcceptable && kdTreeW.empty()) || this->IsVertexOnHit(pVertex, TPC_VIEW_W, kdTreeW) || this->IsVertexInGap(pVertex, TPC_VIEW_W))
             ++nAcceptableViews;
 
         if (nAcceptableViews >= m_minVertexAcceptableViews)
             filteredVertices.push_back(pVertex);
     }
 
     std::sort(filteredVertices.begin(), filteredVertices.end(), SortByVertexZPosition);
 }

void lar_content::VertexSelectionBaseAlgorithm::GetBeamConstants	(	const pandora::VertexVector &	vertexVector,
		BeamConstants &	beamConstants
	)		const

protectedvirtualinherited

Get the beam score constants for a provided list of candidate vertices.

Parameters

vertexVector	the vertex vector
beamConstants	to receive the beam constants

Definition at line 65 of file VertexSelectionBaseAlgorithm.cc.

References f, lar_content::VertexSelectionBaseAlgorithm::m_beamMode, lar_content::VertexSelectionBaseAlgorithm::m_nDecayLengthsInZSpan, max, and lar_content::VertexSelectionBaseAlgorithm::BeamConstants::SetConstants().

Referenced by lar_content::VertexSelectionBaseAlgorithm::Run().

 {
     if (!m_beamMode)
         return;
 
     if (vertexVector.empty())
         throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
     float minZCoordinate(std::numeric_limits<float>::max()), maxZCoordinate(-std::numeric_limits<float>::max());
 
     for (const Vertex *const pVertex : vertexVector)
     {
         if (pVertex->GetPosition().GetZ() < minZCoordinate)
             minZCoordinate = pVertex->GetPosition().GetZ();
 
         if (pVertex->GetPosition().GetZ() > maxZCoordinate)
             maxZCoordinate = pVertex->GetPosition().GetZ();
     }
 
     const float zSpan(maxZCoordinate - minZCoordinate);
     const float decayConstant((zSpan < std::numeric_limits<float>::epsilon()) ? 0.f : (m_nDecayLengthsInZSpan / zSpan));
     beamConstants.SetConstants(minZCoordinate, decayConstant);
 }

float lar_content::VertexSelectionBaseAlgorithm::GetBeamDeweightingScore	(	const BeamConstants &	beamConstants,
		const pandora::Vertex *const	pVertex
	)		const

inlineprotectedinherited

Get the beam deweighting score for a vertex.

Parameters

beamConstants	the beam constants
pVertex	address of the vertex

Returns: the score

Definition at line 394 of file VertexSelectionBaseAlgorithm.h.

References lar_content::VertexSelectionBaseAlgorithm::BeamConstants::GetDecayConstant(), lar_content::VertexSelectionBaseAlgorithm::BeamConstants::GetMinZCoordinate(), and max.

Referenced by lar_content::EnergyKickVertexSelectionAlgorithm::GetVertexScoreList(), and PopulateVertexFeatureInfoMap().

 {
     const float vertexMinZ(std::max(pVertex->GetPosition().GetZ(), beamConstants.GetMinZCoordinate()));
     return (beamConstants.GetMinZCoordinate() - vertexMinZ) * beamConstants.GetDecayConstant();
 }

void lar_content::SvmVertexSelectionAlgorithm::GetBestRegionVertices	(	VertexScoreList &	initialScoreList,
		pandora::VertexVector &	bestRegionVertices
	)		const

private

Get the list of top-N separated vertices.

Parameters

initialScoreList	the initial score list
bestRegionVertices	the list of best region vertices populate

Definition at line 491 of file SvmVertexSelectionAlgorithm.cc.

References m_regionRadius.

Referenced by GetVertexScoreList().

 {
     std::sort(initialScoreList.begin(), initialScoreList.end());
 
     for (const VertexScore &vertexScore : initialScoreList)
     {
         const Vertex *const pVertex(vertexScore.GetVertex());
         bool farEnoughAway(true);
 
         for (const Vertex *const pRegionVertex: bestRegionVertices)
         {
             if (pRegionVertex == pVertex)
             {
                 farEnoughAway = false;
                 break;
             }
 
             const float distance = (pRegionVertex->GetPosition() - pVertex->GetPosition()).GetMagnitude();
 
             if (distance <= m_regionRadius)
             {
                 farEnoughAway = false;
                 break;
             }
         }
 
         if (farEnoughAway)
             bestRegionVertices.push_back(pVertex);
     }
 }

void lar_content::SvmVertexSelectionAlgorithm::GetBestVertex	(	const pandora::VertexVector &	vertexVector,
		const pandora::Vertex *&	pBestVertex,
		float &	bestVertexDr
	)		const

private

Use the MC information to get the best vertex from a list.

Parameters

vertexVector	the vector of vertices
pBestVertex	address of the best vertex
bestVertexDr	dR of the best vertex

Definition at line 654 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::LArMCParticleHelper::GetTrueNeutrinos(), m_mcParticleListName, m_mcVertexXCorrection, and max.

Referenced by ProduceTrainingExamples().

 {
     // Extract input collections
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));
 
     // Obtain vector: true neutrinos
     MCParticleVector mcNeutrinoVector;
     LArMCParticleHelper::GetTrueNeutrinos(pMCParticleList, mcNeutrinoVector);
 
     for (const Vertex *const pVertex : vertexVector)
     {
         float mcVertexDr(std::numeric_limits<float>::max());
         for (const MCParticle *const pMCNeutrino : mcNeutrinoVector)
         {
             const CartesianVector mcNeutrinoPosition(pMCNeutrino->GetEndpoint().GetX() + m_mcVertexXCorrection, pMCNeutrino->GetEndpoint().GetY(),
                 pMCNeutrino->GetEndpoint().GetZ());
 
             const float dr = (mcNeutrinoPosition - pVertex->GetPosition()).GetMagnitude();
             if (dr < mcVertexDr)
                 mcVertexDr = dr;
         }
 
         if (mcVertexDr < bestVertexDr)
         {
             bestVertexDr = mcVertexDr;
             pBestVertex = pVertex;
         }
     }
 }

void lar_content::VertexSelectionBaseAlgorithm::GetClusterLists	(	const pandora::StringVector &	inputClusterListNames,
		pandora::ClusterList &	clusterListU,
		pandora::ClusterList &	clusterListV,
		pandora::ClusterList &	clusterListW
	)		const

protectedinherited

Get the cluster lists.

Parameters

inputClusterListNames	the input cluster list names
clusterListU	the U-view cluster list to populate
clusterListV	the V-view cluster list to populate
clusterListW	the W-view cluster list to populate

Definition at line 91 of file VertexSelectionBaseAlgorithm.cc.

References lar_content::LArClusterHelper::GetClusterHitType().

Referenced by lar_content::EnergyKickVertexSelectionAlgorithm::GetVertexScoreList(), and GetVertexScoreList().

 {
     for (const std::string &clusterListName : inputClusterListNames)
     {
         const ClusterList *pClusterList(NULL);
         PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList));
 
         if (!pClusterList || pClusterList->empty())
         {
              if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                  std::cout << "EnergyKickVertexSelectionAlgorithm: unable to find cluster list " << clusterListName << std::endl;
 
             continue;
         }
 
         const HitType hitType(LArClusterHelper::GetClusterHitType(*(pClusterList->begin())));
 
         if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
         ClusterList &clusterList((TPC_VIEW_U == hitType) ? clusterListU : (TPC_VIEW_V == hitType) ? clusterListV : clusterListW);
         clusterList.insert(clusterList.end(), pClusterList->begin(), pClusterList->end());
     }
 }

float lar_content::SvmVertexSelectionAlgorithm::GetCoordinateSpan	(	const pandora::InputFloat &	minCoord,
		const pandora::InputFloat &	maxCoord
	)		const

inlineprivate

Get the coordinate span.

Parameters

minCoord	the min coordinate
maxCoord	the max coordinate

Returns: the coordinate span

Definition at line 422 of file SvmVertexSelectionAlgorithm.cc.

Referenced by GetEventShapeFeatures().

 {
    if (minCoord.IsInitialized() && maxCoord.IsInitialized())
         return std::fabs(maxCoord.Get() - minCoord.Get());
 
     return 0.f;
 }

void lar_content::SvmVertexSelectionAlgorithm::GetEventShapeFeatures	(	const pandora::ClusterList &	clusterList,
		float &	eventVolume,
		float &	longitudinality
	)		const

private

Get the event shape features.

Parameters

clusterList	the cluster list
eventVolume	the event volume
longitudinality	the event longitudinality

Definition at line 370 of file SvmVertexSelectionAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClusterBoundingBox(), GetCoordinateSpan(), and UpdateSpanCoordinate().

Referenced by CalculateEventFeatures().

 {
     InputFloat xMin, yMin, zMin, xMax, yMax, zMax;
 
     for (const Cluster *const pCluster : clusterList)
     {
         CartesianVector minPosition(0.f, 0.f, 0.f), maxPosition(0.f, 0.f, 0.f);
         LArClusterHelper::GetClusterBoundingBox(pCluster, minPosition, maxPosition);
 
         this->UpdateSpanCoordinate(minPosition.GetX(), maxPosition.GetX(), xMin, xMax);
         this->UpdateSpanCoordinate(minPosition.GetY(), maxPosition.GetY(), yMin, yMax);
         this->UpdateSpanCoordinate(minPosition.GetZ(), maxPosition.GetZ(), zMin, zMax);
     }
 
     const float xSpan(this->GetCoordinateSpan(xMax, xMin));
     const float ySpan(this->GetCoordinateSpan(yMax, zMin));
     const float zSpan(this->GetCoordinateSpan(yMax, zMin));
 
     // Calculate the volume and longitudinality of the event (ySpan often 0 - to be investigated).
     if ((xSpan > std::numeric_limits<float>::epsilon()) && (ySpan > std::numeric_limits<float>::epsilon()))
     {
         eventVolume     = xSpan * ySpan * zSpan;
         longitudinality = zSpan / (xSpan + ySpan);
     }
 
     else if (ySpan > std::numeric_limits<float>::epsilon())
     {
         eventVolume     = ySpan * ySpan * zSpan;
         longitudinality = zSpan / (ySpan + ySpan);
     }
 
     else if (xSpan > std::numeric_limits<float>::epsilon())
     {
         eventVolume     = xSpan * xSpan * zSpan;
         longitudinality = zSpan / (xSpan + xSpan);
     }
 }

std::string lar_content::SvmVertexSelectionAlgorithm::GetInteractionType ( ) const

private

Get the interaction type string.

Returns: the interaction type string

Definition at line 586 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::LArInteractionTypeHelper::GetInteractionType(), lar_content::LArMCParticleHelper::IsBeamNeutrinoFinalState(), m_caloHitListName, m_mcParticleListName, lar_content::LArMCParticleHelper::SelectReconstructableMCParticles(), lar_content::LArMCParticleHelper::SortByMomentum(), and lar_content::LArInteractionTypeHelper::ToString().

Referenced by ProduceTrainingSets().

 {
     // Extract input collections
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));
 
     const CaloHitList *pCaloHitList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pCaloHitList));
 
     // ATTN Assumes single neutrino is parent of all neutrino-induced mc particles
     LArMCParticleHelper::MCContributionMap nuMCParticlesToGoodHitsMap;
     LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, LArMCParticleHelper::PrimaryParameters(),
         LArMCParticleHelper::IsBeamNeutrinoFinalState, nuMCParticlesToGoodHitsMap);
 
     MCParticleList mcPrimaryList;
     for (const auto &mapEntry : nuMCParticlesToGoodHitsMap) mcPrimaryList.push_back(mapEntry.first);
     mcPrimaryList.sort(LArMCParticleHelper::SortByMomentum);
 
     const LArInteractionTypeHelper::InteractionType interactionType(LArInteractionTypeHelper::GetInteractionType(mcPrimaryList));
     return LArInteractionTypeHelper::ToString(interactionType);
 }

void lar_content::SvmVertexSelectionAlgorithm::GetShowerLikeClusterEndPoints	(	const pandora::ClusterList &	clusterList,
		pandora::ClusterList &	showerLikeClusters,
		ClusterEndPointsMap &	clusterEndPointsMap
	)		const

private

Add the endpoints of any shower-like clusters to the map.

Parameters

clusterList	the list of clusters
showerLikeClusters	the list of shower-like clusters to populate
clusterEndPointsMap	the map of shower-like cluster endpoints to populate

Definition at line 202 of file SvmVertexSelectionAlgorithm.cc.

References IsClusterShowerLike(), m_minShowerClusterHits, and lar_content::LArClusterHelper::SortHitsByPosition().

Referenced by CalculateShowerClusterList().

 {
     for (const Cluster *const pCluster : clusterList)
     {
         if (pCluster->GetNCaloHits() < m_minShowerClusterHits)
             continue;
 
         if (this->IsClusterShowerLike(pCluster))
             showerLikeClusters.push_back(pCluster);
 
         CaloHitList clusterCaloHitList;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(clusterCaloHitList);
 
         CaloHitVector clusterCaloHitVector(clusterCaloHitList.begin(), clusterCaloHitList.end());
         std::sort(clusterCaloHitVector.begin(), clusterCaloHitVector.end(), LArClusterHelper::SortHitsByPosition);
 
         if (clusterCaloHitVector.empty())
             continue;
 
         ClusterEndPoints clusterEndPoints(clusterCaloHitVector.front()->GetPositionVector(), clusterCaloHitVector.back()->GetPositionVector());
         clusterEndPointsMap.emplace(pCluster, clusterEndPoints);
     }
 }

void lar_content::SvmVertexSelectionAlgorithm::GetVertexScoreList	(	const pandora::VertexVector &	vertexVector,
		const BeamConstants &	beamConstants,
		HitKDTree2D &	kdTreeU,
		HitKDTree2D &	kdTreeV,
		HitKDTree2D &	kdTreeW,
		VertexScoreList &	vertexScoreList
	)		const

privatevirtual

Get the vertex score list.

Parameters

vertexVector	the vector of vertices
beamConstants	the beam constants
kdTreeU	the hit kd tree for the U view
kdTreeV	the hit kd tree for the V view
kdTreeW	the hit kd tree for the W view
vertexScoreList	the vertex score list to fill

Implements lar_content::VertexSelectionBaseAlgorithm.

Definition at line 61 of file SvmVertexSelectionAlgorithm.cc.

References AddEventFeaturesToVector(), lar_content::VertexSelectionBaseAlgorithm::CalculateClusterSlidingFits(), CalculateEventFeatures(), CalculateRPhiScores(), CalculateShowerClusterList(), CompareVertices(), GetBestRegionVertices(), lar_content::VertexSelectionBaseAlgorithm::GetClusterLists(), m_allowClassifyDuringTraining, m_inputClusterListNames, m_minClusterCaloHits, m_regionRadius, m_slidingFitWindow, m_svMachineRegion, m_svMachineVertex, m_trainingSetMode, m_useRPhiFeatureForRegion, PopulateFinalVertexScoreList(), PopulateInitialScoreList(), PopulateVertexFeatureInfoMap(), and ProduceTrainingSets().

 {
     ClusterList clustersU, clustersV, clustersW;
     this->GetClusterLists(m_inputClusterListNames, clustersU, clustersV, clustersW);
 
     SlidingFitDataList slidingFitDataListU, slidingFitDataListV, slidingFitDataListW;
     this->CalculateClusterSlidingFits(clustersU, m_minClusterCaloHits, m_slidingFitWindow, slidingFitDataListU);
     this->CalculateClusterSlidingFits(clustersV, m_minClusterCaloHits, m_slidingFitWindow, slidingFitDataListV);
     this->CalculateClusterSlidingFits(clustersW, m_minClusterCaloHits, m_slidingFitWindow, slidingFitDataListW);
 
     ShowerClusterList showerClusterListU, showerClusterListV, showerClusterListW;
     this->CalculateShowerClusterList(clustersU, showerClusterListU);
     this->CalculateShowerClusterList(clustersV, showerClusterListV);
     this->CalculateShowerClusterList(clustersW, showerClusterListW);
 
     // Create maps from hit types to objects for passing to feature tools.
     const ClusterListMap clusterListMap{{TPC_VIEW_U, clustersU},
                                         {TPC_VIEW_V, clustersV},
                                         {TPC_VIEW_W, clustersV}};
 
     const SlidingFitDataListMap slidingFitDataListMap{{TPC_VIEW_U, slidingFitDataListU},
                                                       {TPC_VIEW_V, slidingFitDataListV},
                                                       {TPC_VIEW_W, slidingFitDataListW}};
 
     const ShowerClusterListMap showerClusterListMap{{TPC_VIEW_U, showerClusterListU},
                                                     {TPC_VIEW_V, showerClusterListV},
                                                     {TPC_VIEW_W, showerClusterListW}};
 
     const KDTreeMap kdTreeMap{{TPC_VIEW_U, kdTreeU},
                               {TPC_VIEW_V, kdTreeV},
                               {TPC_VIEW_W, kdTreeW}};
 
     // Calculate the event feature list and the vertex feature map.
     EventFeatureInfo eventFeatureInfo(this->CalculateEventFeatures(clustersU, clustersV, clustersW, vertexVector));
 
     LArMvaHelper::MvaFeatureVector eventFeatureList;
     this->AddEventFeaturesToVector(eventFeatureInfo, eventFeatureList);
 
     VertexFeatureInfoMap vertexFeatureInfoMap;
     for (const Vertex *const pVertex : vertexVector)
     {
         this->PopulateVertexFeatureInfoMap(beamConstants, clusterListMap, slidingFitDataListMap, showerClusterListMap, kdTreeMap, pVertex,
             vertexFeatureInfoMap);
     }
 
     // Use a simple score to get the list of vertices representing good regions.
     VertexScoreList initialScoreList;
     for (const Vertex *const pVertex : vertexVector)
         PopulateInitialScoreList(vertexFeatureInfoMap, pVertex, initialScoreList);
 
     VertexVector bestRegionVertices;
     this->GetBestRegionVertices(initialScoreList, bestRegionVertices);
 
     if (m_trainingSetMode)
         this->ProduceTrainingSets(vertexVector, bestRegionVertices, vertexFeatureInfoMap, eventFeatureList, kdTreeMap);
 
     if ((!m_trainingSetMode || m_allowClassifyDuringTraining) && !bestRegionVertices.empty())
     {
         // Use svm to choose the region.
         const Vertex *const pBestRegionVertex(this->CompareVertices(bestRegionVertices, vertexFeatureInfoMap, eventFeatureList, m_svMachineRegion,
             m_useRPhiFeatureForRegion));
 
         // Get all the vertices in the best region.
         VertexVector regionalVertices{pBestRegionVertex};
         for (const Vertex *const pVertex : vertexVector)
         {
             if (pVertex == pBestRegionVertex)
                 continue;
 
             if ((pBestRegionVertex->GetPosition() - pVertex->GetPosition()).GetMagnitude() < m_regionRadius)
                 regionalVertices.push_back(pVertex);
         }
 
         this->CalculateRPhiScores(regionalVertices, vertexFeatureInfoMap, kdTreeMap);
 
         if (!regionalVertices.empty())
         {
             // Use svm to choose the vertex and then fine-tune using the RPhi score.
             const Vertex *const pBestVertex(this->CompareVertices(regionalVertices, vertexFeatureInfoMap, eventFeatureList, m_svMachineVertex, true));
             this->PopulateFinalVertexScoreList(vertexFeatureInfoMap, pBestVertex, vertexVector, vertexScoreList);
         }
     }
 }

void lar_content::SvmVertexSelectionAlgorithm::IncrementShoweryParameters	(	const pandora::ClusterList &	clusterList,
		unsigned int &	nShoweryHits,
		unsigned int &	nHits,
		float &	eventEnergy
	)		const

private

Increment the showery hit parameters for a cluster list.

Parameters

clusterList	the cluster list
nShoweryHits	the number of showery hits
nHits	the number of hits
eventEnergy	the event energy

Definition at line 348 of file SvmVertexSelectionAlgorithm.cc.

References IsClusterShowerLike().

Referenced by CalculateEventFeatures().

 {
     for (const Cluster *const pCluster : clusterList)
     {
         if (this->IsClusterShowerLike(pCluster))
             nShoweryHits += pCluster->GetNCaloHits();
 
         eventEnergy += pCluster->GetElectromagneticEnergy();
         nHits += pCluster->GetNCaloHits();
     }
 }

bool lar_content::VertexSelectionBaseAlgorithm::IsBeamModeOn ( ) const

inlineprotectedinherited

Whether algorithm is running in beam mode, assuming neutrinos travel in positive z-direction.

Returns: boolean

Definition at line 402 of file VertexSelectionBaseAlgorithm.h.

References lar_content::VertexSelectionBaseAlgorithm::m_beamMode.

Referenced by lar_content::EnergyKickVertexSelectionAlgorithm::GetVertexScoreList().

 {
     return m_beamMode;
 }

bool lar_content::SvmVertexSelectionAlgorithm::IsClusterShowerLike ( const pandora::Cluster *const pCluster ) const

inlineprivate

Find whether a cluster is shower-like.

Parameters

pCluster the cluster

Returns: boolean

Definition at line 363 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::LArClusterHelper::GetLength(), and m_minShowerSpineLength.

Referenced by GetShowerLikeClusterEndPoints(), and IncrementShoweryParameters().

 {
     return (pCluster->GetParticleId() == E_MINUS && LArClusterHelper::GetLength(pCluster) < m_minShowerSpineLength);
 }

void lar_content::SvmVertexSelectionAlgorithm::PopulateFinalVertexScoreList	(	const VertexFeatureInfoMap &	vertexFeatureInfoMap,
		const pandora::Vertex *const	pFavouriteVertex,
		const pandora::VertexVector &	vertexVector,
		VertexScoreList &	finalVertexScoreList
	)		const

private

Populate the final vertex score list using the r/phi score to find the best vertex in the vicinity.

Parameters

vertexFeatureInfoMap	the vertex feature info map
pFavouriteVertex	address of the favourite vertex
vertexVector	the vector of all vertex candidates
finalVertexScoreList	the final vertex score list to populate

Definition at line 732 of file SvmVertexSelectionAlgorithm.cc.

References m_rPhiFineTuningRadius.

Referenced by GetVertexScoreList().

 {
     if (pFavouriteVertex)
     {
         const CartesianVector vertexPosition(pFavouriteVertex->GetPosition());
 
         for (const Vertex *const pVertex : vertexVector)
         {
             if ((pVertex->GetPosition() - vertexPosition).GetMagnitude() < m_rPhiFineTuningRadius)
             {
                 const float rPhiScore(vertexFeatureInfoMap.at(pVertex).m_rPhiFeature);
                 finalVertexScoreList.emplace_back(pVertex, rPhiScore);
             }
         }
     }
 }

void lar_content::SvmVertexSelectionAlgorithm::PopulateInitialScoreList	(	VertexFeatureInfoMap &	vertexFeatureInfoMap,
		const pandora::Vertex *const	pVertex,
		VertexScoreList &	initialScoreList
	)		const

private

Populate the initial vertex score list for a given vertex.

Parameters

vertexFeatureInfoMap	the vertex feature info map
pVertex	the vertex
initialScoreList	the score list to populate

Definition at line 475 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_beamDeweighting, m_beamDeweightingConstant, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_energyKick, m_energyKickConstant, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_globalAsymmetry, m_globalAsymmetryConstant, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_localAsymmetry, m_localAsymmetryConstant, lar_content::SvmVertexSelectionAlgorithm::VertexFeatureInfo::m_showerAsymmetry, and m_showerAsymmetryConstant.

Referenced by GetVertexScoreList().

 {
     VertexFeatureInfo vertexFeatureInfo = vertexFeatureInfoMap.at(pVertex);
 
     const float beamDeweightingScore(vertexFeatureInfo.m_beamDeweighting / m_beamDeweightingConstant);
     const float energyKickScore(-vertexFeatureInfo.m_energyKick / m_energyKickConstant);
     const float localAsymmetryScore(vertexFeatureInfo.m_localAsymmetry / m_localAsymmetryConstant);
     const float globalAsymmetryScore(vertexFeatureInfo.m_globalAsymmetry / m_globalAsymmetryConstant);
     const float showerAsymmetryScore(vertexFeatureInfo.m_showerAsymmetry / m_showerAsymmetryConstant);
 
     initialScoreList.emplace_back(pVertex, beamDeweightingScore + energyKickScore + localAsymmetryScore + globalAsymmetryScore + showerAsymmetryScore);
 }

void lar_content::SvmVertexSelectionAlgorithm::PopulateKdTree	(	const pandora::ClusterList &	clusterList,
		HitKDTree2D &	kdTree,
		HitToClusterMap &	hitToClusterMap
	)		const

private

Populate kd tree with information about hits in a provided list of clusters.

Parameters

clusterList	the list of clusters
kdTree	to receive the populated kd tree
hitToClusterMap	to receive the populated hit to cluster map

Definition at line 229 of file SvmVertexSelectionAlgorithm.cc.

References AddClusterToShower(), lar_content::KDTreeLinkerAlgo< DATA, DIM >::build(), lar_content::build_2d_kd_search_region(), lar_content::fill_and_bound_2d_kd_tree(), m_showerClusteringDistance, min, and lar_content::KDTreeLinkerAlgo< DATA, DIM >::search().

Referenced by CalculateShowerClusterList().

 {
     CaloHitList allCaloHits;
 
     for (const Cluster *const pCluster : clusterList)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
         allCaloHits.insert(allCaloHits.end(), daughterHits.begin(), daughterHits.end());
 
         for (const CaloHit *const pCaloHit : daughterHits)
             (void) hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHit, pCluster));
     }
 
     HitKDNode2DList hitKDNode2DList;
     KDTreeBox hitsBoundingRegion2D(fill_and_bound_2d_kd_tree(allCaloHits, hitKDNode2DList));
     kdTree.build(hitKDNode2DList, hitsBoundingRegion2D);
 }

void lar_content::SvmVertexSelectionAlgorithm::PopulateVertexFeatureInfoMap	(	const BeamConstants &	beamConstants,
		const ClusterListMap &	clusterListMap,
		const SlidingFitDataListMap &	slidingFitDataListMap,
		const ShowerClusterListMap &	showerClusterListMap,
		const KDTreeMap &	kdTreeMap,
		const pandora::Vertex *const	pVertex,
		VertexFeatureInfoMap &	vertexFeatureInfoMap
	)		const

private

Populate the vertex feature info map for a given vertex.

Parameters

beamConstants	the beam constants
clusterListMap	the cluster list map
slidingFitDataListMap	the sliding fit data list map
showerClusterListMap	the shower cluster list map
kdTreeMap	the kd tree map
pVertex	the vertex
vertexFeatureInfoMap	the map to populate

Definition at line 446 of file SvmVertexSelectionAlgorithm.cc.

References f, Get, lar_content::VertexSelectionBaseAlgorithm::GetBeamDeweightingScore(), m_featureToolVector, and max.

Referenced by GetVertexScoreList().

 {
     float bestFastScore(-std::numeric_limits<float>::max()); // not actually used - artefact of toolizing RPhi score and still using performance trick
 
     const double beamDeweighting(this->GetBeamDeweightingScore(beamConstants, pVertex));
 
     const double energyKick(LArMvaHelper::CalculateFeaturesOfType<EnergyKickFeatureTool>(m_featureToolVector, this, pVertex,
         slidingFitDataListMap, clusterListMap, kdTreeMap, showerClusterListMap, beamDeweighting, bestFastScore).at(0).Get());
 
     const double localAsymmetry(LArMvaHelper::CalculateFeaturesOfType<LocalAsymmetryFeatureTool>(m_featureToolVector, this, pVertex,
         slidingFitDataListMap, clusterListMap, kdTreeMap, showerClusterListMap, beamDeweighting, bestFastScore).at(0).Get());
 
     const double globalAsymmetry(LArMvaHelper::CalculateFeaturesOfType<GlobalAsymmetryFeatureTool>(m_featureToolVector, this, pVertex,
         slidingFitDataListMap, clusterListMap, kdTreeMap, showerClusterListMap, beamDeweighting, bestFastScore).at(0).Get());
 
     const double showerAsymmetry(LArMvaHelper::CalculateFeaturesOfType<ShowerAsymmetryFeatureTool>(m_featureToolVector, this, pVertex,
         slidingFitDataListMap, clusterListMap, kdTreeMap, showerClusterListMap, beamDeweighting, bestFastScore).at(0).Get());
 
     //const double rPhiFeature(LArMvaHelper::CalculateFeaturesOfType<RPhiFeatureTool>(m_featureToolVector, this, pVertex,
     //    slidingFitDataListMap, clusterListMap, kdTreeMap, showerClusterListMap, beamDeweighting, bestFastScore).at(0).Get());
 
     VertexFeatureInfo vertexFeatureInfo(beamDeweighting, 0.f, energyKick, localAsymmetry, globalAsymmetry, showerAsymmetry);
     vertexFeatureInfoMap.emplace(pVertex, vertexFeatureInfo);
 }

const pandora::Vertex * lar_content::SvmVertexSelectionAlgorithm::ProduceTrainingExamples	(	const pandora::VertexVector &	vertexVector,
		const VertexFeatureInfoMap &	vertexFeatureInfoMap,
		std::bernoulli_distribution &	coinFlip,
		std::mt19937 &	generator,
		const std::string &	interactionType,
		const std::string &	trainingOutputFile,
		const LArMvaHelper::MvaFeatureVector &	eventFeatureList,
		const float	maxRadius,
		const bool	useRPhi
	)		const

private

Produce a set of training examples for a binary classifier.

Parameters

vertexVector	the vector of vertices to use
vertexFeatureInfoMap	the vertex feature info map
coinFlip	a distribution for producing coin flips
generator	the random number generator
interactionType	the interaction type string
trainingOutputFile	the training set output file
eventFeatureList	the event feature list
maxRadius	the maximum allowed radius for the 'best' vertex
useRPhi	whether to include the r/phi feature

Returns: address of the vertex used as the 'best' vertex in the classifier

Definition at line 610 of file SvmVertexSelectionAlgorithm.cc.

References AddVertexFeaturesToVector(), GetBestVertex(), max, and lar_content::LArMvaHelper::ProduceTrainingExample().

Referenced by ProduceTrainingSets().

 {
     const Vertex *pBestVertex(nullptr);
     float bestVertexDr(std::numeric_limits<float>::max());
 
     LArMvaHelper::MvaFeatureVector bestVertexFeatureList;
     this->GetBestVertex(vertexVector, pBestVertex, bestVertexDr);
 
     VertexFeatureInfo bestVertexFeatureInfo(vertexFeatureInfoMap.at(pBestVertex));
     this->AddVertexFeaturesToVector(bestVertexFeatureInfo, bestVertexFeatureList, useRPhi);
 
     for (const Vertex *const pVertex : vertexVector)
     {
         if (pVertex == pBestVertex)
             continue;
 
         LArMvaHelper::MvaFeatureVector featureList;
         VertexFeatureInfo vertexFeatureInfo(vertexFeatureInfoMap.at(pVertex));
         this->AddVertexFeaturesToVector(vertexFeatureInfo, featureList, useRPhi);
 
         if (pBestVertex && (bestVertexDr < maxRadius))
         {
             if (coinFlip(generator))
             {
                 LArMvaHelper::ProduceTrainingExample(trainingOutputFile + "_" + interactionType + ".txt", true, eventFeatureList,
                     bestVertexFeatureList, featureList);
             }
 
             else
             {
                 LArMvaHelper::ProduceTrainingExample(trainingOutputFile + "_" + interactionType + ".txt", false, eventFeatureList, featureList,
                     bestVertexFeatureList);
             }
         }
     }
 
     return pBestVertex;
 }

void lar_content::SvmVertexSelectionAlgorithm::ProduceTrainingSets	(	const pandora::VertexVector &	vertexVector,
		const pandora::VertexVector &	bestRegionVertices,
		VertexFeatureInfoMap &	vertexFeatureInfoMap,
		const LArMvaHelper::MvaFeatureVector &	eventFeatureList,
		const KDTreeMap &	kdTreeMap
	)		const

private

Produce the region and vertex training sets.

Parameters

vertexVector	the vector of all vertices
bestRegionVertices	the best region vertices
vertexFeatureInfoMap	the vertex feature info map
eventFeatureList	the list of event features
kdTreeMap

Definition at line 524 of file SvmVertexSelectionAlgorithm.cc.

References CalculateRPhiScores(), GetInteractionType(), m_maxTrueVertexRadius, m_regionRadius, m_trainingOutputFileRegion, m_trainingOutputFileVertex, m_useRPhiFeatureForRegion, and ProduceTrainingExamples().

Referenced by GetVertexScoreList().

 {
     if (vertexVector.empty())
         return;
 
     // Create a distribution for random coin flips.
     std::random_device device;
     std::mt19937 generator(device());
     std::bernoulli_distribution coinFlip(0.5);
 
     const std::string interactionType(this->GetInteractionType());
 
     // Produce training examples for the vertices representing regions.
     const Vertex *const pBestRegionVertex(this->ProduceTrainingExamples(bestRegionVertices, vertexFeatureInfoMap, coinFlip, generator,
         interactionType, m_trainingOutputFileRegion, eventFeatureList, m_regionRadius, m_useRPhiFeatureForRegion));
 
     // Get all the vertices in the best region.
     VertexVector regionalVertices{pBestRegionVertex};
     for (const Vertex *const pVertex : vertexVector)
     {
         if (pVertex == pBestRegionVertex)
             continue;
 
         if ((pBestRegionVertex->GetPosition() - pVertex->GetPosition()).GetMagnitude() < m_regionRadius)
             regionalVertices.push_back(pVertex);
     }
 
     this->CalculateRPhiScores(regionalVertices, vertexFeatureInfoMap, kdTreeMap);
 
     // Produce training examples for the final vertices within the best region.
     if (!regionalVertices.empty())
     {
         this->ProduceTrainingExamples(regionalVertices, vertexFeatureInfoMap, coinFlip, generator, interactionType, m_trainingOutputFileVertex,
             eventFeatureList, m_maxTrueVertexRadius, true);
     }
 }

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

protected

Definition at line 753 of file SvmVertexSelectionAlgorithm.cc.

References lar_content::LArMvaHelper::AddFeatureToolToVector(), lar_content::LArFileHelper::FindFileInPath(), lar_content::SupportVectorMachine::Initialize(), m_allowClassifyDuringTraining, m_beamDeweightingConstant, m_caloHitListName, m_dropFailedRPhiFastScoreCandidates, m_energyKickConstant, m_featureToolVector, m_filePathEnvironmentVariable, m_globalAsymmetryConstant, m_inputClusterListNames, m_localAsymmetryConstant, m_maxTrueVertexRadius, m_mcParticleListName, m_mcVertexXCorrection, m_minClusterCaloHits, m_minShowerClusterHits, m_minShowerSpineLength, m_regionRadius, m_regionSvmName, m_rPhiFineTuningRadius, m_showerAsymmetryConstant, m_showerClusteringDistance, m_slidingFitWindow, m_svMachineRegion, m_svMachineVertex, m_svmFileName, m_trainingOutputFileRegion, m_trainingOutputFileVertex, m_trainingSetMode, m_useRPhiFeatureForRegion, m_useShowerClusteringApproximation, m_vertexSvmName, and lar_content::VertexSelectionBaseAlgorithm::ReadSettings().

 {
     AlgorithmToolVector algorithmToolVector;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "FeatureTools", algorithmToolVector));
 
     for (AlgorithmTool *const pAlgorithmTool : algorithmToolVector)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArMvaHelper::AddFeatureToolToVector(pAlgorithmTool, m_featureToolVector));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "FilePathEnvironmentVariable", m_filePathEnvironmentVariable));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "SvmFileName", m_svmFileName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "RegionSvmName", m_regionSvmName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "VertexSvmName", m_vertexSvmName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "TrainingSetMode", m_trainingSetMode));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "AllowClassifyDuringTraining", m_allowClassifyDuringTraining));
 
     if ((!m_trainingSetMode || m_allowClassifyDuringTraining))
     {
         if (m_svmFileName.empty() || m_regionSvmName.empty() || m_vertexSvmName.empty())
         {
             std::cout << "SvmVertexSelectionAlgorithm: SvmFileName, RegionSvmName and VertexSvmName must be set if training set mode is" <<
                          "off or we allow classification during training" << std::endl;
             return STATUS_CODE_INVALID_PARAMETER;
         }
 
         const std::string fullSvmFileName(LArFileHelper::FindFileInPath(m_svmFileName, m_filePathEnvironmentVariable));
         m_svMachineRegion.Initialize(fullSvmFileName, m_regionSvmName);
         m_svMachineVertex.Initialize(fullSvmFileName, m_vertexSvmName);
     }
 
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MCVertexXCorrection", m_mcVertexXCorrection));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "TrainingOutputFileRegion", m_trainingOutputFileRegion));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "TrainingOutputFileVertex", m_trainingOutputFileVertex));
 
     if (m_trainingSetMode && (m_trainingOutputFileRegion.empty() || m_trainingOutputFileVertex.empty()))
     {
         std::cout << "SvmVertexSelectionAlgorithm: TrainingOutputFileRegion and TrainingOutputFileVertex are required for training set " <<
                      "mode" << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     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,
         "CaloHitListName", m_caloHitListName));
 
     if (m_trainingSetMode && (m_mcParticleListName.empty() || m_caloHitListName.empty()))
     {
         std::cout << "SvmVertexSelectionAlgorithm: MCParticleListName and CaloHitListName are required for training set mode" << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle,
         "InputClusterListNames", m_inputClusterListNames));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinClusterCaloHits", m_minClusterCaloHits));
 
     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,
         "MinShowerSpineLength", m_minShowerSpineLength));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "BeamDeweightingConstant", m_beamDeweightingConstant));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "LocalAsymmetryConstant", m_localAsymmetryConstant));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "GlobalAsymmetryConstant", m_globalAsymmetryConstant));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "ShowerAsymmetryConstant", m_showerAsymmetryConstant));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "EnergyKickConstant", m_energyKickConstant));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "ShowerClusteringDistance", m_showerClusteringDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinShowerClusterHits", m_minShowerClusterHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "UseShowerClusteringApproximation", m_useShowerClusteringApproximation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "RegionRadius", m_regionRadius));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "RPhiFineTuningRadius", m_rPhiFineTuningRadius));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MaxTrueVertexRadius", m_maxTrueVertexRadius));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "UseRPhiFeatureForRegion", m_useRPhiFeatureForRegion));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "DropFailedRPhiFastScoreCandidates", m_dropFailedRPhiFastScoreCandidates));
 
     return VertexSelectionBaseAlgorithm::ReadSettings(xmlHandle);
 }

void lar_content::SvmVertexSelectionAlgorithm::UpdateSpanCoordinate	(	const float	minPositionCoord,
		const float	maxPositionCoord,
		pandora::InputFloat &	minCoord,
		pandora::InputFloat &	maxCoord
	)		const

inlineprivate

Update the min/max coordinate spans.

Parameters

minPositionCoord	the min position coordinate
maxPositionCoord	the max position coordinate
minCoord	the current min coordinate
maxCoord	the current max coordinate

Definition at line 410 of file SvmVertexSelectionAlgorithm.cc.

Referenced by GetEventShapeFeatures().

 {
     if (!minCoord.IsInitialized() || minPositionCoord < minCoord.Get())
         minCoord = minPositionCoord;
 
     if (!maxCoord.IsInitialized() || maxPositionCoord > maxCoord.Get())
         maxCoord = maxPositionCoord;
 }

Member Data Documentation

bool lar_content::SvmVertexSelectionAlgorithm::m_allowClassifyDuringTraining

private

Whether classification is allowed during training.

Definition at line 388 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetVertexScoreList(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_beamDeweightingConstant

private

The beam deweighting constant for the initial region score list.

Definition at line 400 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateInitialScoreList(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_caloHitListName

private

The 2D CaloHit list name.

Definition at line 393 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetInteractionType(), and ReadSettings().

bool lar_content::SvmVertexSelectionAlgorithm::m_dropFailedRPhiFastScoreCandidates

private

Whether to drop candidates that fail the r/phi fast score test.

Definition at line 413 of file SvmVertexSelectionAlgorithm.h.

Referenced by CalculateRPhiScores(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_energyKickConstant

private

The energy kick constant for the initial region score list.

Definition at line 404 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateInitialScoreList(), and ReadSettings().

VertexFeatureTool::FeatureToolVector lar_content::SvmVertexSelectionAlgorithm::m_featureToolVector

private

The feature tool vector.

Definition at line 379 of file SvmVertexSelectionAlgorithm.h.

Referenced by CalculateRPhiScores(), PopulateVertexFeatureInfoMap(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_filePathEnvironmentVariable

private

The environment variable providing a list of paths to svm files.

Definition at line 380 of file SvmVertexSelectionAlgorithm.h.

Referenced by ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_globalAsymmetryConstant

private

The global asymmetry constant for the initial region score list.

Definition at line 402 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateInitialScoreList(), and ReadSettings().

pandora::StringVector lar_content::SvmVertexSelectionAlgorithm::m_inputClusterListNames

private

The list of cluster list names.

Definition at line 395 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetVertexScoreList(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_localAsymmetryConstant

private

The local asymmetry constant for the initial region score list.

Definition at line 401 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateInitialScoreList(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_maxTrueVertexRadius

private

The maximum distance at which a vertex candidate can be considered the 'true' vertex.

Definition at line 411 of file SvmVertexSelectionAlgorithm.h.

Referenced by ProduceTrainingSets(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_mcParticleListName

private

The MC particle list for creating training examples.

Definition at line 392 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetBestVertex(), GetInteractionType(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_mcVertexXCorrection

private

The correction to the x-coordinate of the MC vertex position.

Definition at line 389 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetBestVertex(), and ReadSettings().

unsigned int lar_content::SvmVertexSelectionAlgorithm::m_minClusterCaloHits

private

The min number of hits parameter in the energy score.

Definition at line 396 of file SvmVertexSelectionAlgorithm.h.

Referenced by CalculateShowerClusterList(), GetVertexScoreList(), and ReadSettings().

unsigned int lar_content::SvmVertexSelectionAlgorithm::m_minShowerClusterHits

private

The minimum number of shower cluster hits.

Definition at line 407 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetShowerLikeClusterEndPoints(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_minShowerSpineLength

private

The minimum length at which all are considered to be tracks.

Definition at line 398 of file SvmVertexSelectionAlgorithm.h.

Referenced by IsClusterShowerLike(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_regionRadius

private

The radius for a vertex region.

Definition at line 409 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetBestRegionVertices(), GetVertexScoreList(), ProduceTrainingSets(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_regionSvmName

private

The name of the region Svm to find.

Definition at line 382 of file SvmVertexSelectionAlgorithm.h.

Referenced by ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_rPhiFineTuningRadius

private

The maximum distance the r/phi tune can move a vertex.

Definition at line 410 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateFinalVertexScoreList(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_showerAsymmetryConstant

private

The shower asymmetry constant for the initial region score list.

Definition at line 403 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateInitialScoreList(), and ReadSettings().

float lar_content::SvmVertexSelectionAlgorithm::m_showerClusteringDistance

private

The shower clustering distance.

Definition at line 406 of file SvmVertexSelectionAlgorithm.h.

Referenced by PopulateKdTree(), and ReadSettings().

unsigned int lar_content::SvmVertexSelectionAlgorithm::m_slidingFitWindow

private

The layer window for the sliding linear fits.

Definition at line 397 of file SvmVertexSelectionAlgorithm.h.

Referenced by CalculateShowerClusterList(), GetVertexScoreList(), and ReadSettings().

SupportVectorMachine lar_content::SvmVertexSelectionAlgorithm::m_svMachineRegion

private

The region support vector machine.

Definition at line 384 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetVertexScoreList(), and ReadSettings().

SupportVectorMachine lar_content::SvmVertexSelectionAlgorithm::m_svMachineVertex

private

The vertex support vector machine.

Definition at line 385 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetVertexScoreList(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_svmFileName

private

The Svm file name.

Definition at line 381 of file SvmVertexSelectionAlgorithm.h.

Referenced by ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_trainingOutputFileRegion

private

The training output file for the region Svm.

Definition at line 390 of file SvmVertexSelectionAlgorithm.h.

Referenced by ProduceTrainingSets(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_trainingOutputFileVertex

private

The training output file for the vertex Svm.

Definition at line 391 of file SvmVertexSelectionAlgorithm.h.

Referenced by ProduceTrainingSets(), and ReadSettings().

bool lar_content::SvmVertexSelectionAlgorithm::m_trainingSetMode

private

Whether to train.

Definition at line 387 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetVertexScoreList(), and ReadSettings().

bool lar_content::SvmVertexSelectionAlgorithm::m_useRPhiFeatureForRegion

private

Whether to use the r/phi feature for the region vertex.

Definition at line 412 of file SvmVertexSelectionAlgorithm.h.

Referenced by GetVertexScoreList(), ProduceTrainingSets(), and ReadSettings().

bool lar_content::SvmVertexSelectionAlgorithm::m_useShowerClusteringApproximation

private

Whether to use the shower clustering distance approximation.

Definition at line 408 of file SvmVertexSelectionAlgorithm.h.

Referenced by CalculateShowerClusterList(), and ReadSettings().

std::string lar_content::SvmVertexSelectionAlgorithm::m_vertexSvmName

private

The name of the vertex Svm to find.

Definition at line 383 of file SvmVertexSelectionAlgorithm.h.

Referenced by ReadSettings().

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

larpandoracontent/v03_13_02/source/larpandoracontent/LArVertex/SvmVertexSelectionAlgorithm.h
larpandoracontent/v03_13_02/source/larpandoracontent/LArVertex/SvmVertexSelectionAlgorithm.cc

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation