DeepLearningTrackShowerIdAlgorithm class. More...

#include "DlVertexingAlgorithm.h"

Inheritance diagram for lar_dl_content::DlVertexingAlgorithm:

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

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

	~DlVertexingAlgorithm ()

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

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 29 of file DlVertexingAlgorithm.h.

Member Typedef Documentation

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::DlVertexingAlgorithm::DlVertexingAlgorithm ( )

Default constructor.

Definition at line 30 of file DlVertexingAlgorithm.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::DlVertexingAlgorithm::~DlVertexingAlgorithm ( )

Definition at line 38 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

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 Infer(), and lar_dl_content::DlSecondaryVertexingAlgorithm::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 Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::Infer(), PrepareTrainingSample(), and lar_dl_content::DlSecondaryVertexingAlgorithm::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::Infer ( )

private

Definition at line 169 of file DlVertexingAlgorithm.cc.

Referenced by Run().

 {
     if (m_pass == 1)
     {
         ++m_event;
     }
     else
     {
         // INFO: Check if there is a zoom in region for the second pass.
         const VertexList *pVertexList(nullptr);
         PandoraContentApi::GetList(*this, m_inputVertexListName, pVertexList);
         if (pVertexList == nullptr || pVertexList->empty())
         {
             std::cout << "DLVertexing: Input vertex list is empty! Can't perform pass " << m_pass << std::endl;
             return STATUS_CODE_SUCCESS;
         }
     }
 
     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<int64_t, 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(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));
             const MCParticleList *pMCParticleList{nullptr};
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));
 
             CartesianVector trueVertex3D(0, 0, 0);
             if (LArMCParticleHelper::GetTrueVertex(pMCParticleList, trueVertex3D))
             {
                 float x{0.f}, u{0.f}, v{0.f}, w{0.f};
                 const LArTransformationPlugin *transform{this->GetPandora().GetPlugins()->GetLArTransformationPlugin()};
                 LArVertexHelper::GetTrueVertexPosition(trueVertex3D, transform, 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));
                 }
                 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 452 of file DlVertexingAlgorithm.cc.

References m_event, lar_dl_content::DlVertexingBaseAlgorithm::m_outputVertexListName, lar_dl_content::DlVertexingBaseAlgorithm::m_pass, m_rootTreeName, lar_dl_content::DlVertexingBaseAlgorithm::m_volumeType, and m_writeTree.

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

References util::begin(), col, lar_dl_content::LArDLHelper::InitialiseInput(), lar_dl_content::DlVertexingBaseAlgorithm::m_driftStep, 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());
 
     // 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 419 of file DlVertexingAlgorithm.cc.

References util::begin(), col, f, lar_dl_content::DlVertexingBaseAlgorithm::m_driftStep, lar_dl_content::DlVertexingBaseAlgorithm::m_height, lar_dl_content::DlVertexingBaseAlgorithm::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 65 of file DlVertexingAlgorithm.cc.

References f, lar_dl_content::DlVertexingBaseAlgorithm::GetHitRegion(), lar_dl_content::DlVertexingBaseAlgorithm::m_caloHitListNames, lar_dl_content::DlVertexingBaseAlgorithm::m_pass, lar_dl_content::DlVertexingBaseAlgorithm::m_trainingOutputFile, x, and z.

Referenced by Run().

 {
     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::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 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 540 of file DlVertexingAlgorithm.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::DlVertexingAlgorithm::Run ( )

private

Definition at line 55 of file DlVertexingAlgorithm.cc.

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

 {
     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(), Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::Infer(), PrepareTrainingSample(), lar_dl_content::DlSecondaryVertexingAlgorithm::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(), MakeNetworkInputFromHits(), MakeWirePlaneCoordinatesFromCanvas(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

int lar_dl_content::DlVertexingAlgorithm::m_event

private

The current event number.

Definition at line 99 of file DlVertexingAlgorithm.h.

Referenced by Infer(), and MakeCandidateVertexList().

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(), lar_dl_content::DlSecondaryVertexingAlgorithm::GetVerticesFromCanvas(), Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::Infer(), MakeNetworkInputFromHits(), lar_dl_content::DlSecondaryVertexingAlgorithm::MakeNetworkInputFromHits(), 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(), 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 Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::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 Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::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 Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::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(), Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::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 MakeCandidateVertexList(), lar_dl_content::DlSecondaryVertexingAlgorithm::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(), Infer(), MakeCandidateVertexList(), MakeNetworkInputFromHits(), lar_dl_content::DlSecondaryVertexingAlgorithm::MakeNetworkInputFromHits(), PrepareTrainingSample(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

std::mt19937 lar_dl_content::DlVertexingAlgorithm::m_rng

private

The random number generator.

Definition at line 104 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm().

std::string lar_dl_content::DlVertexingAlgorithm::m_rootFileName

private

The ROOT file name.

Definition at line 103 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 102 of file DlVertexingAlgorithm.h.

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

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(), Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::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 ReadSettings(), lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings(), lar_dl_content::DlSecondaryVertexingAlgorithm::ReadSettings(), Run(), and lar_dl_content::DlSecondaryVertexingAlgorithm::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(), PrepareTrainingSample(), lar_dl_content::DlSecondaryVertexingAlgorithm::PrepareTrainingSample(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

bool lar_dl_content::DlVertexingAlgorithm::m_visualise

private

Whether or not to visualise the candidate vertices.

Definition at line 100 of file DlVertexingAlgorithm.h.

Referenced by DlVertexingAlgorithm(), Infer(), 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(), MakeCandidateVertexList(), lar_dl_content::DlSecondaryVertexingAlgorithm::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(), lar_dl_content::DlSecondaryVertexingAlgorithm::GetVerticesFromCanvas(), Infer(), lar_dl_content::DlSecondaryVertexingAlgorithm::Infer(), MakeNetworkInputFromHits(), lar_dl_content::DlSecondaryVertexingAlgorithm::MakeNetworkInputFromHits(), MakeWirePlaneCoordinatesFromCanvas(), and lar_dl_content::DlVertexingBaseAlgorithm::ReadSettings().

bool lar_dl_content::DlVertexingAlgorithm::m_writeTree

private

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

Definition at line 101 of file DlVertexingAlgorithm.h.

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

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

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation