DeepLearningTrackShowerIdAlgorithm class. More...

#include "DlSecondaryVertexingAlgorithm.h"

Inheritance diagram for lar_dl_content::DlSecondaryVertexingAlgorithm:

Classes
class	Canvas

Public Types
typedef std::map< std::pair< int, int >, std::vector< const pandora::CaloHit * > >	PixelToCaloHitsMap

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

	~DlSecondaryVertexingAlgorithm ()

Protected Types
typedef std::pair< int, int >	Pixel

typedef std::vector< Pixel >	PixelVector

Protected Member Functions
void	GetHitRegion (const pandora::CaloHitList &caloHitList, float &xMin, float &xMax, float &zMin, float &zMax) const

void	GetCanvasParameters (const LArDLHelper::TorchOutput &networkOutput, const PixelVector &pixelVector, int &columnOffset, int &rowOffset, int &width, int &height) const
	Determines the parameters of the canvas for extracting the vertex location. The network predicts the distance that each pixel associated with a hit is located from the vertex, but says nothing about the direction. As a result, the ring describing the potential vertices associated with that hit can extend beyond the original canvas size. This function returns the size of the required canvas and the offset for the bottom left corner. More...

Protected Attributes
bool	m_trainingMode
	Training mode. More...

std::string	m_trainingOutputFile
	Output file name for training examples. More...

std::string	m_inputVertexListName
	Input vertex list name if 2nd pass. More...

std::string	m_outputVertexListName
	Output vertex list name. More...

pandora::StringVector	m_caloHitListNames
	Names of input calo hit lists. More...

LArDLHelper::TorchModel	m_modelU
	The model for the U view. More...

LArDLHelper::TorchModel	m_modelV
	The model for the V view. More...

LArDLHelper::TorchModel	m_modelW
	The model for the W view. More...

int	m_pass
	The pass of the train/infer step. More...

int	m_nClasses
	The number of distance classes. More...

int	m_height
	The height of the images. More...

int	m_width
	The width of the images. More...

float	m_driftStep
	The size of a pixel in the drift direction in cm (most relevant in pass 2) More...

std::vector< double >	m_thresholds
	Distance class thresholds. More...

std::string	m_volumeType
	The name of the fiducial volume type for the monitoring output. More...

Private Types
typedef std::map< pandora::HitType, Canvas * >	CanvasViewMap

Private Member Functions
pandora::StatusCode	Run ()

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

pandora::StatusCode	PrepareTrainingSample ()

pandora::StatusCode	Infer ()

pandora::StatusCode	MakeNetworkInputFromHits (const pandora::CaloHitList &caloHits, const pandora::HitType view, const float xMin, const float xMax, const float zMin, const float zMax, LArDLHelper::TorchInput &networkInput, PixelVector &pixelVector) const

pandora::StatusCode	GetNetworkVertices (const CanvasViewMap &canvases, pandora::CartesianPointVector &positionVector) const

pandora::StatusCode	GetVerticesFromCanvas (const Canvas &canvas, pandora::CartesianPointVector &vertices) const

bool	GrowPeak (const Canvas &canvas, int col, int row, float intensity, std::vector< std::pair< int, int >> &peak) const
	Determine if the pixel under consideration is part of a peak and grow that peak to include all connected pixels of equal value. More...

pandora::StatusCode	MakeCandidateVertexList (const pandora::CartesianPointVector &positions)
	Create a vertex list from the candidate vertices. More...

Private Attributes
int	m_event
	The current event number. More...

bool	m_visualise
	Whether or not to visualise the candidate vertices. More...

bool	m_writeTree
	Whether or not to write validation details to a ROOT tree. More...

std::string	m_rootTreeName
	The ROOT tree name. More...

std::string	m_rootFileName
	The ROOT file name. More...

std::mt19937	m_rng
	The random number generator. More...

Detailed Description

DeepLearningTrackShowerIdAlgorithm class.

Definition at line 28 of file DlSecondaryVertexingAlgorithm.h.

Member Typedef Documentation

typedef std::map<pandora::HitType, Canvas *> lar_dl_content::DlSecondaryVertexingAlgorithm::CanvasViewMap

private

Definition at line 63 of file DlSecondaryVertexingAlgorithm.h.

typedef std::pair<int, int> lar_dl_content::DlVertexingBaseAlgorithm::Pixel

protectedinherited

Definition at line 41 of file DlVertexingBaseAlgorithm.h.

typedef std::map<std::pair<int, int>, std::vector<const pandora::CaloHit *> > lar_dl_content::DlVertexingBaseAlgorithm::PixelToCaloHitsMap

inherited

Definition at line 31 of file DlVertexingBaseAlgorithm.h.

typedef std::vector<Pixel> lar_dl_content::DlVertexingBaseAlgorithm::PixelVector

protectedinherited

Definition at line 42 of file DlVertexingBaseAlgorithm.h.

Constructor & Destructor Documentation

lar_dl_content::DlSecondaryVertexingAlgorithm::DlSecondaryVertexingAlgorithm ( )

Default constructor.

Definition at line 33 of file DlSecondaryVertexingAlgorithm.cc.

References m_rng, m_visualise, and m_writeTree.

                                                              :
     m_event{-1},
     m_visualise{false},
     m_writeTree{false},
     m_rng(static_cast<std::mt19937::result_type>(std::chrono::high_resolution_clock::now().time_since_epoch().count()))
 {
 }

lar_dl_content::DlSecondaryVertexingAlgorithm::~DlSecondaryVertexingAlgorithm ( )

Definition at line 41 of file DlSecondaryVertexingAlgorithm.cc.

References e, m_rootFileName, m_rootTreeName, and m_writeTree.

 {
     if (m_writeTree)
     {
         try
         {
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_rootTreeName, m_rootFileName, "RECREATE"));
         }
         catch (StatusCodeException e)
         {
             std::cout << "VertexAssessmentAlgorithm: Unable to write to ROOT tree" << std::endl;
         }
     }
 }

Member Function Documentation

void lar_dl_content::DlVertexingBaseAlgorithm::GetCanvasParameters	(	const LArDLHelper::TorchOutput &	networkOutput,
		const PixelVector &	pixelVector,
		int &	columnOffset,
		int &	rowOffset,
		int &	width,
		int &	height
	)		const

protectedinherited

Determines the parameters of the canvas for extracting the vertex location. The network predicts the distance that each pixel associated with a hit is located from the vertex, but says nothing about the direction. As a result, the ring describing the potential vertices associated with that hit can extend beyond the original canvas size. This function returns the size of the required canvas and the offset for the bottom left corner.

Parameters

networkOutput	The TorchOutput object populated by the network inference step
pixelVector	The vector of populated pixels
columnOffset	The output column offset for the canvas
rowOffset	The output row offset for the canvas
width	The output width for the canvas
height	The output height for the canvas

Definition at line 165 of file DlVertexingBaseAlgorithm.cc.

References col, lar_dl_content::DlVertexingBaseAlgorithm::m_height, lar_dl_content::DlVertexingBaseAlgorithm::m_thresholds, and lar_dl_content::DlVertexingBaseAlgorithm::m_width.

Referenced by lar_dl_content::DlVertexingAlgorithm::Infer(), and Infer().

 {
     const double scaleFactor{std::sqrt(m_height * m_height + m_width * m_width)};
     // output is a 1 x num_classes x height x width tensor
     // we want the maximum value in the num_classes dimension (1) for every pixel
     auto classes{torch::argmax(networkOutput, 1)};
     // the argmax result is a 1 x height x width tensor where each element is a class id
     auto classesAccessor{classes.accessor<int64_t, 3>()};
     int colOffsetMin{0}, colOffsetMax{0}, rowOffsetMin{0}, rowOffsetMax{0};
     for (const auto &[row, col] : pixelVector)
     {
         const auto cls{classesAccessor[0][row][col]};
         const double threshold{m_thresholds[cls]};
         if (threshold > 0. && threshold < 1.)
         {
             const int distance = static_cast<int>(std::round(std::ceil(scaleFactor * threshold)));
             if ((row - distance) < rowOffsetMin)
                 rowOffsetMin = row - distance;
             if ((row + distance) > rowOffsetMax)
                 rowOffsetMax = row + distance;
             if ((col - distance) < colOffsetMin)
                 colOffsetMin = col - distance;
             if ((col + distance) > colOffsetMax)
                 colOffsetMax = col + distance;
         }
     }
     colOffset = colOffsetMin < 0 ? -colOffsetMin : 0;
     rowOffset = rowOffsetMin < 0 ? -rowOffsetMin : 0;
     width = std::max(colOffsetMax + colOffset + 1, m_width);
     height = std::max(rowOffsetMax + rowOffset + 1, m_height);
 }

void lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion	(	const pandora::CaloHitList &	caloHitList,
		float &	xMin,
		float &	xMax,
		float &	zMin,
		float &	zMax
	)		const

protectedinherited

Definition at line 50 of file DlVertexingBaseAlgorithm.cc.

References util::begin(), lar_dl_content::DlVertexingBaseAlgorithm::m_caloHitListNames, lar_dl_content::DlVertexingBaseAlgorithm::m_driftStep, lar_dl_content::DlVertexingBaseAlgorithm::m_height, lar_dl_content::DlVertexingBaseAlgorithm::m_inputVertexListName, lar_dl_content::DlVertexingBaseAlgorithm::m_pass, lar_dl_content::DlVertexingBaseAlgorithm::m_width, x, and z.

Referenced by lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), lar_dl_content::DlVertexingAlgorithm::PrepareTrainingSample(), and PrepareTrainingSample().

 {
     xMin = std::numeric_limits<float>::max();
     xMax = -std::numeric_limits<float>::max();
     zMin = std::numeric_limits<float>::max();
     zMax = -std::numeric_limits<float>::max();
     // Find the range of x and z values in the view
     for (const CaloHit *pCaloHit : caloHitList)
     {
         const float x{pCaloHit->GetPositionVector().GetX()};
         const float z{pCaloHit->GetPositionVector().GetZ()};
         xMin = std::min(x, xMin);
         xMax = std::max(x, xMax);
         zMin = std::min(z, zMin);
         zMax = std::max(z, zMax);
     }
 
     if (caloHitList.empty())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     const HitType view{caloHitList.front()->GetHitType()};
     const bool isU{view == TPC_VIEW_U}, isV{view == TPC_VIEW_V}, isW{view == TPC_VIEW_W};
     if (!(isU || isV || isW))
         throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
 
     // ATTN If wire w pitches vary between TPCs, exception will be raised in initialisation of lar pseudolayer plugin
     const LArTPC *const pTPC(this->GetPandora().GetGeometry()->GetLArTPCMap().begin()->second);
     const float pitch(view == TPC_VIEW_U ? pTPC->GetWirePitchU() : view == TPC_VIEW_V ? pTPC->GetWirePitchV() : pTPC->GetWirePitchW());
 
     if (m_pass > 1)
     {
         const VertexList *pVertexList(nullptr);
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_inputVertexListName, pVertexList));
         if (pVertexList->empty())
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
         const CartesianVector &vertex{pVertexList->front()->GetPosition()};
 
         // Get hit distribution left/right asymmetry
         int nHitsLeft{0}, nHitsRight{0};
         const double xVtx{vertex.GetX()};
         for (const std::string &listname : m_caloHitListNames)
         {
             const CaloHitList *pCaloHitList(nullptr);
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listname, pCaloHitList));
             if (pCaloHitList->empty())
                 continue;
             for (const CaloHit *const pCaloHit : *pCaloHitList)
             {
                 const CartesianVector &pos{pCaloHit->GetPositionVector()};
                 if (pos.GetX() <= xVtx)
                     ++nHitsLeft;
                 else
                     ++nHitsRight;
             }
         }
         const int nHitsTotal{nHitsLeft + nHitsRight};
         if (nHitsTotal == 0)
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
         const float xAsymmetry{nHitsLeft / static_cast<float>(nHitsTotal)};
 
         // Vertices
         const LArTransformationPlugin *transform{this->GetPandora().GetPlugins()->GetLArTransformationPlugin()};
         double zVtx{0.};
         if (isW)
             zVtx += transform->YZtoW(vertex.GetY(), vertex.GetZ());
         else if (isV)
             zVtx += transform->YZtoV(vertex.GetY(), vertex.GetZ());
         else
             zVtx = transform->YZtoU(vertex.GetY(), vertex.GetZ());
 
         // Get hit distribution upstream/downstream asymmetry
         int nHitsUpstream{0}, nHitsDownstream{0};
         for (const CaloHit *const pCaloHit : caloHitList)
         {
             const CartesianVector &pos{pCaloHit->GetPositionVector()};
             if (pos.GetZ() <= zVtx)
                 ++nHitsUpstream;
             else
                 ++nHitsDownstream;
         }
         const int nHitsViewTotal{nHitsUpstream + nHitsDownstream};
         if (nHitsViewTotal == 0)
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
         const float zAsymmetry{nHitsUpstream / static_cast<float>(nHitsViewTotal)};
 
         const float xSpan{m_driftStep * (m_width - 1)};
         xMin = xVtx - xAsymmetry * xSpan;
         xMax = xMin + (m_driftStep * (m_width - 1));
         const float zSpan{pitch * (m_height - 1)};
         zMin = zVtx - zAsymmetry * zSpan;
         zMax = zMin + zSpan;
     }
 
     // Avoid unreasonable rescaling of very small hit regions, pixels are assumed to be 0.5cm in x and wire pitch in z
     // ATTN: Rescaling is to a size 1 pixel smaller than the intended image to ensure all hits fit within an imaged binned
     // to be one pixel wider than this
     const float xRange{xMax - xMin}, zRange{zMax - zMin};
     const float minXSpan{m_driftStep * (m_width - 1)};
     if (xRange < minXSpan)
     {
         const float padding{0.5f * (minXSpan - xRange)};
         xMin -= padding;
         xMax += padding;
     }
     const float minZSpan{pitch * (m_height - 1)};
     if (zRange < minZSpan)
     {
         const float padding{0.5f * (minZSpan - zRange)};
         zMin -= padding;
         zMax += padding;
     }
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::GetNetworkVertices	(	const CanvasViewMap &	canvases,
		pandora::CartesianPointVector &	positionVector
	)		const

private

Definition at line 334 of file DlSecondaryVertexingAlgorithm.cc.

References lar_dl_content::VertexTuple::GetChi2(), lar_dl_content::VertexTuple::GetComponents(), and GetVerticesFromCanvas().

Referenced by Infer().

 {
     CartesianPointVector verticesU, verticesV, verticesW;
     this->GetVerticesFromCanvas(*canvases.at(TPC_VIEW_U), verticesU);
     this->GetVerticesFromCanvas(*canvases.at(TPC_VIEW_V), verticesV);
     this->GetVerticesFromCanvas(*canvases.at(TPC_VIEW_W), verticesW);
 
     std::vector<VertexTuple> vertexTuples;
     int nEmptyLists{(verticesU.empty() ? 1 : 0) + (verticesV.empty() ? 1 : 0) + (verticesW.empty() ? 1 : 0)};
 
     if (nEmptyLists == 0)
     {
         for (const CartesianVector &vertexU : verticesU)
         {
             for (const CartesianVector &vertexV : verticesV)
             {
                 for (const CartesianVector &vertexW : verticesW)
                 {
                     const float xMin{std::min({vertexU.GetX(), vertexV.GetX(), vertexW.GetX()})};
                     const float xMax{std::max({vertexU.GetX(), vertexV.GetX(), vertexW.GetX()})};
                     if ((xMax - xMin) < 10.f)
                     {
                         const VertexTuple &tuple{VertexTuple(this->GetPandora(), vertexU, vertexV, vertexW)};
                         if (tuple.GetChi2() < 1)
                             vertexTuples.emplace_back(tuple);
                     }
                 }
             }
         }
     }
     else if (nEmptyLists == 1)
     {
         if (verticesU.empty())
         {
             for (const CartesianVector &vertexV : verticesV)
             {
                 for (const CartesianVector &vertexW : verticesW)
                 {
                     const float xMin{std::min({vertexV.GetX(), vertexW.GetX()})};
                     const float xMax{std::max({vertexV.GetX(), vertexW.GetX()})};
                     if ((xMax - xMin) < 10.f)
                     {
                         const VertexTuple &tuple{VertexTuple(this->GetPandora(), vertexV, vertexW, TPC_VIEW_V, TPC_VIEW_W)};
                         if (tuple.GetChi2() < 1)
                             vertexTuples.emplace_back(tuple);
                     }
                 }
             }
         }
         else if (verticesV.empty())
         {
             for (const CartesianVector &vertexU : verticesU)
             {
                 for (const CartesianVector &vertexW : verticesW)
                 {
                     const float xMin{std::min({vertexU.GetX(), vertexW.GetX()})};
                     const float xMax{std::max({vertexU.GetX(), vertexW.GetX()})};
                     if ((xMax - xMin) < 10.f)
                     {
                         const VertexTuple &tuple{VertexTuple(this->GetPandora(), vertexU, vertexW, TPC_VIEW_U, TPC_VIEW_W)};
                         if (tuple.GetChi2() < 1)
                             vertexTuples.emplace_back(tuple);
                     }
                 }
             }
         }
         else
         {
             for (const CartesianVector &vertexU : verticesU)
             {
                 for (const CartesianVector &vertexV : verticesV)
                 {
                     const float xMin{std::min({vertexU.GetX(), vertexV.GetX()})};
                     const float xMax{std::max({vertexU.GetX(), vertexV.GetX()})};
                     if ((xMax - xMin) < 10.f)
                     {
                         const VertexTuple &tuple{VertexTuple(this->GetPandora(), vertexU, vertexV, TPC_VIEW_U, TPC_VIEW_V)};
                         if (tuple.GetChi2() < 1)
                             vertexTuples.emplace_back(tuple);
                     }
                 }
             }
         }
     }
     else
     {
         std::cout << "Insufficient 2D vertices to reconstruct a 3D vertex" << std::endl;
         return STATUS_CODE_NOT_FOUND;
     }
 
     // Sort the vertex tuples here and pick the unique ones that look sound
     std::sort(vertexTuples.begin(), vertexTuples.end(),
         [](const VertexTuple &tuple1, const VertexTuple &tuple2)
         {
             const CartesianPointVector &components1{tuple1.GetComponents()};
             const CartesianPointVector &components2{tuple2.GetComponents()};
             if (components1.size() == components2.size())
                 return tuple1.GetChi2() < tuple2.GetChi2();
             else
                 return components1.size() > components2.size();
         });
 
     CartesianPointVector used;
     for (const VertexTuple &tuple : vertexTuples)
     {
         const CartesianPointVector &components{tuple.GetComponents()};
         bool isAvailable{true};
         for (const CartesianVector &component : components)
         {
             if (std::find(used.begin(), used.end(), component) != used.end())
             {
                 isAvailable = false;
                 break;
             }
         }
         if (!isAvailable || (components.size() < 3 && tuple.GetChi2() > 0.1))
             continue;
 
         positionVector.emplace_back(tuple.GetPosition());
         for (const CartesianVector &component : components)
             used.emplace_back(component);
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::GetVerticesFromCanvas	(	const Canvas &	canvas,
		pandora::CartesianPointVector &	vertices
	)		const

private

Definition at line 462 of file DlSecondaryVertexingAlgorithm.cc.

Referenced by GetNetworkVertices().

 {
     // ATTN If wire w pitches vary between TPCs, exception will be raised in initialisation of lar pseudolayer plugin
     const LArTPC *const pTPC(this->GetPandora().GetGeometry()->GetLArTPCMap().begin()->second);
 
     HitType view{canvas.m_view};
     const float pitch(view == TPC_VIEW_U ? pTPC->GetWirePitchU() : view == TPC_VIEW_V ? pTPC->GetWirePitchV() : pTPC->GetWirePitchW());
     const float driftStep{0.5f};
 
     const double dx{((canvas.m_xMax + 0.5f * driftStep) - (canvas.m_xMin - 0.5f * driftStep)) / m_width};
     const double dz{((canvas.m_zMax + 0.5f * pitch) - (canvas.m_zMin - 0.5f * pitch)) / m_height};
 
     float maxIntensity{0.f};
     for (int xp = 0; xp < m_width; ++xp)
     {
         int xpp{xp + canvas.m_colOffset};
         if (xpp >= canvas.m_width)
             continue;
 
         for (int zp = 0; zp < m_height; ++zp)
         {
             int zpp{zp + canvas.m_rowOffset};
             if (zpp >= canvas.m_height)
                 continue;
 
             const float localIntensity{canvas.m_canvas[zpp][xpp]};
             if (localIntensity > maxIntensity)
                 maxIntensity = localIntensity;
         }
     }
     const float threshold{maxIntensity * 0.3f};
 
     std::vector<std::vector<std::pair<int, int>>> peaks;
     for (int xp = 0; xp < m_width; ++xp)
     {
         int xpp{xp + canvas.m_colOffset};
         if (xpp >= canvas.m_width)
             continue;
 
         for (int zp = 0; zp < m_height; ++zp)
         {
             int zpp{zp + canvas.m_rowOffset};
             if (zpp >= canvas.m_height)
                 continue;
             const float localIntensity{canvas.m_canvas[zpp][xpp]};
 
             std::vector<std::pair<int, int>> peak;
             bool hasLowNeighbour{false};
             for (int dr = -1; dr <= 1; ++dr)
             {
                 for (int dc = -1; dc <= 1; ++dc)
                 {
                     if (dr == 0 && dc == 0)
                         continue;
                     const int r{zpp + dr}, c{xpp + dc};
                     if (r < 0 || r >= canvas.m_height || c < 0 || c >= canvas.m_width)
                         continue;
 
                     const float neighborIntensity{canvas.m_canvas[r][c]};
                     if (localIntensity > neighborIntensity)
                     {
                         hasLowNeighbour = true;
                     }
                     else if (localIntensity < neighborIntensity)
                     {
                         hasLowNeighbour = false;
                         break;
                     }
                 }
             }
             if (hasLowNeighbour && localIntensity > threshold)
                 this->GrowPeak(canvas, xpp, zpp, localIntensity, peak);
             if (!peak.empty())
                 peaks.emplace_back(peak);
         }
     }
 
     for (const auto &peak : peaks)
     {
         float row{0}, col{0};
         for (const auto &pixel : peak)
         {
             row += pixel.second - canvas.m_rowOffset;
             col += pixel.first - canvas.m_colOffset;
         }
         row /= peak.size();
         col /= peak.size();
 
         const float x{static_cast<float>(col * dx + canvas.m_xMin)};
         const float z{static_cast<float>(row * dz + canvas.m_zMin)};
         CartesianVector pt(x, 0, z);
         vertices.emplace_back(pt);
     }
 
     return STATUS_CODE_SUCCESS;
 }

bool lar_dl_content::DlSecondaryVertexingAlgorithm::GrowPeak	(	const Canvas &	canvas,
		int	col,
		int	row,
		float	intensity,
		std::vector< std::pair< int, int >> &	peak
	)		const

private

Determine if the pixel under consideration is part of a peak and grow that peak to include all connected pixels of equal value.

Parameters

canvas	The canvas within which peaks are sought
col	The column of the pixel under consideration
row	The row of the pixel under consideration
intensity	The target intensity of the candidate peak
peak	The output vector of pixels constituting the peak under consideration

Returns: true if we found a better peak while growing the current region, false otherwise

Definition at line 561 of file DlSecondaryVertexingAlgorithm.cc.

References col, lar_dl_content::DlSecondaryVertexingAlgorithm::Canvas::m_canvas, lar_dl_content::DlSecondaryVertexingAlgorithm::Canvas::m_height, lar_dl_content::DlSecondaryVertexingAlgorithm::Canvas::m_visited, lar_dl_content::DlSecondaryVertexingAlgorithm::Canvas::m_width, and r.

Referenced by GetVerticesFromCanvas().

 {
     //    if (col >= 0 && col < canvas.m_width && row >= 0 && row < canvas.m_height)
     //    {
     //        std::cout << "Visited: " << canvas.m_visited[row][col] << " " <<
     //    }
     if (col < 0 || col >= canvas.m_width || row < 0 || row >= canvas.m_height || canvas.m_visited[row][col] || canvas.m_canvas[row][col] < intensity)
         return false;
 
     // Check that no adjacent pixel is larger than this one
     for (int dc = -1; dc <= 1; ++dc)
     {
         const int c{col + dc};
         if (c < 0 || c >= canvas.m_width)
             continue;
 
         for (int dr = -1; dr <= 1; ++dr)
         {
             const int r{row + dr};
             if (r < 0 || r >= canvas.m_height)
                 continue;
 
             if (dr == 0 && dc == 0)
                 continue;
 
             const float neighborIntensity{canvas.m_canvas[r][c]};
             if (neighborIntensity > intensity)
                 return false;
         }
     }
 
     // Need to check we aren't growing into a higher peak, if we are restart from the current pixel
     float localIntensity{canvas.m_canvas[row][col]};
     if (localIntensity > intensity)
     {
         intensity = localIntensity;
         for (const auto &pixel : peak)
             canvas.m_visited[pixel.second][pixel.first] = false;
         peak.clear();
         //std::cout << ". New size " << peak.size() << " new intensity " << intensity << std::endl;
         this->GrowPeak(canvas, col, row, intensity, peak);
         return true;
     }
 
     // Add pixel to the peak
     canvas.m_visited[row][col] = true;
     peak.emplace_back(std::make_pair(col, row));
     //std::cout << "   Added" << std::endl;
 
     for (int dc = -1; dc <= 1; ++dc)
     {
         for (int dr = -1; dr <= 1; ++dr)
         {
             if (dr == 0 && dc == 0)
                 continue;
             //std::cout << "   Adjacent (" << (row + i) << "," << (col + j) << ")" << std::endl;
             bool reset{this->GrowPeak(canvas, col + dc, row + dr, intensity, peak)};
             // If we started growing a non-peak region, stop looking relative to the previous peak
             if (reset)
                 return reset;
         }
     }
 
     return false;
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::Infer ( )

private

Definition at line 178 of file DlSecondaryVertexingAlgorithm.cc.

Referenced by Run().

 {
     // Get boundaries for hits and make x dimension common
     std::map<HitType, float> wireMin, wireMax;
     float driftMin{std::numeric_limits<float>::max()}, driftMax{-std::numeric_limits<float>::max()};
     for (const std::string &listname : m_caloHitListNames)
     {
         const CaloHitList *pCaloHitList{nullptr};
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listname, pCaloHitList));
         if (pCaloHitList->empty())
             continue;
 
         HitType view{pCaloHitList->front()->GetHitType()};
         float viewDriftMin{driftMin}, viewDriftMax{driftMax};
         this->GetHitRegion(*pCaloHitList, viewDriftMin, viewDriftMax, wireMin[view], wireMax[view]);
         driftMin = std::min(viewDriftMin, driftMin);
         driftMax = std::max(viewDriftMax, driftMax);
     }
 
     CanvasViewMap canvases;
     canvases[TPC_VIEW_U] = nullptr;
     canvases[TPC_VIEW_V] = nullptr;
     canvases[TPC_VIEW_W] = nullptr;
     CartesianPointVector vertexCandidatesU, vertexCandidatesV, vertexCandidatesW;
     for (const std::string &listname : m_caloHitListNames)
     {
         const CaloHitList *pCaloHitList{nullptr};
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listname, pCaloHitList));
         if (pCaloHitList->empty())
             continue;
 
         HitType view{pCaloHitList->front()->GetHitType()};
         LArDLHelper::TorchInput input;
         PixelVector pixelVector;
         this->MakeNetworkInputFromHits(*pCaloHitList, view, driftMin, driftMax, wireMin[view], wireMax[view], input, pixelVector);
 
         // Run the input through the trained model
         LArDLHelper::TorchInputVector inputs;
         inputs.push_back(input);
         LArDLHelper::TorchOutput output;
         switch (view)
         {
             case TPC_VIEW_U:
                 LArDLHelper::Forward(m_modelU, inputs, output);
                 break;
             case TPC_VIEW_V:
                 LArDLHelper::Forward(m_modelV, inputs, output);
                 break;
             default:
                 LArDLHelper::Forward(m_modelW, inputs, output);
                 break;
         }
 
         int colOffset{0}, rowOffset{0}, canvasWidth{m_width}, canvasHeight{m_height};
         this->GetCanvasParameters(output, pixelVector, colOffset, rowOffset, canvasWidth, canvasHeight);
         canvases[view] = new Canvas(view, canvasWidth, canvasHeight, colOffset, rowOffset, driftMin, driftMax, wireMin[view], wireMax[view]);
         // we want the maximum value in the num_classes dimension (1) for every pixel
         auto classes{torch::argmax(output, 1)};
         // the argmax result is a 1 x height x width tensor where each element is a class id
         auto classesAccessor{classes.accessor<long, 3>()};
         const double scaleFactor{std::sqrt(m_height * m_height + m_width * m_width)};
         std::map<int, bool> haveSeenMap;
         for (const auto &[row, col] : pixelVector)
         {
             const auto cls{classesAccessor[0][row][col]};
             if (cls > 0 && cls < m_nClasses)
             {
                 const int inner{static_cast<int>(std::round(std::ceil(scaleFactor * m_thresholds[cls - 1])))};
                 const int outer{static_cast<int>(std::round(std::ceil(scaleFactor * m_thresholds[cls])))};
                 LArCanvasHelper::DrawRing(
                     canvases[view]->m_canvas, row + rowOffset, col + colOffset, inner, outer, 1.f / (outer * outer - inner * inner));
             }
         }
     }
 
     CartesianPointVector vertexVector;
     this->GetNetworkVertices(canvases, vertexVector);
 
     if (!vertexVector.empty())
     {
         StatusCode status{this->MakeCandidateVertexList(vertexVector)};
 
         for (const HitType view : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
         {
             if (canvases[view])
                 delete canvases[view];
         }
 
         return status;
     }
     else
     {
         for (const HitType view : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
         {
             if (canvases[view])
                 delete canvases[view];
         }
 
         return STATUS_CODE_SUCCESS;
     }
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::MakeCandidateVertexList ( const pandora::CartesianPointVector & positions )

private

Create a vertex list from the candidate vertices.

Parameters

candidates The candidate positions with which to create the list.

Returns: The StatusCode resulting from the function

Definition at line 629 of file DlSecondaryVertexingAlgorithm.cc.

References lar_dl_content::DlVertexingBaseAlgorithm::m_outputVertexListName.

Referenced by Infer().

 {
     const VertexList *pVertexList{nullptr};
     std::string temporaryListName;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pVertexList, temporaryListName));
 
     for (const CartesianVector &position : positions)
     {
         PandoraContentApi::Vertex::Parameters parameters;
         parameters.m_position = position;
         parameters.m_vertexLabel = VERTEX_INTERACTION;
         parameters.m_vertexType = VERTEX_3D;
 
         const Vertex *pVertex(nullptr);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
     }
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*this, m_outputVertexListName));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::MakeNetworkInputFromHits	(	const pandora::CaloHitList &	caloHits,
		const pandora::HitType	view,
		const float	xMin,
		const float	xMax,
		const float	zMin,
		const float	zMax,
		LArDLHelper::TorchInput &	networkInput,
		PixelVector &	pixelVector
	)		const

private

Definition at line 282 of file DlSecondaryVertexingAlgorithm.cc.

References util::begin(), col, lar_dl_content::LArDLHelper::InitialiseInput(), lar_dl_content::DlVertexingBaseAlgorithm::m_height, lar_dl_content::DlVertexingBaseAlgorithm::m_pass, lar_dl_content::DlVertexingBaseAlgorithm::m_width, value, x, and z.

Referenced by Infer().

 {
     // ATTN If wire w pitches vary between TPCs, exception will be raised in initialisation of lar pseudolayer plugin
     const LArTPC *const pTPC(this->GetPandora().GetGeometry()->GetLArTPCMap().begin()->second);
     const float pitch(view == TPC_VIEW_U ? pTPC->GetWirePitchU() : view == TPC_VIEW_V ? pTPC->GetWirePitchV() : pTPC->GetWirePitchW());
     const float driftStep{0.5f};
 
     // Determine the bin edges
     std::vector<double> xBinEdges(m_width + 1);
     std::vector<double> zBinEdges(m_height + 1);
     xBinEdges[0] = xMin - 0.5f * driftStep;
     const double dx = ((xMax + 0.5f * driftStep) - xBinEdges[0]) / m_width;
     for (int i = 1; i < m_width + 1; ++i)
         xBinEdges[i] = xBinEdges[i - 1] + dx;
     zBinEdges[0] = zMin - 0.5f * pitch;
     const double dz = ((zMax + 0.5f * pitch) - zBinEdges[0]) / m_height;
     for (int i = 1; i < m_height + 1; ++i)
         zBinEdges[i] = zBinEdges[i - 1] + dz;
 
     LArDLHelper::InitialiseInput({1, 1, m_height, m_width}, networkInput);
     auto accessor = networkInput.accessor<float, 4>();
 
     for (const CaloHit *pCaloHit : caloHits)
     {
         const float x{pCaloHit->GetPositionVector().GetX()};
         const float z{pCaloHit->GetPositionVector().GetZ()};
         if (m_pass > 1)
         {
             if (x < xMin || x > xMax || z < zMin || z > zMax)
                 continue;
         }
         const float adc{pCaloHit->GetMipEquivalentEnergy()};
         const int pixelX{static_cast<int>(std::floor((x - xBinEdges[0]) / dx))};
         const int pixelZ{static_cast<int>(std::floor((z - zBinEdges[0]) / dz))};
         accessor[0][0][pixelZ][pixelX] += adc;
     }
     for (int row = 0; row < m_height; ++row)
     {
         for (int col = 0; col < m_width; ++col)
         {
             const float value{accessor[0][0][row][col]};
             if (value > 0)
                 pixelVector.emplace_back(std::make_pair(row, col));
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::PrepareTrainingSample ( )

private

Definition at line 70 of file DlSecondaryVertexingAlgorithm.cc.

References lar_content::LArEventTopology::ConstructVisibleHierarchy(), lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), lar_content::LArEventTopology::GetVertices(), lar_dl_content::DlVertexingBaseAlgorithm::m_caloHitListNames, m_event, lar_dl_content::DlVertexingBaseAlgorithm::m_trainingOutputFile, lar_dl_content::DlVertexingBaseAlgorithm::m_volumeType, and lar_content::LArEventTopology::PruneHierarchy().

Referenced by Run().

 {
     const CaloHitList *pCaloHitList2D{nullptr};
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, "CaloHitList2D", pCaloHitList2D));
     LArEventTopology eventTopology(*pCaloHitList2D);
     eventTopology.ConstructVisibleHierarchy();
     eventTopology.PruneHierarchy();
     CartesianPointVector vertices;
     eventTopology.GetVertices(vertices);
 
     // Only train on events where there is a vertex in the fiducial volume
     bool hasFiducialVertex{false};
     for (const CartesianVector &vertex : vertices)
     {
         if (LArVertexHelper::IsInFiducialVolume(this->GetPandora(), vertex, m_volumeType))
         {
             hasFiducialVertex = true;
             break;
         }
     }
 
     if (!hasFiducialVertex)
         return STATUS_CODE_SUCCESS;
 
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));
     LArMCParticleHelper::MCContributionMap mcToHitsMap;
     LArMCParticleHelper::GetMCToHitsMap(pCaloHitList2D, pMCParticleList, mcToHitsMap);
     MCParticleList hierarchy;
     LArMCParticleHelper::CompleteMCHierarchy(mcToHitsMap, hierarchy);
 
     // Get boundaries for hits and make x dimension common
     std::map<HitType, float> wireMin, wireMax;
     float driftMin{std::numeric_limits<float>::max()}, driftMax{-std::numeric_limits<float>::max()};
     for (const std::string &listname : m_caloHitListNames)
     {
         const CaloHitList *pCaloHitList{nullptr};
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listname, pCaloHitList));
         if (pCaloHitList->empty())
             continue;
 
         HitType view{pCaloHitList->front()->GetHitType()};
         float viewDriftMin{driftMin}, viewDriftMax{driftMax};
         this->GetHitRegion(*pCaloHitList, viewDriftMin, viewDriftMax, wireMin[view], wireMax[view]);
         driftMin = std::min(viewDriftMin, driftMin);
         driftMax = std::max(viewDriftMax, driftMax);
     }
     for (const std::string &listname : m_caloHitListNames)
     {
         const CaloHitList *pCaloHitList(nullptr);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listname, pCaloHitList));
         if (pCaloHitList->empty())
             continue;
 
         HitType view{pCaloHitList->front()->GetHitType()};
 
         const std::string trainingFilename{m_trainingOutputFile + "_" + listname + ".csv"};
         const unsigned long nVertices{vertices.size()};
         unsigned long nHits{0};
 
         LArMvaHelper::MvaFeatureVector featureVector;
         featureVector.emplace_back(static_cast<double>(m_event));
         featureVector.emplace_back(static_cast<double>(nVertices));
         // Vertices
         const LArTransformationPlugin *transform{this->GetPandora().GetPlugins()->GetLArTransformationPlugin()};
         for (const CartesianVector &vertex : vertices)
         {
             switch (view)
             {
                 case TPC_VIEW_U:
                     featureVector.emplace_back(vertex.GetX());
                     featureVector.emplace_back(transform->YZtoU(vertex.GetY(), vertex.GetZ()));
                     break;
                 case TPC_VIEW_V:
                     featureVector.emplace_back(vertex.GetX());
                     featureVector.emplace_back(transform->YZtoV(vertex.GetY(), vertex.GetZ()));
                     break;
                 default:
                     featureVector.emplace_back(vertex.GetX());
                     featureVector.emplace_back(transform->YZtoW(vertex.GetY(), vertex.GetZ()));
                     break;
             }
         }
 
         // Retain the hit region
         featureVector.emplace_back(driftMin);
         featureVector.emplace_back(driftMax);
         featureVector.emplace_back(wireMin[view]);
         featureVector.emplace_back(wireMax[view]);
 
         for (const CaloHit *pCaloHit : *pCaloHitList)
         {
             featureVector.emplace_back(static_cast<double>(pCaloHit->GetPositionVector().GetX()));
             featureVector.emplace_back(static_cast<double>(pCaloHit->GetPositionVector().GetZ()));
             featureVector.emplace_back(static_cast<double>(pCaloHit->GetMipEquivalentEnergy()));
             ++nHits;
         }
         featureVector.insert(featureVector.begin() + 2 + 2 * nVertices + 4, static_cast<double>(nHits));
         // Only write out the feature vector if there were enough hits in the region of interest
         if (nHits > 10)
             LArMvaHelper::ProduceTrainingExample(trainingFilename, true, featureVector);
     }
 
     return STATUS_CODE_SUCCESS;
 }

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

private

Definition at line 652 of file DlSecondaryVertexingAlgorithm.cc.

References m_rootFileName, m_rootTreeName, lar_dl_content::DlVertexingBaseAlgorithm::m_trainingMode, m_visualise, m_writeTree, and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, DlVertexingBaseAlgorithm::ReadSettings(xmlHandle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Visualise", m_visualise));
 
     if (!m_trainingMode)
     {
         PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "WriteTree", m_writeTree));
         if (m_writeTree)
         {
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "RootTreeName", m_rootTreeName));
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "RootFileName", m_rootFileName));
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlSecondaryVertexingAlgorithm::Run ( )

private

Definition at line 58 of file DlSecondaryVertexingAlgorithm.cc.

References Infer(), m_event, lar_dl_content::DlVertexingBaseAlgorithm::m_trainingMode, and PrepareTrainingSample().

 {
     ++m_event;
 
     if (m_trainingMode)
         return this->PrepareTrainingSample();
     else
         return this->Infer();
 
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

pandora::StringVector lar_dl_content::DlVertexingBaseAlgorithm::m_caloHitListNames

protectedinherited

Names of input calo hit lists.

Definition at line 79 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), lar_dl_content::DlVertexingAlgorithm::PrepareTrainingSample(), PrepareTrainingSample(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

float lar_dl_content::DlVertexingBaseAlgorithm::m_driftStep

protectedinherited

The size of a pixel in the drift direction in cm (most relevant in pass 2)

Definition at line 87 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), lar_dl_content::DlVertexingAlgorithm::MakeNetworkInputFromHits(), lar_dl_content::DlVertexingAlgorithm::MakeWirePlaneCoordinatesFromCanvas(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

int lar_dl_content::DlSecondaryVertexingAlgorithm::m_event

private

The current event number.

Definition at line 129 of file DlSecondaryVertexingAlgorithm.h.

Referenced by PrepareTrainingSample(), and Run().

int lar_dl_content::DlVertexingBaseAlgorithm::m_height

protectedinherited

The height of the images.

Definition at line 85 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingBaseAlgorithm::GetCanvasParameters(), lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), GetVerticesFromCanvas(), lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), lar_dl_content::DlVertexingAlgorithm::MakeNetworkInputFromHits(), MakeNetworkInputFromHits(), lar_dl_content::DlVertexingAlgorithm::MakeWirePlaneCoordinatesFromCanvas(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

std::string lar_dl_content::DlVertexingBaseAlgorithm::m_inputVertexListName

protectedinherited

Input vertex list name if 2nd pass.

Definition at line 77 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), lar_dl_content::DlVertexingAlgorithm::Infer(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DlVertexingBaseAlgorithm::m_modelU

protectedinherited

The model for the U view.

Definition at line 80 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DlVertexingBaseAlgorithm::m_modelV

protectedinherited

The model for the V view.

Definition at line 81 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DlVertexingBaseAlgorithm::m_modelW

protectedinherited

The model for the W view.

Definition at line 82 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

int lar_dl_content::DlVertexingBaseAlgorithm::m_nClasses

protectedinherited

The number of distance classes.

Definition at line 84 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

std::string lar_dl_content::DlVertexingBaseAlgorithm::m_outputVertexListName

protectedinherited

Output vertex list name.

Definition at line 78 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingAlgorithm::MakeCandidateVertexList(), MakeCandidateVertexList(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

int lar_dl_content::DlVertexingBaseAlgorithm::m_pass

protectedinherited

The pass of the train/infer step.

Definition at line 83 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), lar_dl_content::DlVertexingAlgorithm::Infer(), lar_dl_content::DlVertexingAlgorithm::MakeCandidateVertexList(), lar_dl_content::DlVertexingAlgorithm::MakeNetworkInputFromHits(), MakeNetworkInputFromHits(), lar_dl_content::DlVertexingAlgorithm::PrepareTrainingSample(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

std::mt19937 lar_dl_content::DlSecondaryVertexingAlgorithm::m_rng

private

The random number generator.

Definition at line 134 of file DlSecondaryVertexingAlgorithm.h.

Referenced by DlSecondaryVertexingAlgorithm().

std::string lar_dl_content::DlSecondaryVertexingAlgorithm::m_rootFileName

private

The ROOT file name.

Definition at line 133 of file DlSecondaryVertexingAlgorithm.h.

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

std::string lar_dl_content::DlSecondaryVertexingAlgorithm::m_rootTreeName

private

The ROOT tree name.

Definition at line 132 of file DlSecondaryVertexingAlgorithm.h.

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

std::vector<double> lar_dl_content::DlVertexingBaseAlgorithm::m_thresholds

protectedinherited

Distance class thresholds.

Definition at line 88 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::GetCanvasParameters(), lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

bool lar_dl_content::DlVertexingBaseAlgorithm::m_trainingMode

protectedinherited

Training mode.

Definition at line 75 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingAlgorithm::ReadSettings(), lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings(), ReadSettings(), lar_dl_content::DlVertexingAlgorithm::Run(), and Run().

std::string lar_dl_content::DlVertexingBaseAlgorithm::m_trainingOutputFile

protectedinherited

Output file name for training examples.

Definition at line 76 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingAlgorithm::PrepareTrainingSample(), PrepareTrainingSample(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

bool lar_dl_content::DlSecondaryVertexingAlgorithm::m_visualise

private

Whether or not to visualise the candidate vertices.

Definition at line 130 of file DlSecondaryVertexingAlgorithm.h.

Referenced by DlSecondaryVertexingAlgorithm(), and ReadSettings().

std::string lar_dl_content::DlVertexingBaseAlgorithm::m_volumeType

protectedinherited

The name of the fiducial volume type for the monitoring output.

Definition at line 89 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingAlgorithm::MakeCandidateVertexList(), PrepareTrainingSample(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

int lar_dl_content::DlVertexingBaseAlgorithm::m_width

protectedinherited

The width of the images.

Definition at line 86 of file DlVertexingBaseAlgorithm.h.

Referenced by lar_dl_content::DlVertexingBaseAlgorithm::DlVertexingBaseAlgorithm(), lar_dl_content::DlVertexingBaseAlgorithm::GetCanvasParameters(), lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), GetVerticesFromCanvas(), lar_dl_content::DlVertexingAlgorithm::Infer(), Infer(), lar_dl_content::DlVertexingAlgorithm::MakeNetworkInputFromHits(), MakeNetworkInputFromHits(), lar_dl_content::DlVertexingAlgorithm::MakeWirePlaneCoordinatesFromCanvas(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

bool lar_dl_content::DlSecondaryVertexingAlgorithm::m_writeTree

private

Whether or not to write validation details to a ROOT tree.

Definition at line 131 of file DlSecondaryVertexingAlgorithm.h.

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

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

larpandoracontent/v04_14_00/source/larpandoradlcontent/LArVertex/DlSecondaryVertexingAlgorithm.h
larpandoracontent/v04_14_00/source/larpandoradlcontent/LArVertex/DlSecondaryVertexingAlgorithm.cc

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation