lar_dl_content::DlHitTrackShowerIdAlgorithm Class Reference

DlHitTrackShowerIdAlgorithm class. More...

#include <DlHitTrackShowerIdAlgorithm.h>

Inheritance diagram for lar_dl_content::DlHitTrackShowerIdAlgorithm:

Public Member Functions
	DlHitTrackShowerIdAlgorithm ()
	Default constructor. More...
virtual	~DlHitTrackShowerIdAlgorithm ()

Private Types
typedef std::map< const pandora::CaloHit *, std::tuple < int, int, int, int > >	CaloHitToPixelMap
typedef std::map< int, int >	PixelToTileMap

Private Member Functions
pandora::StatusCode	Run ()
pandora::StatusCode	Train ()
	Produce files that act as inputs to network training. More...
pandora::StatusCode	Infer ()
	Run network inference. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
void	GetHitRegion (const pandora::CaloHitList &caloHitList, float &xMin, float &xMax, float &zMin, float &zMax)
	Identify the XZ range containing the hits for an event. More...
void	GetSparseTileMap (const pandora::CaloHitList &caloHitList, const float xMin, const float zMin, const int nTilesX, PixelToTileMap &sparseMap)
	Populate a map between pixels and tiles. More...

Private Attributes
pandora::StringVector	m_caloHitListNames
	Name of input calo hit list. More...
std::string	m_modelFileNameU
	Model file name for U view. More...
std::string	m_modelFileNameV
	Model file name for V view. More...
std::string	m_modelFileNameW
	Model file name for W view. More...
LArDLHelper::TorchModel	m_modelU
	Model for the U view. More...
LArDLHelper::TorchModel	m_modelV
	Model for the V view. More...
LArDLHelper::TorchModel	m_modelW
	Model for the W view. More...
int	m_imageHeight
	Height of images in pixels. More...
int	m_imageWidth
	Width of images in pixels. More...
float	m_tileSize
	Size of tile in cm. More...
bool	m_visualize
	Whether to visualize the track shower ID scores. More...
bool	m_useTrainingMode
	Training mode. More...
std::string	m_trainingOutputFile
	Output file name for training examples. More...

Detailed Description

DlHitTrackShowerIdAlgorithm class.

Definition at line 21 of file DlHitTrackShowerIdAlgorithm.h.

Member Typedef Documentation

typedef std::map<const pandora::CaloHit *, std::tuple<int, int, int, int> > lar_dl_content::DlHitTrackShowerIdAlgorithm::CaloHitToPixelMap

private

Definition at line 32 of file DlHitTrackShowerIdAlgorithm.h.

typedef std::map<int, int> lar_dl_content::DlHitTrackShowerIdAlgorithm::PixelToTileMap

private

Definition at line 33 of file DlHitTrackShowerIdAlgorithm.h.

Constructor & Destructor Documentation

lar_dl_content::DlHitTrackShowerIdAlgorithm::DlHitTrackShowerIdAlgorithm

(

)

Default constructor.

Definition at line 32 of file DlHitTrackShowerIdAlgorithm.cc.

                                                         :
    m_imageHeight(256),
    m_imageWidth(256),
    m_tileSize(128.f),
    m_visualize(false),
    m_useTrainingMode(false),
    m_trainingOutputFile("")
{
}

lar_dl_content::DlHitTrackShowerIdAlgorithm::~DlHitTrackShowerIdAlgorithm ( )

virtual

Definition at line 44 of file DlHitTrackShowerIdAlgorithm.cc.

{
}

Member Function Documentation

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

private

Identify the XZ range containing the hits for an event.

Parameters

caloHitList	The list of CaloHits for which the range is to be found
xMin	The output minimum x-coordinate
xMax	The output maximum x-coordinate
zMin	The output minimum z-coordinate
zMax	The output maximum z-coordinate

Definition at line 313 of file DlHitTrackShowerIdAlgorithm.cc.

{
    xMin = std::numeric_limits<float>::max();
    xMax = -std::numeric_limits<float>::max();
    zMin = std::numeric_limits<float>::max();
    zMax = -std::numeric_limits<float>::max();
    for (const CaloHit *pCaloHit : caloHitList)
    {
        const float x(pCaloHit->GetPositionVector().GetX());
        const float z(pCaloHit->GetPositionVector().GetZ());
        if (x < xMin)
            xMin = x;
        if (x > xMax)
            xMax = x;
        if (z < zMin)
            zMin = z;
        if (z > zMax)
            zMax = z;
    }
}

void lar_dl_content::DlHitTrackShowerIdAlgorithm::GetSparseTileMap ( const pandora::CaloHitList &  caloHitList, const float  xMin, const float  zMin, const int  nTilesX, PixelToTileMap &  sparseMap  )

private

Populate a map between pixels and tiles.

Parameters

caloHitList	The list of CaloHits for which the map is to be populated
xMin	The minimum x-coordinate
zMin	The minimum z-coordinate
nTilesX	The number of tiles in the x direction
sparseMap	The output map between pixels and tiles

Definition at line 336 of file DlHitTrackShowerIdAlgorithm.cc.

{
    // Identify the tiles that actually contain hits
    std::map<int, bool> tilePopulationMap;
    for (const CaloHit *pCaloHit : caloHitList)
    {
        const float x(pCaloHit->GetPositionVector().GetX());
        const float z(pCaloHit->GetPositionVector().GetZ());
        // Determine which tile the hit will be assigned to
        const int tileX = static_cast<int>(std::floor((x - xMin) / m_tileSize));
        const int tileZ = static_cast<int>(std::floor((z - zMin) / m_tileSize));
        const int tile = tileZ * nTilesX + tileX;
        tilePopulationMap.insert(std::make_pair(tile, true));
    }

    int nextTile = 0;
    for (auto element : tilePopulationMap)
    {
        if (element.second)
        {
            sparseMap.insert(std::make_pair(element.first, nextTile));
            ++nextTile;
        }
    }
}

StatusCode lar_dl_content::DlHitTrackShowerIdAlgorithm::Infer ( )

private

Run network inference.

Definition at line 139 of file DlHitTrackShowerIdAlgorithm.cc.

{
    const float eps{1.1920929e-7}; // Python float epsilon, used in image padding

    if (m_visualize)
    {
        PANDORA_MONITORING_API(SetEveDisplayParameters(this->GetPandora(), true, DETECTOR_VIEW_XZ, -1.f, 1.f, 1.f));
    }

    for (const std::string listName : m_caloHitListNames)
    {
        const CaloHitList *pCaloHitList(nullptr);
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listName, pCaloHitList));

        const HitType view{pCaloHitList->front()->GetHitType()};

        if (!(view == TPC_VIEW_U || view == TPC_VIEW_V || view == TPC_VIEW_W))
            return STATUS_CODE_NOT_ALLOWED;

        LArDLHelper::TorchModel &model{view == TPC_VIEW_U ? m_modelU : (view == TPC_VIEW_V ? m_modelV : m_modelW)};

        // Get bounds of hit region
        float xMin{};
        float xMax{};
        float zMin{};
        float zMax{};
        this->GetHitRegion(*pCaloHitList, xMin, xMax, zMin, zMax);
        const float xRange = (xMax + eps) - (xMin - eps);
        int nTilesX = static_cast<int>(std::ceil(xRange / m_tileSize));

        PixelToTileMap sparseMap;
        this->GetSparseTileMap(*pCaloHitList, xMin, zMin, nTilesX, sparseMap);
        const int nTiles = sparseMap.size();

        CaloHitList trackHits, showerHits, otherHits;
        // Process tile
        // ATTN: Be sure to reset all values to zero after each tile has been processed
        float **weights = new float *[m_imageHeight];
        for (int r = 0; r < m_imageHeight; ++r)
            weights[r] = new float[m_imageWidth]();
        for (int i = 0; i < nTiles; ++i)
        {
            for (const CaloHit *pCaloHit : *pCaloHitList)
            {
                const float x(pCaloHit->GetPositionVector().GetX());
                const float z(pCaloHit->GetPositionVector().GetZ());
                // Determine which tile the hit will be assigned to
                const int tileX = static_cast<int>(std::floor((x - xMin) / m_tileSize));
                const int tileZ = static_cast<int>(std::floor((z - zMin) / m_tileSize));
                const int tile = sparseMap.at(tileZ * nTilesX + tileX);
                if (tile == i)
                {
                    // Determine hit position within the tile
                    const float localX = std::fmod(x - xMin, m_tileSize);
                    const float localZ = std::fmod(z - zMin, m_tileSize);
                    // Determine hit pixel within the tile
                    const int pixelX = static_cast<int>(std::floor(localX * m_imageWidth / m_tileSize));
                    const int pixelZ = (m_imageHeight - 1) - static_cast<int>(std::floor(localZ * m_imageHeight / m_tileSize));
                    weights[pixelZ][pixelX] += pCaloHit->GetInputEnergy();
                }
            }

            // Find min and max charge to allow normalisation
            float chargeMin{std::numeric_limits<float>::max()}, chargeMax{-std::numeric_limits<float>::max()};
            for (int r = 0; r < m_imageHeight; ++r)
            {
                for (int c = 0; c < m_imageWidth; ++c)
                {
                    if (weights[r][c] > chargeMax)
                        chargeMax = weights[r][c];
                    if (weights[r][c] < chargeMin)
                        chargeMin = weights[r][c];
                }
            }
            float chargeRange{chargeMax - chargeMin};
            if (chargeRange <= 0.f)
                chargeRange = 1.f;

            // Populate accessor based on normalised weights
            CaloHitToPixelMap caloHitToPixelMap;
            LArDLHelper::TorchInput input;
            LArDLHelper::InitialiseInput({1, 1, m_imageHeight, m_imageWidth}, input);
            auto accessor = input.accessor<float, 4>();
            for (const CaloHit *pCaloHit : *pCaloHitList)
            {
                const float x(pCaloHit->GetPositionVector().GetX());
                const float z(pCaloHit->GetPositionVector().GetZ());
                // Determine which tile the hit will be assigned to
                const int tileX = static_cast<int>(std::floor((x - xMin) / m_tileSize));
                const int tileZ = static_cast<int>(std::floor((z - zMin) / m_tileSize));
                const int tile = sparseMap.at(tileZ * nTilesX + tileX);
                if (tile == i)
                {
                    // Determine hit position within the tile
                    const float localX = std::fmod(x - xMin, m_tileSize);
                    const float localZ = std::fmod(z - zMin, m_tileSize);
                    // Determine hit pixel within the tile
                    const int pixelX = static_cast<int>(std::floor(localX * m_imageWidth / m_tileSize));
                    const int pixelZ = (m_imageHeight - 1) - static_cast<int>(std::floor(localZ * m_imageHeight / m_tileSize));
                    accessor[0][0][pixelZ][pixelX] = (weights[pixelZ][pixelX] - chargeMin) / chargeRange;
                    caloHitToPixelMap.insert(std::make_pair(pCaloHit, std::make_tuple(tileZ, tileX, pixelZ, pixelX)));
                }
            }
            // Reset weights
            for (int r = 0; r < this->m_imageHeight; ++r)
                for (int c = 0; c < this->m_imageWidth; ++c)
                    weights[r][c] = 0.f;

            // Run the input through the trained model and get the output accessor
            LArDLHelper::TorchInputVector inputs;
            inputs.push_back(input);
            LArDLHelper::TorchOutput output;
            LArDLHelper::Forward(model, inputs, output);
            auto outputAccessor = output.accessor<float, 4>();

            for (const CaloHit *pCaloHit : *pCaloHitList)
            {
                auto found{caloHitToPixelMap.find(pCaloHit)};
                if (found == caloHitToPixelMap.end())
                    continue;
                auto pixelMap = found->second;
                const int tileZ(std::get<0>(pixelMap));
                const int tileX(std::get<1>(pixelMap));
                const int tile = sparseMap.at(tileZ * nTilesX + tileX);
                if (tile == i)
                { // Make sure we're looking at a hit in the correct tile
                    const int pixelZ(std::get<2>(pixelMap));
                    const int pixelX(std::get<3>(pixelMap));

                    // Apply softmax to loss to get actual probability
                    float probShower = exp(outputAccessor[0][1][pixelZ][pixelX]);
                    float probTrack = exp(outputAccessor[0][2][pixelZ][pixelX]);
                    float probNull = exp(outputAccessor[0][0][pixelZ][pixelX]);
                    if (probShower > probTrack && probShower > probNull)
                        showerHits.push_back(pCaloHit);
                    else if (probTrack > probShower && probTrack > probNull)
                        trackHits.push_back(pCaloHit);
                    else
                        otherHits.push_back(pCaloHit);
                    float recipSum = 1.f / (probShower + probTrack);
                    // Adjust probabilities to ignore null hits and update LArCaloHit
                    probShower *= recipSum;
                    probTrack *= recipSum;
                    LArCaloHit *pLArCaloHit{const_cast<LArCaloHit *>(dynamic_cast<const LArCaloHit *>(pCaloHit))};
                    pLArCaloHit->SetShowerProbability(probShower);
                    pLArCaloHit->SetTrackProbability(probTrack);
                }
            }
        }
        for (int r = 0; r < this->m_imageHeight; ++r)
            delete[] weights[r];
        delete[] weights;

        if (m_visualize)
        {
            const std::string trackListName("TrackHits_" + listName);
            const std::string showerListName("ShowerHits_" + listName);
            const std::string otherListName("OtherHits_" + listName);
            PANDORA_MONITORING_API(VisualizeCaloHits(this->GetPandora(), &trackHits, trackListName, BLUE));
            PANDORA_MONITORING_API(VisualizeCaloHits(this->GetPandora(), &showerHits, showerListName, RED));
            PANDORA_MONITORING_API(VisualizeCaloHits(this->GetPandora(), &otherHits, otherListName, BLACK));
        }
    }

    if (m_visualize)
    {
        PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
    }

    return STATUS_CODE_SUCCESS;
}

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

private

Definition at line 365 of file DlHitTrackShowerIdAlgorithm.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UseTrainingMode", m_useTrainingMode));

    if (m_useTrainingMode)
    {
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrainingOutputFileName", m_trainingOutputFile));
    }
    else
    {
        bool modelLoaded{false};
        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ModelFileNameU", m_modelFileNameU));
        if (!m_modelFileNameU.empty())
        {
            m_modelFileNameU = LArFileHelper::FindFileInPath(m_modelFileNameU, "FW_SEARCH_PATH");
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_modelFileNameU, m_modelU));
            modelLoaded = true;
        }
        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ModelFileNameV", m_modelFileNameV));
        if (!m_modelFileNameV.empty())
        {
            m_modelFileNameV = LArFileHelper::FindFileInPath(m_modelFileNameV, "FW_SEARCH_PATH");
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_modelFileNameV, m_modelV));
            modelLoaded = true;
        }
        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ModelFileNameW", m_modelFileNameW));
        if (!m_modelFileNameW.empty())
        {
            m_modelFileNameW = LArFileHelper::FindFileInPath(m_modelFileNameW, "FW_SEARCH_PATH");
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLHelper::LoadModel(m_modelFileNameW, m_modelW));
            modelLoaded = true;
        }
        if (!modelLoaded)
        {
            std::cout << "Error: Inference requested, but no model files were successfully loaded" << std::endl;
            return STATUS_CODE_INVALID_PARAMETER;
        }
    }

    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, "ImageHeight", m_imageHeight));
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ImageWidth", m_imageWidth));
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TileSize", m_tileSize));
    if (m_imageHeight <= 0.f || m_imageWidth <= 0.f || m_tileSize <= 0.f)
    {
        std::cout << "Error: Invalid image size specification" << std::endl;
        return STATUS_CODE_INVALID_PARAMETER;
    }
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Visualize", m_visualize));

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_dl_content::DlHitTrackShowerIdAlgorithm::Run ( )

private

Definition at line 50 of file DlHitTrackShowerIdAlgorithm.cc.

{
    if (m_useTrainingMode)
        return this->Train();
    else
        return this->Infer();
}

StatusCode lar_dl_content::DlHitTrackShowerIdAlgorithm::Train ( )

private

Produce files that act as inputs to network training.

Definition at line 60 of file DlHitTrackShowerIdAlgorithm.cc.

{
    const int SHOWER{1}, TRACK{2};
    for (const std::string listName : m_caloHitListNames)
    {
        const CaloHitList *pCaloHitList(nullptr);
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listName, pCaloHitList));
        const MCParticleList *pMCParticleList(nullptr);
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));

        const HitType view{pCaloHitList->front()->GetHitType()};

        if (!(view == TPC_VIEW_U || view == TPC_VIEW_V || view == TPC_VIEW_W))
            return STATUS_CODE_NOT_ALLOWED;

        std::string trainingOutputFileName(m_trainingOutputFile);

        if (view == TPC_VIEW_U)
            trainingOutputFileName += "_CaloHitListU.csv";
        else if (view == TPC_VIEW_V)
            trainingOutputFileName += "_CaloHitListV.csv";
        else if (view == TPC_VIEW_W)
            trainingOutputFileName += "_CaloHitListW.csv";

        LArMCParticleHelper::PrimaryParameters parameters;
        // Only care about reconstructability with respect to the current view, so skip good view check
        parameters.m_minHitsForGoodView = 0;
        // Turn off max photo propagation for now, only care about killing off daughters of neutrons
        parameters.m_maxPhotonPropagation = std::numeric_limits<float>::max();
        LArMCParticleHelper::MCContributionMap targetMCParticleToHitsMap;
        LArMCParticleHelper::SelectReconstructableMCParticles(
            pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsBeamNeutrinoFinalState, targetMCParticleToHitsMap);

        LArMvaHelper::MvaFeatureVector featureVector;
        for (const CaloHit *pCaloHit : *pCaloHitList)
        {
            int tag{TRACK};
            float inputEnergy{0.f};

            try
            {
                const MCParticle *const pMCParticle(MCParticleHelper::GetMainMCParticle(pCaloHit));
                // Throw away non-reconstructable hits
                if (targetMCParticleToHitsMap.find(pMCParticle) == targetMCParticleToHitsMap.end())
                    continue;
                if (LArMCParticleHelper::IsDescendentOf(pMCParticle, 2112))
                    continue;
                inputEnergy = pCaloHit->GetInputEnergy();
                if (inputEnergy < 0.f)
                    continue;

                const int pdg{std::abs(pMCParticle->GetParticleId())};
                if (pdg == 11 || pdg == 22)
                    tag = SHOWER;
                else
                    tag = TRACK;
            }
            catch (const StatusCodeException &)
            {
                continue;
            }

            featureVector.push_back(static_cast<double>(pCaloHit->GetPositionVector().GetX()));
            featureVector.push_back(static_cast<double>(pCaloHit->GetPositionVector().GetZ()));
            featureVector.push_back(static_cast<double>(tag));
            featureVector.push_back(static_cast<double>(inputEnergy));
        }
        // Add number of hits to end of vector than rotate (more efficient than direct insert at front)
        featureVector.push_back(static_cast<double>(featureVector.size() / 4));
        std::rotate(featureVector.rbegin(), featureVector.rbegin() + 1, featureVector.rend());

        PANDORA_RETURN_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, LArMvaHelper::ProduceTrainingExample(trainingOutputFileName, true, featureVector));
    }

    return STATUS_CODE_SUCCESS;
}

Member Data Documentation

pandora::StringVector lar_dl_content::DlHitTrackShowerIdAlgorithm::m_caloHitListNames

private

Name of input calo hit list.

Definition at line 70 of file DlHitTrackShowerIdAlgorithm.h.

int lar_dl_content::DlHitTrackShowerIdAlgorithm::m_imageHeight

private

Height of images in pixels.

Definition at line 77 of file DlHitTrackShowerIdAlgorithm.h.

int lar_dl_content::DlHitTrackShowerIdAlgorithm::m_imageWidth

private

Width of images in pixels.

Definition at line 78 of file DlHitTrackShowerIdAlgorithm.h.

std::string lar_dl_content::DlHitTrackShowerIdAlgorithm::m_modelFileNameU

private

Model file name for U view.

Definition at line 71 of file DlHitTrackShowerIdAlgorithm.h.

std::string lar_dl_content::DlHitTrackShowerIdAlgorithm::m_modelFileNameV

private

Model file name for V view.

Definition at line 72 of file DlHitTrackShowerIdAlgorithm.h.

std::string lar_dl_content::DlHitTrackShowerIdAlgorithm::m_modelFileNameW

private

Model file name for W view.

Definition at line 73 of file DlHitTrackShowerIdAlgorithm.h.

LArDLHelper::TorchModel lar_dl_content::DlHitTrackShowerIdAlgorithm::m_modelU

private

Model for the U view.

Definition at line 74 of file DlHitTrackShowerIdAlgorithm.h.

LArDLHelper::TorchModel lar_dl_content::DlHitTrackShowerIdAlgorithm::m_modelV

private

Model for the V view.

Definition at line 75 of file DlHitTrackShowerIdAlgorithm.h.

LArDLHelper::TorchModel lar_dl_content::DlHitTrackShowerIdAlgorithm::m_modelW

private

Model for the W view.

Definition at line 76 of file DlHitTrackShowerIdAlgorithm.h.

float lar_dl_content::DlHitTrackShowerIdAlgorithm::m_tileSize

private

Size of tile in cm.

Definition at line 79 of file DlHitTrackShowerIdAlgorithm.h.

std::string lar_dl_content::DlHitTrackShowerIdAlgorithm::m_trainingOutputFile

private

Output file name for training examples.

Definition at line 82 of file DlHitTrackShowerIdAlgorithm.h.

bool lar_dl_content::DlHitTrackShowerIdAlgorithm::m_useTrainingMode

private

Training mode.

Definition at line 81 of file DlHitTrackShowerIdAlgorithm.h.

bool lar_dl_content::DlHitTrackShowerIdAlgorithm::m_visualize

private

Whether to visualize the track shower ID scores.

Definition at line 80 of file DlHitTrackShowerIdAlgorithm.h.

---

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

• DlHitTrackShowerIdAlgorithm.h
• DlHitTrackShowerIdAlgorithm.cc