lar_content::MvaPfoCharacterisationAlgorithm< T > Class Template Reference

MvaPfoCharacterisationAlgorithm class. More...

#include <MvaPfoCharacterisationAlgorithm.h>

Inheritance diagram for lar_content::MvaPfoCharacterisationAlgorithm< T >:

Public Member Functions
	MvaPfoCharacterisationAlgorithm ()
	Default constructor. More...
Public Member Functions inherited from lar_content::PfoCharacterisationBaseAlgorithm
	PfoCharacterisationBaseAlgorithm ()
	Default constructor. More...
virtual	~PfoCharacterisationBaseAlgorithm ()
	Destructor. More...

Protected Member Functions
virtual bool	IsClearTrack (const pandora::ParticleFlowObject *const pPfo) const
	Whether pfo is identified as a clear track. More...
virtual bool	IsClearTrack (const pandora::Cluster *const pCluster) const
	Whether cluster is identified as a clear track. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
Protected Member Functions inherited from lar_content::PfoCharacterisationBaseAlgorithm
pandora::StatusCode	Run ()
virtual bool	IsClearTrack3x2D (const pandora::ParticleFlowObject *const pPfo) const
	Whether pfo is identified as a clear track using its three clusters. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Protected Attributes
ClusterCharacterisationFeatureTool::FeatureToolMap	m_featureToolMap
	The feature tool map. More...
PfoCharacterisationFeatureTool::FeatureToolMap	m_featureToolMapThreeD
	FeatureToolMap as a map for 3D info. More...
PfoCharacterisationFeatureTool::FeatureToolMap	m_featureToolMapNoChargeInfo
	FeatureToolMap as a map for missing W view. More...
pandora::StringVector	m_algorithmToolNames
	Vector of strings saving feature tool order for use in feature calculation. More...
pandora::StringVector	m_algorithmToolNamesNoChargeInfo
	Vector of strings saving feature tool order for use in feature calculation (missing W view) More...
T	m_mva
	The mva. More...
T	m_mvaNoChargeInfo
	The mva for missing W view. More...
bool	m_persistFeatures
	Whether to write the features to the properties map. More...
bool	m_trainingSetMode
	Whether to train. More...
bool	m_testBeamMode
	Whether the training set is from a test beam experiment. More...
bool	m_enableProbability
	Whether to use probabilities instead of binary classification. More...
bool	m_useThreeDInformation
	Whether to use 3D information. More...
float	m_minProbabilityCut
	The minimum probability to label a cluster as track-like. More...
unsigned int	m_minCaloHitsCut
	The minimum number of calo hits to qualify as a track. More...
bool	m_applyFiducialCut
	Whether to apply a fiducial volume cut during training. More...
float	m_fiducialMinX
	Fiducial volume minimum x. More...
float	m_fiducialMaxX
	Fiducial volume maximum x. More...
float	m_fiducialMinY
	Fiducial volume minimum y. More...
float	m_fiducialMaxY
	Fiducial volume maximum y. More...
float	m_fiducialMinZ
	Fiducial volume minimum z. More...
float	m_fiducialMaxZ
	Fiducial volume maximum z. More...
bool	m_applyReconstructabilityChecks
	Whether to apply reconstructability checks during training. More...
std::string	m_caloHitListName
	Name of input calo hit list. More...
std::string	m_mcParticleListName
	Name of input MC particle list. More...
std::string	m_trainingOutputFile
	The training output file. More...
std::string	m_filePathEnvironmentVariable
	The environment variable providing a list of paths to mva files. More...
std::string	m_mvaFileName
	The mva input file. More...
std::string	m_mvaName
	The name of the mva to find. More...
std::string	m_mvaFileNameNoChargeInfo
	The mva input file for PFOs missing the W view, and thus charge info. More...
std::string	m_mvaNameNoChargeInfo
	The name of the mva to find for PFOs missing the W view, and thus charge info. More...
LArMCParticleHelper::PrimaryParameters	m_primaryParameters
	The mc particle primary selection parameters. More...
Protected Attributes inherited from lar_content::PfoCharacterisationBaseAlgorithm
std::string	m_trackPfoListName
	The track pfo list name. More...
std::string	m_showerPfoListName
	The shower pfo list name. More...
pandora::StringVector	m_inputPfoListNames
	The names of the input pfo lists. More...
bool	m_updateClusterIds
	Whether to update daughter cluster particle id labels to match pfo id. More...
bool	m_postBranchAddition
	Whether to use configuration for shower clusters post branch addition. More...
bool	m_useThreeDInformation
	Whether to use PFO and 3D information or clusters for characterisation. More...
unsigned int	m_minTrackLikeViews
	The minimum number of track-like views to declare a pfo as track-like. More...

Private Member Functions
bool	PassesFiducialCut (const pandora::CartesianVector &vertex) const
	Checks if the interaction vertex is within the fiducial volume. More...

Detailed Description

template<typename T>
class lar_content::MvaPfoCharacterisationAlgorithm< T >

MvaPfoCharacterisationAlgorithm class.

Definition at line 28 of file MvaPfoCharacterisationAlgorithm.h.

Constructor & Destructor Documentation

template<typename T >

lar_content::MvaPfoCharacterisationAlgorithm< T >::MvaPfoCharacterisationAlgorithm

(

)

Default constructor.

Definition at line 24 of file MvaPfoCharacterisationAlgorithm.cc.

                                                                    :
    m_persistFeatures(false),
    m_trainingSetMode(false),
    m_testBeamMode(false),
    m_enableProbability(true),
    m_useThreeDInformation(true),
    m_minProbabilityCut(0.5f),
    m_minCaloHitsCut(5),
    m_applyFiducialCut(false),
    m_fiducialMinX(-std::numeric_limits<float>::max()),
    m_fiducialMaxX(std::numeric_limits<float>::max()),
    m_fiducialMinY(-std::numeric_limits<float>::max()),
    m_fiducialMaxY(std::numeric_limits<float>::max()),
    m_fiducialMinZ(-std::numeric_limits<float>::max()),
    m_fiducialMaxZ(std::numeric_limits<float>::max()),
    m_applyReconstructabilityChecks(false),
    m_filePathEnvironmentVariable("FW_SEARCH_PATH")
{
}

Member Function Documentation

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::IsClearTrack ( const pandora::ParticleFlowObject *const  pPfo ) const

protectedvirtual

Whether pfo is identified as a clear track.

Parameters

pPfo	address of the relevant pfo

Returns

boolean

Implements lar_content::PfoCharacterisationBaseAlgorithm.

Definition at line 85 of file MvaPfoCharacterisationAlgorithm.cc.

{
    if (!LArPfoHelper::IsThreeD(pPfo))
    {
        if (m_enableProbability)
        {
            object_creation::ParticleFlowObject::Metadata metadata;
            metadata.m_propertiesToAdd["TrackScore"] = -1.f;
            PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
        }
        return (pPfo->GetParticleId() == MU_MINUS);
    }

    // Charge related features are only calculated using hits in W view
    ClusterList wClusterList;
    LArPfoHelper::GetClusters(pPfo, TPC_VIEW_W, wClusterList);

    const PfoCharacterisationFeatureTool::FeatureToolMap &chosenFeatureToolMap(wClusterList.empty() ? m_featureToolMapNoChargeInfo : m_featureToolMapThreeD);
    const StringVector chosenFeatureToolOrder(wClusterList.empty() ? m_algorithmToolNamesNoChargeInfo : m_algorithmToolNames);
    StringVector featureOrder;
    const LArMvaHelper::MvaFeatureMap featureMap(
        LArMvaHelper::CalculateFeatures(chosenFeatureToolOrder, chosenFeatureToolMap, featureOrder, this, pPfo));

    for (auto const &[featureKey, featureValue] : featureMap)
    {
        (void)featureKey;

        if (!featureValue.IsInitialized())
        {
            if (m_enableProbability)
            {
                object_creation::ParticleFlowObject::Metadata metadata;
                metadata.m_propertiesToAdd["TrackScore"] = -1.f;
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
            }
            return (pPfo->GetParticleId() == MU_MINUS);
        }
    }

    if (m_trainingSetMode && m_applyReconstructabilityChecks)
    {
        const MCParticleList *pMCParticleList(nullptr);
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));

        const CaloHitList *pCaloHitList(nullptr);
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pCaloHitList));

        // Mapping target MCParticles -> truth associated Hits
        LArMCParticleHelper::MCContributionMap targetMCParticleToHitsMap;
        if (!m_testBeamMode)
            LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, m_primaryParameters,
                LArMCParticleHelper::IsBeamNeutrinoFinalState, targetMCParticleToHitsMap);
        else
            LArMCParticleHelper::SelectReconstructableMCParticles(
                pMCParticleList, pCaloHitList, m_primaryParameters, LArMCParticleHelper::IsBeamParticle, targetMCParticleToHitsMap);

        LArMCParticleHelper::MCContributionMapVector mcParticlesToGoodHitsMaps({targetMCParticleToHitsMap});

        LArMCParticleHelper::PfoContributionMap pfoToReconstructable2DHitsMap;
        LArMCParticleHelper::GetPfoToReconstructable2DHitsMap(
            PfoList(1, pPfo), mcParticlesToGoodHitsMaps, pfoToReconstructable2DHitsMap, m_primaryParameters.m_foldBackHierarchy);
        if (pfoToReconstructable2DHitsMap.empty())
            return false;

        LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCParticleHitSharingMap;
        LArMCParticleHelper::MCParticleToPfoHitSharingMap mcParticleToPfoHitSharingMap;
        LArMCParticleHelper::GetPfoMCParticleHitSharingMaps(
            pfoToReconstructable2DHitsMap, mcParticlesToGoodHitsMaps, pfoToMCParticleHitSharingMap, mcParticleToPfoHitSharingMap);
        if (pfoToMCParticleHitSharingMap.empty())
            return false;

        unsigned int nHitsInBestMCParticleTotal(0);
        unsigned int nHitsSharedWithBestMCParticleTotal(0);
        int bestMCParticlePdgCode(0);
        CartesianVector threeDVertexPosition(0.f, 0.f, 0.f);
        float hitsShower(0), hitsTrack(0);
        const LArMCParticleHelper::MCParticleToSharedHitsVector &mcParticleToSharedHitsVector(pfoToMCParticleHitSharingMap.at(pPfo));

        for (const LArMCParticleHelper::MCParticleCaloHitListPair &mcParticleCaloHitListPair : mcParticleToSharedHitsVector)
        {
            const pandora::MCParticle *const pAssociatedMCParticle(mcParticleCaloHitListPair.first);
            const CaloHitList &allMCHits(targetMCParticleToHitsMap.at(pAssociatedMCParticle));
            const CaloHitList &associatedMCHits(mcParticleCaloHitListPair.second);

            if ((PHOTON == pAssociatedMCParticle->GetParticleId()) || (E_MINUS == std::abs(pAssociatedMCParticle->GetParticleId())))
                hitsShower += associatedMCHits.size();
            else
                hitsTrack += associatedMCHits.size();

            if (associatedMCHits.size() > nHitsSharedWithBestMCParticleTotal)
            {
                nHitsSharedWithBestMCParticleTotal = associatedMCHits.size();
                nHitsInBestMCParticleTotal = allMCHits.size();
                bestMCParticlePdgCode = pAssociatedMCParticle->GetParticleId();
                threeDVertexPosition = pAssociatedMCParticle->GetVertex();
            }
        }

        const float trackShowerHitsRatio((hitsTrack + hitsShower) > 0 ? hitsTrack / (hitsTrack + hitsShower) : 0.f);
        const bool isTrueTrack(trackShowerHitsRatio >= 0.5);

        const int nHitsInPfoTotal(pfoToReconstructable2DHitsMap.at(pPfo).size());
        const float purity((nHitsInPfoTotal > 0) ? nHitsSharedWithBestMCParticleTotal / static_cast<float>(nHitsInPfoTotal) : 0.f);
        const float completeness(
            (nHitsInBestMCParticleTotal > 0) ? nHitsSharedWithBestMCParticleTotal / static_cast<float>(nHitsInBestMCParticleTotal) : 0.f);

        CaloHitList checkHitListW;
        LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_W, checkHitListW);
        CaloHitList checkHitListU;
        LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_U, checkHitListU);
        CaloHitList checkHitListV;
        LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_V, checkHitListV);
        CaloHitList checkHitListAll;
        checkHitListAll.splice(checkHitListAll.end(), checkHitListW);
        checkHitListAll.splice(checkHitListAll.end(), checkHitListU);
        checkHitListAll.splice(checkHitListAll.end(), checkHitListV);

        LArMCParticleHelper::MCRelationMap mcPrimaryMap;
        LArMCParticleHelper::GetMCPrimaryMap(pMCParticleList, mcPrimaryMap);

        LArMCParticleHelper::MCContributionMap mcToTrueHitListMap;
        LArMCParticleHelper::CaloHitToMCMap hitToMCMap;
        LArMCParticleHelper::GetMCParticleToCaloHitMatches(&checkHitListAll, mcPrimaryMap, hitToMCMap, mcToTrueHitListMap);

        unsigned int showerCount(0), allCount(0);
        for (const CaloHit *pHit : checkHitListAll)
        {
            if (hitToMCMap.find(pHit) != hitToMCMap.end())
            {
                const MCParticle *pHitMCParticle(hitToMCMap.at(pHit));
                if ((PHOTON == pHitMCParticle->GetParticleId()) || (E_MINUS == std::abs(pHitMCParticle->GetParticleId())))
                    ++showerCount;
                ++allCount;
            }
        }

        if (allCount == 0)
            return false;
        const float showerProbability(showerCount / static_cast<float>(allCount));
        const bool mischaracterisedPfo((showerProbability < 0.5f && !isTrueTrack) || (showerProbability > 0.5 && isTrueTrack) ? true : false);
        const bool isMainMCParticleSet(bestMCParticlePdgCode != 0);

        if (isMainMCParticleSet)
        {
            if (completeness >= 0.f && purity >= 0.f && !mischaracterisedPfo && (!m_applyFiducialCut || this->PassesFiducialCut(threeDVertexPosition)))
            {
                std::string outputFile(m_trainingOutputFile);
                const std::string end = ((wClusterList.empty()) ? "noChargeInfo.txt" : ".txt");
                outputFile.append(end);
                LArMvaHelper::ProduceTrainingExample(outputFile, isTrueTrack, featureOrder, featureMap);
            }
        }

        return isTrueTrack;
    }
    else if (m_trainingSetMode)
    {
        bool isTrueTrack(false);
        bool isMainMCParticleSet(false);

        try
        {
            const MCParticle *const pMCParticle(LArMCParticleHelper::GetMainMCParticle(pPfo));
            isTrueTrack = ((PHOTON != pMCParticle->GetParticleId()) && (E_MINUS != std::abs(pMCParticle->GetParticleId())));
            isMainMCParticleSet = (pMCParticle->GetParticleId() != 0);
        }
        catch (const StatusCodeException &)
        {
        }

        if (isMainMCParticleSet)
        {
            std::string outputFile(m_trainingOutputFile);
            outputFile.append(wClusterList.empty() ? "noChargeInfo.txt" : ".txt");
            LArMvaHelper::ProduceTrainingExample(outputFile, isTrueTrack, featureOrder, featureMap);
        }

        return isTrueTrack;
    }

    // If no failures, proceed with MvaPfoCharacterisationAlgorithm classification
    if (!m_enableProbability)
    {
        return LArMvaHelper::Classify((wClusterList.empty() ? m_mvaNoChargeInfo : m_mva), featureOrder, featureMap);
    }
    else
    {
        const double score(LArMvaHelper::CalculateProbability((wClusterList.empty() ? m_mvaNoChargeInfo : m_mva), featureOrder, featureMap));
        object_creation::ParticleFlowObject::Metadata metadata;
        metadata.m_propertiesToAdd["TrackScore"] = score;
        if (m_persistFeatures)
        {
            for (auto const &[name, value] : featureMap)
            {
                metadata.m_propertiesToAdd[name] = value.Get();
            }
        }
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
        return (m_minProbabilityCut <= score);
    }
}

template<typename T >

virtual bool lar_content::MvaPfoCharacterisationAlgorithm< T >::IsClearTrack ( const pandora::Cluster *const  pCluster ) const

protectedvirtual

Whether cluster is identified as a clear track.

Parameters

pCluster

address of the relevant cluster

Returns

boolean

Implements lar_content::PfoCharacterisationBaseAlgorithm.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::PassesFiducialCut ( const pandora::CartesianVector &  vertex ) const

private

Checks if the interaction vertex is within the fiducial volume.

Parameters

vertex

The coordinates of the vertex

Definition at line 433 of file MvaPfoCharacterisationAlgorithm.cc.

{
    const float vx(vertex.GetX()), vy(vertex.GetY()), vz(vertex.GetZ());
    return m_fiducialMinX <= vx && vx <= m_fiducialMaxX && m_fiducialMinY <= vy && vy <= m_fiducialMaxY && m_fiducialMinZ <= vz && vz <= m_fiducialMaxZ;
}

template<typename T >

StatusCode lar_content::MvaPfoCharacterisationAlgorithm< T >::ReadSettings ( const pandora::TiXmlHandle  xmlHandle )

protected

Definition at line 290 of file MvaPfoCharacterisationAlgorithm.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinPrimaryGoodHits", m_primaryParameters.m_minPrimaryGoodHits));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinHitsForGoodView", m_primaryParameters.m_minHitsForGoodView));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinPrimaryGoodViews", m_primaryParameters.m_minPrimaryGoodViews));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "SelectInputHits", m_primaryParameters.m_selectInputHits));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinHitSharingFraction", m_primaryParameters.m_minHitSharingFraction));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxPhotonPropagation", m_primaryParameters.m_maxPhotonPropagation));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "FoldToPrimaries", m_primaryParameters.m_foldBackHierarchy));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PersistFeatures", m_persistFeatures));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingSetMode", m_trainingSetMode));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitsCut", m_minCaloHitsCut));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UseThreeDInformation", m_useThreeDInformation));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "FilePathEnvironmentVariable", m_filePathEnvironmentVariable));

    // ATTN Support legacy XML configurations (note an order of precedence of XML keys exists)
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BdtFileName", m_mvaFileName));
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SvmFileName", m_mvaFileName));
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MvaFileName", m_mvaFileName));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BdtName", m_mvaName));
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SvmName", m_mvaName));
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MvaName", m_mvaName));

    if (m_useThreeDInformation)
    {
        PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
            XmlHelper::ReadValue(xmlHandle, "BdtFileNameNoChargeInfo", m_mvaFileNameNoChargeInfo));
        PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
            XmlHelper::ReadValue(xmlHandle, "SvmFileNameNoChargeInfo", m_mvaFileNameNoChargeInfo));
        PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
            XmlHelper::ReadValue(xmlHandle, "MvaFileNameNoChargeInfo", m_mvaFileNameNoChargeInfo));

        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BdtNameNoChargeInfo", m_mvaNameNoChargeInfo));
        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SvmNameNoChargeInfo", m_mvaNameNoChargeInfo));
        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MvaNameNoChargeInfo", m_mvaNameNoChargeInfo));
    }

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EnableProbability", m_enableProbability));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinProbabilityCut", m_minProbabilityCut));

    if (m_trainingSetMode)
    {
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListName", m_caloHitListName));
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MCParticleListName", m_mcParticleListName));
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrainingOutputFileName", m_trainingOutputFile));
        PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TestBeamMode", m_testBeamMode));
        PANDORA_RETURN_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ApplyFiducialCut", m_applyFiducialCut));
        if (m_applyFiducialCut)
        {
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMinX", m_fiducialMinX));
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMaxX", m_fiducialMaxX));
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMinY", m_fiducialMinY));
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMaxY", m_fiducialMaxY));
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMinZ", m_fiducialMinZ));
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMaxZ", m_fiducialMaxZ));
        }
        PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
            XmlHelper::ReadValue(xmlHandle, "ApplyReconstructabilityChecks", m_applyReconstructabilityChecks));
    }
    else
    {
        if (m_mvaFileName.empty() || m_mvaName.empty())
        {
            std::cout << "MvaPfoCharacterisationAlgorithm: MvaFileName and MvaName must be set if in classification mode " << std::endl;
            return STATUS_CODE_INVALID_PARAMETER;
        }

        const std::string fullMvaFileName(LArFileHelper::FindFileInPath(m_mvaFileName, m_filePathEnvironmentVariable));
        m_mva.Initialize(fullMvaFileName, m_mvaName);

        if (m_useThreeDInformation)
        {
            if (m_mvaFileNameNoChargeInfo.empty() || m_mvaNameNoChargeInfo.empty())
            {
                std::cout << "MvaPfoCharacterisationAlgorithm: MvaFileNameNoChargeInfo and MvaNameNoChargeInfo must be set if in classification mode for no charge info in 3D mode "
                          << std::endl;
                return STATUS_CODE_INVALID_PARAMETER;
            }
            const std::string fullMvaFileNameNoChargeInfo(LArFileHelper::FindFileInPath(m_mvaFileNameNoChargeInfo, m_filePathEnvironmentVariable));
            m_mvaNoChargeInfo.Initialize(fullMvaFileNameNoChargeInfo, m_mvaNameNoChargeInfo);
        }
    }

    LArMvaHelper::AlgorithmToolMap algorithmToolMap;
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
        LArMvaHelper::ProcessAlgorithmToolListToMap(*this, xmlHandle, "FeatureTools", m_algorithmToolNames, algorithmToolMap));

    if (m_useThreeDInformation)
    {
        // and the map for NoChargeInfo
        LArMvaHelper::AlgorithmToolMap algorithmToolMapNoChargeInfo;
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
            LArMvaHelper::ProcessAlgorithmToolListToMap(
                *this, xmlHandle, "FeatureToolsNoChargeInfo", m_algorithmToolNamesNoChargeInfo, algorithmToolMapNoChargeInfo));

        for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMap)
            PANDORA_RETURN_RESULT_IF(
                STATUS_CODE_SUCCESS, !=, LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMapThreeD));

        for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMapNoChargeInfo)
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
                LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMapNoChargeInfo));
    }
    else
    {
        for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMap)
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMap));
    }

    return PfoCharacterisationBaseAlgorithm::ReadSettings(xmlHandle);
}

Member Data Documentation

template<typename T >

pandora::StringVector lar_content::MvaPfoCharacterisationAlgorithm< T >::m_algorithmToolNames

protected

Vector of strings saving feature tool order for use in feature calculation.

Definition at line 46 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

pandora::StringVector lar_content::MvaPfoCharacterisationAlgorithm< T >::m_algorithmToolNamesNoChargeInfo

protected

Vector of strings saving feature tool order for use in feature calculation (missing W view)

Definition at line 47 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_applyFiducialCut

protected

Whether to apply a fiducial volume cut during training.

Definition at line 59 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_applyReconstructabilityChecks

protected

Whether to apply reconstructability checks during training.

Definition at line 66 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_caloHitListName

protected

Name of input calo hit list.

Definition at line 68 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_enableProbability

protected

Whether to use probabilities instead of binary classification.

Definition at line 55 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

ClusterCharacterisationFeatureTool::FeatureToolMap lar_content::MvaPfoCharacterisationAlgorithm< T >::m_featureToolMap

protected

The feature tool map.

Definition at line 41 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

PfoCharacterisationFeatureTool::FeatureToolMap lar_content::MvaPfoCharacterisationAlgorithm< T >::m_featureToolMapNoChargeInfo

protected

FeatureToolMap as a map for missing W view.

Definition at line 44 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

PfoCharacterisationFeatureTool::FeatureToolMap lar_content::MvaPfoCharacterisationAlgorithm< T >::m_featureToolMapThreeD

protected

FeatureToolMap as a map for 3D info.

Definition at line 43 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_fiducialMaxX

protected

Fiducial volume maximum x.

Definition at line 61 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_fiducialMaxY

protected

Fiducial volume maximum y.

Definition at line 63 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_fiducialMaxZ

protected

Fiducial volume maximum z.

Definition at line 65 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_fiducialMinX

protected

Fiducial volume minimum x.

Definition at line 60 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_fiducialMinY

protected

Fiducial volume minimum y.

Definition at line 62 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_fiducialMinZ

protected

Fiducial volume minimum z.

Definition at line 64 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_filePathEnvironmentVariable

protected

The environment variable providing a list of paths to mva files.

Definition at line 72 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mcParticleListName

protected

Name of input MC particle list.

Definition at line 69 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

unsigned int lar_content::MvaPfoCharacterisationAlgorithm< T >::m_minCaloHitsCut

protected

The minimum number of calo hits to qualify as a track.

Definition at line 58 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

float lar_content::MvaPfoCharacterisationAlgorithm< T >::m_minProbabilityCut

protected

The minimum probability to label a cluster as track-like.

Definition at line 57 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

T lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mva

protected

The mva.

Definition at line 49 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mvaFileName

protected

The mva input file.

Definition at line 73 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mvaFileNameNoChargeInfo

protected

The mva input file for PFOs missing the W view, and thus charge info.

Definition at line 75 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mvaName

protected

The name of the mva to find.

Definition at line 74 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mvaNameNoChargeInfo

protected

The name of the mva to find for PFOs missing the W view, and thus charge info.

Definition at line 76 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

T lar_content::MvaPfoCharacterisationAlgorithm< T >::m_mvaNoChargeInfo

protected

The mva for missing W view.

Definition at line 50 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_persistFeatures

protected

Whether to write the features to the properties map.

Definition at line 52 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

LArMCParticleHelper::PrimaryParameters lar_content::MvaPfoCharacterisationAlgorithm< T >::m_primaryParameters

protected

The mc particle primary selection parameters.

Definition at line 78 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_testBeamMode

protected

Whether the training set is from a test beam experiment.

Definition at line 54 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

std::string lar_content::MvaPfoCharacterisationAlgorithm< T >::m_trainingOutputFile

protected

The training output file.

Definition at line 71 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_trainingSetMode

protected

Whether to train.

Definition at line 53 of file MvaPfoCharacterisationAlgorithm.h.

template<typename T >

bool lar_content::MvaPfoCharacterisationAlgorithm< T >::m_useThreeDInformation

protected

Whether to use 3D information.

Definition at line 56 of file MvaPfoCharacterisationAlgorithm.h.

---

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

• MvaPfoCharacterisationAlgorithm.h
• MvaPfoCharacterisationAlgorithm.cc