lar_content::TrainedVertexSelectionAlgorithm Class Reference

TrainedVertexSelectionAlgorithm class. More...

#include <TrainedVertexSelectionAlgorithm.h>

Inheritance diagram for lar_content::TrainedVertexSelectionAlgorithm:

Classes
class	EventFeatureInfo
	Event feature info class. More...
class	VertexFeatureInfo
	Vertex feature info class. More...
class	VertexSharedFeatureInfo
	Shared vertex feature info class. More...

Public Types
typedef std::map< const pandora::Vertex *const, VertexFeatureInfo >	VertexFeatureInfoMap
Public Types inherited from lar_content::VertexSelectionBaseAlgorithm
typedef std::vector< VertexScore >	VertexScoreList
typedef std::vector < SlidingFitData >	SlidingFitDataList
typedef std::vector < ShowerCluster >	ShowerClusterList
typedef KDTreeNodeInfoT< const pandora::CaloHit *, 2 >	HitKDNode2D
typedef std::vector< HitKDNode2D >	HitKDNode2DList
typedef KDTreeLinkerAlgo < const pandora::CaloHit *, 2 >	HitKDTree2D
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
	TrainedVertexSelectionAlgorithm ()
	Default constructor. More...
Public Member Functions inherited from lar_content::VertexSelectionBaseAlgorithm
	VertexSelectionBaseAlgorithm ()
	Default constructor. More...

Protected 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

Protected Member Functions
virtual void	GetVertexScoreList (const pandora::VertexVector &vertexVector, const BeamConstants &beamConstants, HitKDTree2D &kdTreeU, HitKDTree2D &kdTreeV, HitKDTree2D &kdTreeW, VertexScoreList &vertexScoreList) const =0
	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	GetLegacyEventShapeFeatures (const pandora::ClusterList &clusterList, float &eventVolume, float &longitudinality) const
	Get the event shape features. More...
void	GetEventShapeFeatures (const ClusterListMap &clusterListMap, float &eventArea, float &longitudinality) const
	Get the event shape features. More...
void	Get2DSpan (const pandora::ClusterList &clusterList, float &xSpan, float &zSpan) const
	Get the coordinate span in one view. 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 KDTreeMap &kdTreeMap, 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	GetSharedFeatures (const pandora::Vertex *const pVertex1, const pandora::Vertex *const pVertex2, const KDTreeMap &kdTreeMap, float &separation, float &axisHits) const
	Calculates the shared features of a pair of vertex candidates. More...
void	IncrementSharedAxisValues (const pandora::CartesianVector pos1, const pandora::CartesianVector pos2, HitKDTree2D &kdTree, float &axisHits) const
	Increments the axis hits information for one view. More...
bool	IsHitInBox (const pandora::CartesianVector &hitPos, const pandora::CartesianVector &point1, const pandora::CartesianVector &point2, const pandora::CartesianVector &point3, const pandora::CartesianVector &point4) const
	Determines whether a hit lies within the box defined by four other positions. 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...
void	AddSharedFeaturesToVector (const VertexSharedFeatureInfo &vertexSharedFeatureInfo, LArMvaHelper::MvaFeatureVector &featureVector) const
	Add the shared features to a vector in the correct order. 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...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
Protected Member Functions inherited from lar_content::VertexSelectionBaseAlgorithm
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...
float	GetVertexEnergy (const pandora::Vertex *const pVertex, const KDTreeMap &kdTreeMap) const
	Calculate the energy of a vertex candidate by summing values from all three planes. More...
float	VertexHitEnergy (const pandora::Vertex *const pVertex, const pandora::HitType hitType, HitKDTree2D &kdTree) const
	Finds the energy of the nearest hit to the vertex candidate in this view. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Protected Attributes
VertexFeatureTool::FeatureToolVector	m_featureToolVector
	The feature tool vector. 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 mva. More...
std::string	m_trainingOutputFileVertex
	The training output file for the vertex mva. 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...
bool	m_testBeamMode
	Test beam mode. More...
bool	m_legacyEventShapes
	Whether to use the old event shapes calculation. More...
bool	m_legacyVariables
	Whether to only use the old variables. More...

Detailed Description

TrainedVertexSelectionAlgorithm class.

Definition at line 36 of file TrainedVertexSelectionAlgorithm.h.

Member Typedef Documentation

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

protected

Definition at line 131 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 132 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 133 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 168 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 169 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 167 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 171 of file TrainedVertexSelectionAlgorithm.h.

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

protected

Definition at line 134 of file TrainedVertexSelectionAlgorithm.h.

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

Definition at line 70 of file TrainedVertexSelectionAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TrainedVertexSelectionAlgorithm::TrainedVertexSelectionAlgorithm

(

)

Default constructor.

Definition at line 36 of file TrainedVertexSelectionAlgorithm.cc.

                                                                 :
    VertexSelectionBaseAlgorithm(),
    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),
    m_testBeamMode(false),
    m_legacyEventShapes(true),
    m_legacyVariables(true)
{
}

Member Function Documentation

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

protected

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

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

protected

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::TrainedVertexSelectionAlgorithm::AddEventFeaturesToVector ( const EventFeatureInfo &  eventFeatureInfo, LArMvaHelper::MvaFeatureVector &  featureVector  ) const

protected

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 412 of file TrainedVertexSelectionAlgorithm.cc.

{
    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_eventArea));
    featureVector.push_back(static_cast<double>(eventFeatureInfo.m_longitudinality));
    if (this->IsBeamModeOn())
    {
        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::TrainedVertexSelectionAlgorithm::AddSharedFeaturesToVector ( const VertexSharedFeatureInfo &  vertexSharedFeatureInfo, LArMvaHelper::MvaFeatureVector &  featureVector  ) const

protected

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

Parameters

vertexSharedFeatureInfo	the shared vertex feature info
featureVector	the vector of floats to append

Definition at line 829 of file TrainedVertexSelectionAlgorithm.cc.

{
    featureVector.push_back(static_cast<double>(vertexSharedFeatureInfo.m_separation));
    featureVector.push_back(static_cast<double>(vertexSharedFeatureInfo.m_axisHits));
}

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

protected

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 807 of file TrainedVertexSelectionAlgorithm.cc.

{
    if (this->IsBeamModeOn())
        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 (!m_legacyVariables)
    {
        featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_dEdxAsymmetry));
        featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_vertexEnergy));
    }

    if (useRPhi)
        featureVector.push_back(static_cast<double>(vertexFeatureInfo.m_rPhiFeature));
}

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

protected

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 240 of file TrainedVertexSelectionAlgorithm.cc.

{
    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());

    const ClusterListMap clusterListMap{{TPC_VIEW_U, clusterListU}, {TPC_VIEW_V, clusterListV}, {TPC_VIEW_W, clusterListW}};

    float eventArea(0.f), longitudinality(0.f);
    if (m_legacyEventShapes)
        this->GetLegacyEventShapeFeatures(allClusters, eventArea, longitudinality);
    else
        this->GetEventShapeFeatures(clusterListMap, eventArea, longitudinality);

    return EventFeatureInfo(eventShoweryness, eventEnergy, eventArea, longitudinality, nHits, nClusters, vertexVector.size());
}

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

protected

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 571 of file TrainedVertexSelectionAlgorithm.cc.

{
    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::TrainedVertexSelectionAlgorithm::CalculateShowerClusterList ( const pandora::ClusterList &  inputClusterList, ShowerClusterList &  showerClusterList  ) const

protected

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 65 of file TrainedVertexSelectionAlgorithm.cc.

{
    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);
    }
}

void lar_content::TrainedVertexSelectionAlgorithm::Get2DSpan ( const pandora::ClusterList &  clusterList, float &  xSpan, float &  zSpan  ) const

protected

Get the coordinate span in one view.

Parameters

clusterList	the cluster list in one view
xSpan	the coordinate span in the drift direction
zSpan	the coordinate span in the wire direction

Definition at line 352 of file TrainedVertexSelectionAlgorithm.cc.

{
    FloatVector xPositions, zPositions;

    for (const Cluster *const pCluster : clusterList)
    {
        const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

        for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
        {
            for (CaloHitList::const_iterator hitIter = iter->second->begin(), hitIterEnd = iter->second->end(); hitIter != hitIterEnd; ++hitIter)
            {
                xPositions.push_back((*hitIter)->GetPositionVector().GetX());
                zPositions.push_back((*hitIter)->GetPositionVector().GetZ());
            }
        }
    }

    std::sort(xPositions.begin(), xPositions.end());
    std::sort(zPositions.begin(), zPositions.end());

    if (xPositions.empty())
    {
        xSpan = 0;
        zSpan = 0;
    }
    else
    {
        const int low = std::round(0.05 * xPositions.size());
        const int high = std::round(0.95 * xPositions.size()) - 1;

        xSpan = xPositions[high] - xPositions[low];
        zSpan = zPositions[high] - zPositions[low];
    }
}

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

protected

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 498 of file TrainedVertexSelectionAlgorithm.cc.

{
    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::TrainedVertexSelectionAlgorithm::GetBestVertex ( const pandora::VertexVector &  vertexVector, const pandora::Vertex *&  pBestVertex, float &  bestVertexDr  ) const

protected

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 764 of file TrainedVertexSelectionAlgorithm.cc.

{
    // Extract input collections
    const MCParticleList *pMCParticleList(nullptr);
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));

    // Obtain vector: true targets
    MCParticleVector mcTargetVector;

    if (m_testBeamMode)
    {
        LArMCParticleHelper::GetTrueTestBeamParticles(pMCParticleList, mcTargetVector);
    }
    else
    {
        LArMCParticleHelper::GetTrueNeutrinos(pMCParticleList, mcTargetVector);
    }

    for (const Vertex *const pVertex : vertexVector)
    {
        float mcVertexDr(std::numeric_limits<float>::max());
        for (const MCParticle *const pMCTarget : mcTargetVector)
        {
            const CartesianVector &mcTargetPosition(
                (m_testBeamMode && std::fabs(pMCTarget->GetParticleId()) == 11) ? pMCTarget->GetVertex() : pMCTarget->GetEndpoint());
            const CartesianVector mcTargetCorrectedPosition(
                mcTargetPosition.GetX() + m_mcVertexXCorrection, mcTargetPosition.GetY(), mcTargetPosition.GetZ());
            const float dr = (mcTargetCorrectedPosition - pVertex->GetPosition()).GetMagnitude();

            if (dr < mcVertexDr)
                mcVertexDr = dr;
        }

        if (mcVertexDr < bestVertexDr)
        {
            bestVertexDr = mcVertexDr;
            pBestVertex = pVertex;
        }
    }
}

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

inlineprotected

Get the coordinate span.

Parameters

minCoord	the min coordinate
maxCoord	the max coordinate

Returns

the coordinate span

Definition at line 402 of file TrainedVertexSelectionAlgorithm.cc.

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

    return 0.f;
}

void lar_content::TrainedVertexSelectionAlgorithm::GetEventShapeFeatures ( const ClusterListMap &  clusterListMap, float &  eventArea, float &  longitudinality  ) const

protected

Get the event shape features.

Parameters

clusterList	the map of cluster lists for each view
eventArea	the event area
longitudinality	the event longitudinality

Definition at line 332 of file TrainedVertexSelectionAlgorithm.cc.

{
    float xSpanU(0.f), zSpanU(0.f), xSpanV(0.f), zSpanV(0.f), xSpanW(0.f), zSpanW(0.f);

    this->Get2DSpan(clusterListMap.at(TPC_VIEW_U), xSpanU, zSpanU);
    this->Get2DSpan(clusterListMap.at(TPC_VIEW_V), xSpanV, zSpanV);
    this->Get2DSpan(clusterListMap.at(TPC_VIEW_W), xSpanW, zSpanW);

    const float xSpan = (xSpanU + xSpanV + xSpanW) / 3.f;
    const float zSpan = (zSpanU + zSpanV + zSpanW) / 3.f;

    if ((xSpan > std::numeric_limits<float>::epsilon()) && (zSpan > std::numeric_limits<float>::epsilon()))
    {
        eventArea = xSpan * zSpan;
        longitudinality = zSpan / (xSpan + zSpan);
    }
}

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

protected

Get the interaction type string.

Returns

the interaction type string

Definition at line 594 of file TrainedVertexSelectionAlgorithm.cc.

{
    // 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));

    LArMCParticleHelper::MCContributionMap targetMCParticlesToGoodHitsMap;

    if (m_testBeamMode)
    {
        LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, LArMCParticleHelper::PrimaryParameters(),
            LArMCParticleHelper::IsTriggeredBeamParticle, targetMCParticlesToGoodHitsMap);
    }
    else
    {
        // ATTN Assumes single neutrino is parent of all neutrino-induced mc particles
        LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, LArMCParticleHelper::PrimaryParameters(),
            LArMCParticleHelper::IsBeamNeutrinoFinalState, targetMCParticlesToGoodHitsMap);
    }

    MCParticleList mcPrimaryList;
    for (const auto &mapEntry : targetMCParticlesToGoodHitsMap)
        mcPrimaryList.push_back(mapEntry.first);
    mcPrimaryList.sort(LArMCParticleHelper::SortByMomentum);

    const LArInteractionTypeHelper::InteractionType interactionType(LArInteractionTypeHelper::GetInteractionType(mcPrimaryList));
    return LArInteractionTypeHelper::ToString(interactionType);
}

void lar_content::TrainedVertexSelectionAlgorithm::GetLegacyEventShapeFeatures ( const pandora::ClusterList &  clusterList, float &  eventVolume, float &  longitudinality  ) const

protected

Get the event shape features.

Parameters

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

Definition at line 292 of file TrainedVertexSelectionAlgorithm.cc.

{
    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);
    }
}

void lar_content::TrainedVertexSelectionAlgorithm::GetSharedFeatures ( const pandora::Vertex *const  pVertex1, const pandora::Vertex *const  pVertex2, const KDTreeMap &  kdTreeMap, float &  separation, float &  axisHits  ) const

protected

Calculates the shared features of a pair of vertex candidates.

Parameters

pVertex1	the address of the first vertex
pVertex2	the address of the second vertex
kdTreeMap	the map of 2D hit kd trees
separation	the 3D distance between the two vertex candidates
axisHits	the number of hits between the two candidates normalised to the distance between them

Definition at line 688 of file TrainedVertexSelectionAlgorithm.cc.

{
    separation = (pVertex1->GetPosition() - pVertex2->GetPosition()).GetMagnitude();

    this->IncrementSharedAxisValues(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex1->GetPosition(), TPC_VIEW_U),
        LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex2->GetPosition(), TPC_VIEW_U), kdTreeMap.at(TPC_VIEW_U), axisHits);

    this->IncrementSharedAxisValues(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex1->GetPosition(), TPC_VIEW_V),
        LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex2->GetPosition(), TPC_VIEW_V), kdTreeMap.at(TPC_VIEW_V), axisHits);

    this->IncrementSharedAxisValues(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex1->GetPosition(), TPC_VIEW_W),
        LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex2->GetPosition(), TPC_VIEW_W), kdTreeMap.at(TPC_VIEW_W), axisHits);

    axisHits = separation > std::numeric_limits<float>::epsilon() ? axisHits / separation : 0.f;
}

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

protected

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 119 of file TrainedVertexSelectionAlgorithm.cc.

{
    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);
    }
}

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

protectedpure virtual

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.

Implemented in lar_content::MvaVertexSelectionAlgorithm< T >, and lar_content::CheatingVertexSelectionAlgorithm.

void lar_content::TrainedVertexSelectionAlgorithm::IncrementSharedAxisValues ( const pandora::CartesianVector  pos1, const pandora::CartesianVector  pos2, HitKDTree2D &  kdTree, float &  axisHits  ) const

protected

Increments the axis hits information for one view.

Parameters

pos1	2D projected position of the first vertex
pos2	2D projected position of the second vertex
kdTree	the kd tree of 2D hits
axisHits	the number of hits between the two candidates

Definition at line 707 of file TrainedVertexSelectionAlgorithm.cc.

{
    if (pos1 == pos2)
        return;

    // Define the axis and perpendicular directions
    const CartesianVector unitAxis = (pos1 - pos2).GetUnitVector();
    const CartesianVector unitPerp(unitAxis.GetZ(), 0, -unitAxis.GetX());

    // Define the corners of the search box
    const CartesianVector point1 = pos1 + unitPerp;
    const CartesianVector point2 = pos1 - unitPerp;
    const CartesianVector point3 = pos2 + unitPerp;
    const CartesianVector point4 = pos2 - unitPerp;

    // Find the total coordinate span these points cover
    const float xMin{std::min({point1.GetX(), point2.GetX(), point3.GetX(), point4.GetX()})};
    const float xMax{std::max({point1.GetX(), point2.GetX(), point3.GetX(), point4.GetX()})};
    const float zMin{std::min({point1.GetZ(), point2.GetZ(), point3.GetZ(), point4.GetZ()})};
    const float zMax{std::max({point1.GetZ(), point2.GetZ(), point3.GetZ(), point4.GetZ()})};

    // Use a kd search to find the hits in the 'wide' area
    KDTreeBox searchBox(xMin, zMin, xMax, zMax);
    HitKDNode2DList found;
    kdTree.search(searchBox, found);

    // Use IsHitInBox method to check the 'wide' area hits for those in the search box
    for (auto f : found)
    {
        const CartesianVector &hitPos = f.data->GetPositionVector();
        bool inBox = this->IsHitInBox(hitPos, point1, point2, point3, point4);

        if (inBox)
            ++axisHits;
    }
}

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

protected

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 270 of file TrainedVertexSelectionAlgorithm.cc.

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

        eventEnergy += pCluster->GetElectromagneticEnergy();
        nHits += pCluster->GetNCaloHits();
    }
}

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

inlineprotected

Find whether a cluster is shower-like.

Parameters

pCluster

the cluster

Returns

boolean

Definition at line 285 of file TrainedVertexSelectionAlgorithm.cc.

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

bool lar_content::TrainedVertexSelectionAlgorithm::IsHitInBox ( const pandora::CartesianVector &  hitPos, const pandora::CartesianVector &  point1, const pandora::CartesianVector &  point2, const pandora::CartesianVector &  point3, const pandora::CartesianVector &  point4  ) const

protected

Determines whether a hit lies within the box defined by four other positions.

Parameters

hitPos	the hit position
point1	the first corner of the box
point2	the second corner of the box
point3	the third corner of the box
point4	the fourth corner of the box

Returns

boolean

Definition at line 747 of file TrainedVertexSelectionAlgorithm.cc.

{
    bool b1 = std::signbit(((point2 - point1).GetCrossProduct(point2 - hitPos)).GetY());
    bool b2 = std::signbit(((point4 - point3).GetCrossProduct(point4 - hitPos)).GetY());

    if (!(b1 xor b2))
        return false;

    bool b3 = std::signbit(((point3 - point1).GetCrossProduct(point3 - hitPos)).GetY());
    bool b4 = std::signbit(((point4 - point2).GetCrossProduct(point4 - hitPos)).GetY());

    return (b3 xor b4);
}

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

protected

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 838 of file TrainedVertexSelectionAlgorithm.cc.

{
    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::TrainedVertexSelectionAlgorithm::PopulateInitialScoreList ( VertexFeatureInfoMap &  vertexFeatureInfoMap, const pandora::Vertex *const  pVertex, VertexScoreList &  initialScoreList  ) const

protected

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 482 of file TrainedVertexSelectionAlgorithm.cc.

{
    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::TrainedVertexSelectionAlgorithm::PopulateKdTree ( const pandora::ClusterList &  clusterList, HitKDTree2D &  kdTree, HitToClusterMap &  hitToClusterMap  ) const

protected

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 146 of file TrainedVertexSelectionAlgorithm.cc.

{
    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::TrainedVertexSelectionAlgorithm::PopulateVertexFeatureInfoMap ( const BeamConstants &  beamConstants, const ClusterListMap &  clusterListMap, const SlidingFitDataListMap &  slidingFitDataListMap, const ShowerClusterListMap &  showerClusterListMap, const KDTreeMap &  kdTreeMap, const pandora::Vertex *const  pVertex, VertexFeatureInfoMap &  vertexFeatureInfoMap  ) const

protected

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 428 of file TrainedVertexSelectionAlgorithm.cc.

{
    float bestFastScore(-std::numeric_limits<float>::max()); // not actually used - artefact of toolizing RPhi score and still using performance trick

    // ATTN - If beam mode is false GetBeamDeweightingScore will fail, so have a default value that we'll ignore when poplating the feature vector
    double tempBeamDeweight{0.f};
    if (this->IsBeamModeOn())
        tempBeamDeweight = this->GetBeamDeweightingScore(beamConstants, pVertex);

    const double beamDeweighting(tempBeamDeweight);

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

    double dEdxAsymmetry(0.f), vertexEnergy(0.f);

    if (!m_legacyVariables)
    {
        dEdxAsymmetry = LArMvaHelper::CalculateFeaturesOfType<EnergyDepositionAsymmetryFeatureTool>(m_featureToolVector, this, pVertex,
            slidingFitDataListMap, clusterListMap, kdTreeMap, showerClusterListMap, beamDeweighting, bestFastScore)
                            .at(0)
                            .Get();

        vertexEnergy = this->GetVertexEnergy(pVertex, kdTreeMap);
    }

    VertexFeatureInfo vertexFeatureInfo(beamDeweighting, 0.f, energyKick, localAsymmetry, globalAsymmetry, showerAsymmetry, dEdxAsymmetry, vertexEnergy);
    vertexFeatureInfoMap.emplace(pVertex, vertexFeatureInfo);
}

const pandora::Vertex * lar_content::TrainedVertexSelectionAlgorithm::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 KDTreeMap &  kdTreeMap, const float  maxRadius, const bool  useRPhi  ) const

protected

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
kdTreeMap	the map of 2D hit kd trees
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 628 of file TrainedVertexSelectionAlgorithm.cc.

{
    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 (!m_legacyVariables)
        {
            LArMvaHelper::MvaFeatureVector sharedFeatureList;
            float separation(0.f), axisHits(0.f);
            this->GetSharedFeatures(pVertex, pBestVertex, kdTreeMap, separation, axisHits);
            VertexSharedFeatureInfo sharedFeatureInfo(separation, axisHits);
            this->AddSharedFeaturesToVector(sharedFeatureInfo, sharedFeatureList);

            if (pBestVertex && (bestVertexDr < maxRadius))
            {
                if (coinFlip(generator))
                    LArMvaHelper::ProduceTrainingExample(trainingOutputFile + "_" + interactionType + ".txt", true,
                        LArMvaHelper::ConcatenateFeatureLists(eventFeatureList, bestVertexFeatureList, featureList, sharedFeatureList));
                else
                    LArMvaHelper::ProduceTrainingExample(trainingOutputFile + "_" + interactionType + ".txt", false,
                        LArMvaHelper::ConcatenateFeatureLists(eventFeatureList, featureList, bestVertexFeatureList, sharedFeatureList));
            }
        }
        else
        {
            if (pBestVertex && (bestVertexDr < maxRadius))
            {
                if (coinFlip(generator))
                    LArMvaHelper::ProduceTrainingExample(trainingOutputFile + "_" + interactionType + ".txt", true,
                        LArMvaHelper::ConcatenateFeatureLists(eventFeatureList, bestVertexFeatureList, featureList));
                else
                    LArMvaHelper::ProduceTrainingExample(trainingOutputFile + "_" + interactionType + ".txt", false,
                        LArMvaHelper::ConcatenateFeatureLists(eventFeatureList, featureList, bestVertexFeatureList));
            }
        }
    }

    return pBestVertex;
}

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

protected

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 531 of file TrainedVertexSelectionAlgorithm.cc.

{
    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, kdTreeMap, 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, kdTreeMap, m_maxTrueVertexRadius, true);
    }
}

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

protected

Definition at line 859 of file TrainedVertexSelectionAlgorithm.cc.

{
    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, "TrainingSetMode", m_trainingSetMode));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "AllowClassifyDuringTraining", m_allowClassifyDuringTraining));

    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 << "TrainedVertexSelectionAlgorithm: 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 << "TrainedVertexSelectionAlgorithm: 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));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TestBeamMode", m_testBeamMode));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "LegacyEventShapes", m_legacyEventShapes));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "LegacyVariables", m_legacyVariables));

    if (m_trainingSetMode && m_legacyEventShapes)
        std::cout << "TrainedVertexSelectionAlgorithm: WARNING -- Producing training sample using incorrect legacy event shapes, consider turning LegacyEventShapes off"
                  << std::endl;

    return VertexSelectionBaseAlgorithm::ReadSettings(xmlHandle);
}

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

inlineprotected

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 390 of file TrainedVertexSelectionAlgorithm.cc.

{
    if (!minCoord.IsInitialized() || minPositionCoord < minCoord.Get())
        minCoord = minPositionCoord;

    if (!maxCoord.IsInitialized() || maxPositionCoord > maxCoord.Get())
        maxCoord = maxPositionCoord;
}

Member Data Documentation

bool lar_content::TrainedVertexSelectionAlgorithm::m_allowClassifyDuringTraining

protected

Whether classification is allowed during training.

Definition at line 454 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_beamDeweightingConstant

protected

The beam deweighting constant for the initial region score list.

Definition at line 466 of file TrainedVertexSelectionAlgorithm.h.

std::string lar_content::TrainedVertexSelectionAlgorithm::m_caloHitListName

protected

The 2D CaloHit list name.

Definition at line 459 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_dropFailedRPhiFastScoreCandidates

protected

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

Definition at line 479 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_energyKickConstant

protected

The energy kick constant for the initial region score list.

Definition at line 470 of file TrainedVertexSelectionAlgorithm.h.

VertexFeatureTool::FeatureToolVector lar_content::TrainedVertexSelectionAlgorithm::m_featureToolVector

protected

The feature tool vector.

Definition at line 452 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_globalAsymmetryConstant

protected

The global asymmetry constant for the initial region score list.

Definition at line 468 of file TrainedVertexSelectionAlgorithm.h.

pandora::StringVector lar_content::TrainedVertexSelectionAlgorithm::m_inputClusterListNames

protected

The list of cluster list names.

Definition at line 461 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_legacyEventShapes

protected

Whether to use the old event shapes calculation.

Definition at line 481 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_legacyVariables

protected

Whether to only use the old variables.

Definition at line 482 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_localAsymmetryConstant

protected

The local asymmetry constant for the initial region score list.

Definition at line 467 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_maxTrueVertexRadius

protected

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

Definition at line 477 of file TrainedVertexSelectionAlgorithm.h.

std::string lar_content::TrainedVertexSelectionAlgorithm::m_mcParticleListName

protected

The MC particle list for creating training examples.

Definition at line 458 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_mcVertexXCorrection

protected

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

Definition at line 455 of file TrainedVertexSelectionAlgorithm.h.

unsigned int lar_content::TrainedVertexSelectionAlgorithm::m_minClusterCaloHits

protected

The min number of hits parameter in the energy score.

Definition at line 462 of file TrainedVertexSelectionAlgorithm.h.

unsigned int lar_content::TrainedVertexSelectionAlgorithm::m_minShowerClusterHits

protected

The minimum number of shower cluster hits.

Definition at line 473 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_minShowerSpineLength

protected

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

Definition at line 464 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_regionRadius

protected

The radius for a vertex region.

Definition at line 475 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_rPhiFineTuningRadius

protected

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

Definition at line 476 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_showerAsymmetryConstant

protected

The shower asymmetry constant for the initial region score list.

Definition at line 469 of file TrainedVertexSelectionAlgorithm.h.

float lar_content::TrainedVertexSelectionAlgorithm::m_showerClusteringDistance

protected

The shower clustering distance.

Definition at line 472 of file TrainedVertexSelectionAlgorithm.h.

unsigned int lar_content::TrainedVertexSelectionAlgorithm::m_slidingFitWindow

protected

The layer window for the sliding linear fits.

Definition at line 463 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_testBeamMode

protected

Test beam mode.

Definition at line 480 of file TrainedVertexSelectionAlgorithm.h.

std::string lar_content::TrainedVertexSelectionAlgorithm::m_trainingOutputFileRegion

protected

The training output file for the region mva.

Definition at line 456 of file TrainedVertexSelectionAlgorithm.h.

std::string lar_content::TrainedVertexSelectionAlgorithm::m_trainingOutputFileVertex

protected

The training output file for the vertex mva.

Definition at line 457 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_trainingSetMode

protected

Whether to train.

Definition at line 453 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_useRPhiFeatureForRegion

protected

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

Definition at line 478 of file TrainedVertexSelectionAlgorithm.h.

bool lar_content::TrainedVertexSelectionAlgorithm::m_useShowerClusteringApproximation

protected

Whether to use the shower clustering distance approximation.

Definition at line 474 of file TrainedVertexSelectionAlgorithm.h.

---

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

• TrainedVertexSelectionAlgorithm.h
• TrainedVertexSelectionAlgorithm.cc