DeepLearningTrackShowerIdAlgorithm class. More...

#include "DlVertexingAlgorithm.h"

Inheritance diagram for lar_dl_content::DlVertexingAlgorithm:

Classes
class	VertexTuple

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

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

virtual	~DlVertexingAlgorithm ()

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

typedef std::vector< Pixel >	PixelVector

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	MakeWirePlaneCoordinatesFromCanvas (float **canvas, const int canvasWidth, const int canvasHeight, const int columnOffset, const int rowOffset, const pandora::HitType view, const float xMin, const float xMax, const float zMin, const float zMax, pandora::CartesianPointVector &positionVector) 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...

void	DrawRing (float **canvas, const int row, const int col, const int inner, const int outer, const float weight) const
	Add a filled ring to the specified canvas. The ring has an inner radius based on the minimum predicted distance to the vertex and an outer radius based on the maximum predicted distance to the vertex. The centre of the ring is the location of the hit used to predict the distance to the vertex. Each pixel to be filled is augmented by the specified weight. In this way, once all hits have been considered, a consensus view emerges of the likely vertex location based on the overlap of various rings centred at different locations. More...

void	Update (const int radius, int &col, int &row) const
	Update the coordinates along the loci of a circle. When drawing the ring we need an efficient means to determine the next pixel defining the inner and outer loci of the ring. This update function uses the Bresenham midpoint circle update function to determine this location. The row position is always incremented by 1 pixel, the column position is left unchanged, or decremented by 1 pixel to best follow the arc of the true underlying circle. More...

pandora::StatusCode	GetMCToHitsMap (LArMCParticleHelper::MCContributionMap &mcToHitsMap) const

pandora::StatusCode	CompleteMCHierarchy (const LArMCParticleHelper::MCContributionMap &mcToHitsMap, pandora::MCParticleList &mcHierarchy) const

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

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

void	GetTrueVertexPosition (float &x, float &y, float &z) const
	Retrieve the true neutrino vertex position. More...

void	GetTrueVertexPosition (float &x, float &u, float &v, float &w) const
	Retrieve the true neutrino vertex position. More...

const pandora::CartesianVector &	GetTrueVertex () const
	Retrieve the true neutrino vertex. More...

Private 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_event
	The current event number. 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...

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...

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...

Detailed Description

DeepLearningTrackShowerIdAlgorithm class.

Definition at line 27 of file DlVertexingAlgorithm.h.

Member Typedef Documentation

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

private

Definition at line 58 of file DlVertexingAlgorithm.h.

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

Definition at line 30 of file DlVertexingAlgorithm.h.

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

private

Definition at line 59 of file DlVertexingAlgorithm.h.

Constructor & Destructor Documentation

lar_dl_content::DlVertexingAlgorithm::DlVertexingAlgorithm ( )

Default constructor.

Definition at line 28 of file DlVertexingAlgorithm.cc.

References m_driftStep, m_event, m_height, m_nClasses, m_pass, m_rng, m_trainingOutputFile, m_visualise, m_volumeType, m_width, and m_writeTree.

                                            :
     m_trainingMode{false},
     m_trainingOutputFile{""},
     m_event{-1},
     m_pass{1},
     m_nClasses{0},
     m_height{256},
     m_width{256},
     m_driftStep{0.5f},
     m_visualise{false},
     m_writeTree{false},
     m_rng(static_cast<std::mt19937::result_type>(std::chrono::high_resolution_clock::now().time_since_epoch().count())),
     m_volumeType{"dune_fd_hd"}
 {
 }

lar_dl_content::DlVertexingAlgorithm::~DlVertexingAlgorithm ( )

virtual

Definition at line 44 of file DlVertexingAlgorithm.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

StatusCode lar_dl_content::DlVertexingAlgorithm::CompleteMCHierarchy	(	const LArMCParticleHelper::MCContributionMap &	mcToHitsMap,
		pandora::MCParticleList &	mcHierarchy
	)		const

private

Definition at line 562 of file DlVertexingAlgorithm.cc.

References e, and hits().

Referenced by PrepareTrainingSample().

 {
     try
     {
         for (const auto &[mc, hits] : mcToHitsMap)
         {
             (void)hits;
             mcHierarchy.push_back(mc);
             LArMCParticleHelper::GetAllAncestorMCParticles(mc, mcHierarchy);
         }
     }
     catch (const StatusCodeException &e)
     {
         return e.GetStatusCode();
     }
 
     // Move the neutrino to the front of the list
     auto pivot =
         std::find_if(mcHierarchy.begin(), mcHierarchy.end(), [](const MCParticle *mc) -> bool { return LArMCParticleHelper::IsNeutrino(mc); });
     (void)pivot;
     if (pivot != mcHierarchy.end())
         std::rotate(mcHierarchy.begin(), pivot, std::next(pivot));
     else
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

void lar_dl_content::DlVertexingAlgorithm::DrawRing	(	float **	canvas,
		const int	row,
		const int	col,
		const int	inner,
		const int	outer,
		const float	weight
	)		const

private

Add a filled ring to the specified canvas. The ring has an inner radius based on the minimum predicted distance to the vertex and an outer radius based on the maximum predicted distance to the vertex. The centre of the ring is the location of the hit used to predict the distance to the vertex. Each pixel to be filled is augmented by the specified weight. In this way, once all hits have been considered, a consensus view emerges of the likely vertex location based on the overlap of various rings centred at different locations.

The underlying implementation is a variant of the Bresenham midpoint circle algorithm and therefore only computes pixel coordinates for one octant of each circle (one of radius 'inner', one of radius 'outer') and interpolates the fill between points using integer arithmetic, guaranteeing each pixel of the ring is filled once and only once, and then mirrored to the remaining seven octants.

Parameters

networkOutput	The TorchOutput object populated by the network inference step
pixelVector	The vector of populated pixels
thresholds	The fractional distance thresholds representing the classes predicted by the network
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 475 of file DlVertexingAlgorithm.cc.

References c1, c2, Update(), and weight.

Referenced by Infer().

 {
     // Set the starting position for each circle bounding the ring
     int c1{inner}, r1{0}, c2{outer}, r2{0};
     int inner2{inner * inner}, outer2{outer * outer};
     while (c2 >= r2)
     {
         // Set the output pixel location
         int rp2{r2}, cp2{c2};
         // We're still within the octant for the inner ring, so use the inner pixel location (see Update comment below)
         // Note also that the inner row is always the same as the outer row, so no need to define rp1
         int cp1{c1};
         if (c1 <= r1)
         { // We've completed the arc of the inner ring already, so just move radially out from here (see Update comment below)
             cp1 = r2;
         }
         // Fill the pixels from inner to outer in the current row and their mirror pixels in the other octants
         for (int c = cp1; c <= cp2; ++c)
         {
             canvas[row + rp2][col + c] += weight;
             if (rp2 != c)
                 canvas[row + c][col + rp2] += weight;
             if (rp2 != 0 && cp2 != 0)
             {
                 canvas[row - rp2][col - c] += weight;
                 if (rp2 != c)
                     canvas[row - c][col - rp2] += weight;
             }
             if (rp2 != 0)
             {
                 canvas[row - rp2][col + c] += weight;
                 if (rp2 != c)
                     canvas[row + c][col - rp2] += weight;
             }
             if (cp2 != 0)
             {
                 canvas[row + rp2][col - c] += weight;
                 if (rp2 != c)
                     canvas[row - c][col + rp2] += weight;
             }
         }
         // Only update the inner location while it remains in the octant (outer ring also remains in the octant of course, but the logic of
         // the update means that the inner ring can leave its octant before the outer ring is complete, so we need to stop that)
         if (c1 > r1)
             this->Update(inner2, c1, r1);
         // Update the outer location - increase the row position with every step, decrease the column position if conditions are met
         this->Update(outer2, c2, r2);
     }
 }

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

private

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 440 of file DlVertexingAlgorithm.cc.

References col, m_height, m_thresholds, and m_width.

Referenced by 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<long, 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::DlVertexingAlgorithm::GetHitRegion	(	const pandora::CaloHitList &	caloHitList,
		float &	xMin,
		float &	xMax,
		float &	zMin,
		float &	zMax
	)		const

private

Definition at line 592 of file DlVertexingAlgorithm.cc.

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

Referenced by Infer(), 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::DlVertexingAlgorithm::GetMCToHitsMap ( LArMCParticleHelper::MCContributionMap & mcToHitsMap ) const

private

Definition at line 545 of file DlVertexingAlgorithm.cc.

References lar_content::LArMCParticleHelper::PrimaryParameters::m_maxPhotonPropagation.

Referenced by PrepareTrainingSample().

 {
     const CaloHitList *pCaloHitList2D(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, "CaloHitList2D", pCaloHitList2D));
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));
 
     LArMCParticleHelper::PrimaryParameters parameters;
     parameters.m_maxPhotonPropagation = std::numeric_limits<float>::max();
     LArMCParticleHelper::SelectReconstructableMCParticles(
         pMCParticleList, pCaloHitList2D, parameters, LArMCParticleHelper::IsBeamNeutrinoFinalState, mcToHitsMap);
 
     return STATUS_CODE_SUCCESS;
 }

const CartesianVector & lar_dl_content::DlVertexingAlgorithm::GetTrueVertex ( ) const

private

Retrieve the true neutrino vertex.

Definition at line 753 of file DlVertexingAlgorithm.cc.

References m_event, m_pass, m_rootTreeName, m_volumeType, and m_writeTree.

Referenced by GetTrueVertexPosition().

 {
     const MCParticleList *pMCParticleList{nullptr};
     if (STATUS_CODE_SUCCESS == PandoraContentApi::GetCurrentList(*this, pMCParticleList) && pMCParticleList)
     {
         MCParticleVector primaries;
         LArMCParticleHelper::GetPrimaryMCParticleList(pMCParticleList, primaries);
         if (!primaries.empty())
         {
             const MCParticle *primary{primaries.front()};
             const MCParticleList &parents{primary->GetParentList()};
             if (parents.size() == 1)
             {
                 const MCParticle *trueNeutrino{parents.front()};
                 if (LArMCParticleHelper::IsNeutrino(trueNeutrino))
                     return primaries.front()->GetVertex();
             }
         }
     }
 
     throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 }

void lar_dl_content::DlVertexingAlgorithm::GetTrueVertexPosition	(	float &	x,
		float &	y,
		float &	z
	)		const

private

Retrieve the true neutrino vertex position.

Definition at line 731 of file DlVertexingAlgorithm.cc.

References GetTrueVertex().

Referenced by Infer().

 {
     const CartesianVector &trueVertex{this->GetTrueVertex()};
     x = trueVertex.GetX();
     y = trueVertex.GetY();
     z = trueVertex.GetZ();
 }

void lar_dl_content::DlVertexingAlgorithm::GetTrueVertexPosition	(	float &	x,
		float &	u,
		float &	v,
		float &	w
	)		const

private

Retrieve the true neutrino vertex position.

Definition at line 741 of file DlVertexingAlgorithm.cc.

References GetTrueVertex().

 {
     const CartesianVector &trueVertex{this->GetTrueVertex()};
     const LArTransformationPlugin *transform{this->GetPandora().GetPlugins()->GetLArTransformationPlugin()};
     x = trueVertex.GetX();
     u = static_cast<float>(transform->YZtoU(trueVertex.GetY(), trueVertex.GetZ()));
     v = static_cast<float>(transform->YZtoV(trueVertex.GetY(), trueVertex.GetZ()));
     w = static_cast<float>(transform->YZtoW(trueVertex.GetY(), trueVertex.GetZ()));
 }

StatusCode lar_dl_content::DlVertexingAlgorithm::Infer ( )

private

Definition at line 171 of file DlVertexingAlgorithm.cc.

References col, DrawRing(), e, f, lar_dl_content::LArDLHelper::Forward(), GetCanvasParameters(), GetHitRegion(), GetTrueVertexPosition(), m_caloHitListNames, m_event, m_height, m_modelU, m_modelV, m_modelW, m_nClasses, m_pass, m_thresholds, m_visualise, m_width, MakeCandidateVertexList(), MakeNetworkInputFromHits(), MakeWirePlaneCoordinatesFromCanvas(), w, and x.

Referenced by Run().

 {
     if (m_pass == 1)
         ++m_event;
 
     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);
     }
 
     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));
 
         HitType view{pCaloHitList->front()->GetHitType()};
         const bool isU{view == TPC_VIEW_U}, isV{view == TPC_VIEW_V}, isW{view == TPC_VIEW_W};
         if (!isU && !isV && !isW)
             return STATUS_CODE_NOT_ALLOWED;
 
         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;
         if (isU)
             LArDLHelper::Forward(m_modelU, inputs, output);
         else if (isV)
             LArDLHelper::Forward(m_modelV, inputs, output);
         else
             LArDLHelper::Forward(m_modelW, inputs, output);
 
         int colOffset{0}, rowOffset{0}, canvasWidth{m_width}, canvasHeight{m_height};
         this->GetCanvasParameters(output, pixelVector, colOffset, rowOffset, canvasWidth, canvasHeight);
 
         float **canvas{new float *[canvasHeight]};
         for (int row = 0; row < canvasHeight; ++row)
             canvas[row] = new float[canvasWidth]{};
 
         // 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])))};
                 this->DrawRing(canvas, row + rowOffset, col + colOffset, inner, outer, 1.f / (outer * outer - inner * inner));
             }
         }
 
         CartesianPointVector positionVector;
         this->MakeWirePlaneCoordinatesFromCanvas(
             canvas, canvasWidth, canvasHeight, colOffset, rowOffset, view, driftMin, driftMax, wireMin[view], wireMax[view], positionVector);
         if (isU)
             vertexCandidatesU.emplace_back(positionVector.front());
         else if (isV)
             vertexCandidatesV.emplace_back(positionVector.front());
         else
             vertexCandidatesW.emplace_back(positionVector.front());
 
 #ifdef MONITORING
         if (m_visualise)
         {
             PANDORA_MONITORING_API(SetEveDisplayParameters(this->GetPandora(), true, DETECTOR_VIEW_XZ, -1.f, 1.f, 1.f));
             try
             {
                 float x{0.f}, u{0.f}, v{0.f}, w{0.f};
                 this->GetTrueVertexPosition(x, u, v, w);
                 if (isU)
                 {
                     const CartesianVector trueVertex(x, 0.f, u);
                     PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &trueVertex, "U(true)", BLUE, 3));
                 }
                 else if (isV)
                 {
                     const CartesianVector trueVertex(x, 0.f, v);
                     PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &trueVertex, "V(true)", BLUE, 3));
                 }
                 else if (isW)
                 {
                     const CartesianVector trueVertex(x, 0.f, w);
                     PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &trueVertex, "W(true)", BLUE, 3));
                 }
             }
             catch (StatusCodeException &e)
             {
                 std::cerr << "DlVertexingAlgorithm: Warning. Couldn't find true vertex." << std::endl;
             }
             for (const auto &pos : positionVector)
             {
                 std::string label{isU ? "U" : isV ? "V" : "W"};
                 PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &pos, label, RED, 3));
             }
             PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
         }
 #endif
 
         for (int row = 0; row < canvasHeight; ++row)
             delete[] canvas[row];
         delete[] canvas;
     }
 
     int nEmptyLists{0};
     if (vertexCandidatesU.empty())
         ++nEmptyLists;
     if (vertexCandidatesV.empty())
         ++nEmptyLists;
     if (vertexCandidatesW.empty())
         ++nEmptyLists;
     std::vector<VertexTuple> vertexTuples;
     CartesianPointVector candidates3D;
     if (nEmptyLists == 0)
     {
         vertexTuples.emplace_back(VertexTuple(this->GetPandora(), vertexCandidatesU.front(), vertexCandidatesV.front(), vertexCandidatesW.front()));
     }
     else if (nEmptyLists == 1)
     {
         if (vertexCandidatesU.empty())
         { // V and W available
             vertexTuples.emplace_back(VertexTuple(this->GetPandora(), vertexCandidatesV.front(), vertexCandidatesW.front(), TPC_VIEW_V, TPC_VIEW_W));
         }
         else if (vertexCandidatesV.empty())
         { // U and W available
             vertexTuples.emplace_back(VertexTuple(this->GetPandora(), vertexCandidatesU.front(), vertexCandidatesW.front(), TPC_VIEW_U, TPC_VIEW_W));
         }
         else
         { // U and V available
             vertexTuples.emplace_back(VertexTuple(this->GetPandora(), vertexCandidatesU.front(), vertexCandidatesV.front(), TPC_VIEW_U, TPC_VIEW_V));
         }
     }
     else
     { // Not enough views to reconstruct a 3D vertex
         std::cout << "Insufficient 2D vertices to reconstruct a 3D vertex" << std::endl;
         return STATUS_CODE_NOT_FOUND;
     }
 
     if (m_visualise)
     {
         PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &vertexTuples.front().GetPosition(), "candidate", GREEN, 1));
     }
 
     if (!vertexTuples.empty())
     {
         const CartesianVector &vertex{vertexTuples.front().GetPosition()};
         CartesianPointVector vertexCandidates;
         vertexCandidates.emplace_back(vertex);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->MakeCandidateVertexList(vertexCandidates));
     }
     else
     {
         std::cout << "Insufficient 2D vertices to reconstruct a 3D vertex" << std::endl;
         return STATUS_CODE_NOT_FOUND;
     }
 
     if (m_visualise)
     {
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlVertexingAlgorithm::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 707 of file DlVertexingAlgorithm.cc.

References 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));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Vertex>(*this, m_outputVertexListName));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlVertexingAlgorithm::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 356 of file DlVertexingAlgorithm.cc.

References util::begin(), col, lar_dl_content::LArDLHelper::InitialiseInput(), m_driftStep, m_height, m_pass, 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());
 
     // Determine the bin edges
     std::vector<double> xBinEdges(m_width + 1);
     std::vector<double> zBinEdges(m_height + 1);
     xBinEdges[0] = xMin - 0.5f * m_driftStep;
     const double dx = ((xMax + 0.5f * m_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::DlVertexingAlgorithm::MakeWirePlaneCoordinatesFromCanvas	(	float **	canvas,
		const int	canvasWidth,
		const int	canvasHeight,
		const int	columnOffset,
		const int	rowOffset,
		const pandora::HitType	view,
		const float	xMin,
		const float	xMax,
		const float	zMin,
		const float	zMax,
		pandora::CartesianPointVector &	positionVector
	)		const

private

Definition at line 407 of file DlVertexingAlgorithm.cc.

References util::begin(), col, f, m_driftStep, m_height, m_width, pt, 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 double dx = ((xMax + 0.5f * m_driftStep) - (xMin - 0.5f * m_driftStep)) / m_width;
     const double dz = ((zMax + 0.5f * pitch) - (zMin - 0.5f * pitch)) / m_height;
 
     float best{-1.f};
     int rowBest{0}, colBest{0};
     for (int row = 0; row < canvasHeight; ++row)
         for (int col = 0; col < canvasWidth; ++col)
             if (canvas[row][col] > 0 && canvas[row][col] > best)
             {
                 best = canvas[row][col];
                 rowBest = row;
                 colBest = col;
             }
 
     const float x{static_cast<float>((colBest - columnOffset) * dx + xMin)};
     const float z{static_cast<float>((rowBest - rowOffset) * dz + zMin)};
 
     CartesianVector pt(x, 0.f, z);
     positionVector.emplace_back(pt);
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlVertexingAlgorithm::PrepareTrainingSample ( )

private

Definition at line 71 of file DlVertexingAlgorithm.cc.

References CompleteMCHierarchy(), f, GetHitRegion(), GetMCToHitsMap(), m_caloHitListNames, m_pass, m_trainingOutputFile, x, and z.

Referenced by Run().

 {
     LArMCParticleHelper::MCContributionMap mcToHitsMap;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetMCToHitsMap(mcToHitsMap));
     MCParticleList hierarchy;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->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 bool isU{view == TPC_VIEW_U}, isV{view == TPC_VIEW_V}, isW{view == TPC_VIEW_W};
         if (!(isU || isV || isW))
             return STATUS_CODE_NOT_ALLOWED;
 
         CartesianPointVector vertices;
         for (const MCParticle *mc : hierarchy)
         {
             if (LArMCParticleHelper::IsNeutrino(mc))
                 vertices.push_back(mc->GetVertex());
         }
         if (vertices.empty())
             continue;
         const CartesianVector &vertex{vertices.front()};
         const std::string trainingFilename{m_trainingOutputFile + "_" + listname + ".csv"};
         const unsigned long nVertices{1};
         unsigned long nHits{0};
         const unsigned int nuance{LArMCParticleHelper::GetNuanceCode(hierarchy.front())};
 
         // Vertices
         const LArTransformationPlugin *transform{this->GetPandora().GetPlugins()->GetLArTransformationPlugin()};
         const double xVtx{vertex.GetX()};
         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());
 
         // Calo hits
         double xMin{driftMin}, xMax{driftMax}, zMin{wireMin[view]}, zMax{wireMax[view]};
 
         // Only train on events where the vertex resides within the image - with a small tolerance
         if (!(xVtx > (xMin - 1.f) && xVtx < (xMax + 1.f) && zVtx > (zMin - 1.f) && zVtx < (zMax + 1.f)))
             continue;
 
         LArMvaHelper::MvaFeatureVector featureVector;
         featureVector.emplace_back(static_cast<double>(nuance));
         featureVector.emplace_back(static_cast<double>(nVertices));
         featureVector.emplace_back(xVtx);
         featureVector.emplace_back(zVtx);
         // Retain the hit region
         featureVector.emplace_back(xMin);
         featureVector.emplace_back(xMax);
         featureVector.emplace_back(zMin);
         featureVector.emplace_back(zMax);
 
         for (const CaloHit *pCaloHit : *pCaloHitList)
         {
             const float x{pCaloHit->GetPositionVector().GetX()}, z{pCaloHit->GetPositionVector().GetZ()}, adc{pCaloHit->GetMipEquivalentEnergy()};
             // If on a refinement pass, drop hits outside the region of interest
             if (m_pass > 1 && (x < xMin || x > xMax || z < zMin || z > zMax))
                 continue;
             featureVector.emplace_back(static_cast<double>(x));
             featureVector.emplace_back(static_cast<double>(z));
             featureVector.emplace_back(static_cast<double>(adc));
             ++nHits;
         }
         featureVector.insert(featureVector.begin() + 8, 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::DlVertexingAlgorithm::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 842 of file DlVertexingAlgorithm.cc.

References f, lar_dl_content::LArDLHelper::LoadModel(), m_caloHitListNames, m_driftStep, m_height, m_inputVertexListName, m_modelU, m_modelV, m_modelW, m_nClasses, m_outputVertexListName, m_pass, m_rootFileName, m_rootTreeName, m_thresholds, m_trainingMode, m_trainingOutputFile, m_visualise, m_volumeType, m_width, m_writeTree, and lar_dl_content::DlVertexingAlgorithm::VertexTuple::VertexTuple().

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingMode", m_trainingMode));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Visualise", m_visualise));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Pass", m_pass));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ImageHeight", m_height));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ImageWidth", m_width));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DriftStep", m_driftStep));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "DistanceThresholds", m_thresholds));
     m_nClasses = m_thresholds.size() - 1;
     if (m_pass > 1)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputVertexListName", m_inputVertexListName));
     }
 
     if (m_trainingMode)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrainingOutputFileName", m_trainingOutputFile));
     }
     else
     {
         std::string modelName;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ModelFileNameU", modelName));
         modelName = LArFileHelper::FindFileInPath(modelName, "FW_SEARCH_PATH");
         LArDLHelper::LoadModel(modelName, m_modelU);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ModelFileNameV", modelName));
         modelName = LArFileHelper::FindFileInPath(modelName, "FW_SEARCH_PATH");
         LArDLHelper::LoadModel(modelName, m_modelV);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ModelFileNameW", modelName));
         modelName = LArFileHelper::FindFileInPath(modelName, "FW_SEARCH_PATH");
         LArDLHelper::LoadModel(modelName, m_modelW);
         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));
         }
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputVertexListName", m_outputVertexListName));
     }
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "CaloHitListNames", m_caloHitListNames));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VolumeType", m_volumeType));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DlVertexingAlgorithm::Run ( )

private

Definition at line 61 of file DlVertexingAlgorithm.cc.

References Infer(), m_trainingMode, and PrepareTrainingSample().

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

void lar_dl_content::DlVertexingAlgorithm::Update	(	const int	radius,
		int &	col,
		int &	row
	)		const

private

Update the coordinates along the loci of a circle. When drawing the ring we need an efficient means to determine the next pixel defining the inner and outer loci of the ring. This update function uses the Bresenham midpoint circle update function to determine this location. The row position is always incremented by 1 pixel, the column position is left unchanged, or decremented by 1 pixel to best follow the arc of the true underlying circle.

Parameters

radius2	The squared radius of the circle under consideration
col	The input/output column position to (potentially) update
row	The input/output row position to update

Definition at line 527 of file DlVertexingAlgorithm.cc.

References col.

Referenced by DrawRing().

 {
     // Bresenham midpoint circle algorithm to determine if we should update the column position
     // This obscure looking block of code uses bit shifts and integer arithmetic to perform this check as efficiently as possible
     const int a{1 - (col << 2)};
     const int b{col * col + row * row - radius2 + (row << 2) + 1};
     const int c{(a << 2) * b + a * a};
     if (c < 0)
     {
         --col;
         ++row;
     }
     else
         ++row;
 }

Member Data Documentation

pandora::StringVector lar_dl_content::DlVertexingAlgorithm::m_caloHitListNames

private

Names of input calo hit lists.

Definition at line 223 of file DlVertexingAlgorithm.h.

Referenced by GetHitRegion(), Infer(), PrepareTrainingSample(), and ReadSettings().

float lar_dl_content::DlVertexingAlgorithm::m_driftStep

private

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

Definition at line 232 of file DlVertexingAlgorithm.h.

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

int lar_dl_content::DlVertexingAlgorithm::m_event

private

The current event number.

Definition at line 227 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), GetTrueVertex(), and Infer().

int lar_dl_content::DlVertexingAlgorithm::m_height

private

The height of the images.

Definition at line 230 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), GetCanvasParameters(), GetHitRegion(), Infer(), MakeNetworkInputFromHits(), MakeWirePlaneCoordinatesFromCanvas(), and ReadSettings().

std::string lar_dl_content::DlVertexingAlgorithm::m_inputVertexListName

private

Input vertex list name if 2nd pass.

Definition at line 221 of file DlVertexingAlgorithm.h.

Referenced by GetHitRegion(), and ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DlVertexingAlgorithm::m_modelU

private

The model for the U view.

Definition at line 224 of file DlVertexingAlgorithm.h.

Referenced by Infer(), and ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DlVertexingAlgorithm::m_modelV

private

The model for the V view.

Definition at line 225 of file DlVertexingAlgorithm.h.

Referenced by Infer(), and ReadSettings().

LArDLHelper::TorchModel lar_dl_content::DlVertexingAlgorithm::m_modelW

private

The model for the W view.

Definition at line 226 of file DlVertexingAlgorithm.h.

Referenced by Infer(), and ReadSettings().

int lar_dl_content::DlVertexingAlgorithm::m_nClasses

private

The number of distance classes.

Definition at line 229 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), Infer(), and ReadSettings().

std::string lar_dl_content::DlVertexingAlgorithm::m_outputVertexListName

private

Output vertex list name.

Definition at line 222 of file DlVertexingAlgorithm.h.

Referenced by MakeCandidateVertexList(), and ReadSettings().

int lar_dl_content::DlVertexingAlgorithm::m_pass

private

The pass of the train/infer step.

Definition at line 228 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), GetHitRegion(), GetTrueVertex(), Infer(), MakeNetworkInputFromHits(), PrepareTrainingSample(), and ReadSettings().

std::mt19937 lar_dl_content::DlVertexingAlgorithm::m_rng

private

The random number generator.

Definition at line 237 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm().

std::string lar_dl_content::DlVertexingAlgorithm::m_rootFileName

private

The ROOT file name.

Definition at line 236 of file DlVertexingAlgorithm.h.

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

std::string lar_dl_content::DlVertexingAlgorithm::m_rootTreeName

private

The ROOT tree name.

Definition at line 235 of file DlVertexingAlgorithm.h.

Referenced by GetTrueVertex(), ReadSettings(), and ~DlVertexingAlgorithm().

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

private

Distance class thresholds.

Definition at line 238 of file DlVertexingAlgorithm.h.

Referenced by GetCanvasParameters(), Infer(), and ReadSettings().

bool lar_dl_content::DlVertexingAlgorithm::m_trainingMode

private

Training mode.

Definition at line 219 of file DlVertexingAlgorithm.h.

Referenced by ReadSettings(), and Run().

std::string lar_dl_content::DlVertexingAlgorithm::m_trainingOutputFile

private

Output file name for training examples.

Definition at line 220 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), PrepareTrainingSample(), and ReadSettings().

bool lar_dl_content::DlVertexingAlgorithm::m_visualise

private

Whether or not to visualise the candidate vertices.

Definition at line 233 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), Infer(), and ReadSettings().

std::string lar_dl_content::DlVertexingAlgorithm::m_volumeType

private

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

Definition at line 239 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), GetTrueVertex(), and ReadSettings().

int lar_dl_content::DlVertexingAlgorithm::m_width

private

The width of the images.

Definition at line 231 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), GetCanvasParameters(), GetHitRegion(), Infer(), MakeNetworkInputFromHits(), MakeWirePlaneCoordinatesFromCanvas(), and ReadSettings().

bool lar_dl_content::DlVertexingAlgorithm::m_writeTree

private

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

Definition at line 234 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), GetTrueVertex(), ReadSettings(), and ~DlVertexingAlgorithm().

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

larpandoracontent/v04_08_01/source/larpandoradlcontent/LArVertex/DlVertexingAlgorithm.h
larpandoracontent/v04_08_01/source/larpandoradlcontent/LArVertex/DlVertexingAlgorithm.cc

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation