lar_content::CheatingNeutrinoSliceSelectionTool Class Reference

CheatingNeutrinoSliceSelectionTool class. More...

#include "CheatingNeutrinoSliceSelectionTool.h"

Inheritance diagram for lar_content::CheatingNeutrinoSliceSelectionTool:

Public Types
typedef std::map< float, int, std::greater< float > >	MetricSliceIndexMap

Public Member Functions
void	SelectSlices (const pandora::Algorithm *const pAlgorithm, const SliceVector &inputSliceVector, SliceVector &outputSliceVector)
	Select which slice(s) to use. More...

Protected Member Functions
bool	IsTarget (const pandora::MCParticle *const mcParticle) const
	Template method to determine if an MC particle matches the target criteria for slice selection. Return true if match. More...

Protected Attributes
int	m_maxSlices
	The maximum number of slices to retain (0 to retain all) - default 0. More...
float	m_threshold
	The minimum cut threshold to retain a slice (< 0 for no threshold) - default -1. More...
std::string	m_cutVariable
	The variable to cut on ("purity" or "completeness") - default "completeness". More...

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Detailed Description

CheatingNeutrinoSliceSelectionTool class.

Definition at line 19 of file CheatingNeutrinoSliceSelectionTool.h.

Member Typedef Documentation

typedef std::map<float, int, std::greater<float> > lar_content::CheatingSliceSelectionTool::MetricSliceIndexMap

inherited

Definition at line 37 of file CheatingSliceSelectionTool.h.

Member Function Documentation

bool lar_content::CheatingNeutrinoSliceSelectionTool::IsTarget ( const pandora::MCParticle *const  mcParticle ) const

protectedvirtual

Template method to determine if an MC particle matches the target criteria for slice selection. Return true if match.

Parameters

mcParticle

the MC particle to check

Implements lar_content::CheatingSliceSelectionTool.

Definition at line 20 of file CheatingNeutrinoSliceSelectionTool.cc.

{
    return LArMCParticleHelper::IsNeutrino(mcParticle);
}

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

private

Definition at line 27 of file CheatingNeutrinoSliceSelectionTool.cc.

{
    return CheatingSliceSelectionTool::ReadSettings(xmlHandle);
}

void lar_content::CheatingSliceSelectionTool::SelectSlices ( const pandora::Algorithm *const  pAlgorithm, const SliceVector &  inputSliceVector, SliceVector &  outputSliceVector  )

virtualinherited

Select which slice(s) to use.

Parameters

pAlgorithm	the address of the master instance, used to access MCParticles when in training mode
inputSliceVector	the initial slice vector
outputSliceVector	the output slice vector

Implements lar_content::SliceSelectionBaseTool.

Definition at line 29 of file CheatingSliceSelectionTool.cc.

References lar_content::LArMCParticleHelper::GetParentMCParticle(), lar_content::CheatingSliceSelectionTool::IsTarget(), lar_content::CheatingSliceSelectionTool::m_cutVariable, lar_content::CheatingSliceSelectionTool::m_maxSlices, lar_content::CheatingSliceSelectionTool::m_threshold, lar_content::LArMCParticleHelper::SortByMomentum(), and weight.

{
    // ATTN Ensure this only runs if slicing enabled
    unsigned int sliceCounter{0};
    MetricSliceIndexMap reducedSliceVarIndexMap;

    FloatVector targetWeights(inputSliceVector.size());
    FloatVector otherWeights(inputSliceVector.size());

    // Calculate target and total weight for each slice
    for (const CaloHitList &sliceHits : inputSliceVector)
    {
        CaloHitList localHitList{};
        // ATTN Must ensure we copy the hit actually owned by master instance; access differs with/without slicing enabled
        for (const CaloHit *const pSliceCaloHit : sliceHits)
            localHitList.push_back(static_cast<const CaloHit *>(pSliceCaloHit->GetParentAddress()));

        for (const CaloHit *const pCaloHit : localHitList)
        {
            float thisTargetParticleWeight{0.f}, thisTotalWeight{0.f};
            const MCParticleWeightMap &hitMCParticleWeightMap(pCaloHit->GetMCParticleWeightMap());

            if (hitMCParticleWeightMap.empty())
                continue;

            MCParticleList mcParticleList;
            for (const auto &mapEntry : hitMCParticleWeightMap)
                mcParticleList.push_back(mapEntry.first);
            mcParticleList.sort(LArMCParticleHelper::SortByMomentum);

            for (const MCParticle *const pMCParticle : mcParticleList)
            {
                const float weight{hitMCParticleWeightMap.at(pMCParticle)};
                const MCParticle *const pParentMCParticle{LArMCParticleHelper::GetParentMCParticle(pMCParticle)};

                if (this->IsTarget(pParentMCParticle))
                    thisTargetParticleWeight += weight;

                thisTotalWeight += weight;
            }

            // ATTN normalise arbitrary input weights at this point
            if (thisTotalWeight > std::numeric_limits<float>::epsilon())
            {
                thisTargetParticleWeight *= 1.f / thisTotalWeight;
                thisTotalWeight = 1.f;
            }
            else
            {
                thisTargetParticleWeight = 0.f;
                thisTotalWeight = 0.f;
            }
            targetWeights[sliceCounter] += thisTargetParticleWeight;
            otherWeights[sliceCounter] += (1. - thisTargetParticleWeight);
        }

        ++sliceCounter;
    }

    float totalTargetWeight{0.f};
    for (const float weight : targetWeights)
        totalTargetWeight += weight;

    // Add slices passing cut threshold to map
    for (unsigned int i = 0; i < targetWeights.size(); ++i)
    {
        const float sliceWeight = targetWeights[i] + otherWeights[i];
        const float completeness{totalTargetWeight > std::numeric_limits<float>::epsilon() ? targetWeights[i] / totalTargetWeight : 0.f};
        const float purity{sliceWeight > std::numeric_limits<float>::epsilon() ? targetWeights[i] / sliceWeight : 0.f};
        // Already checked correctness of variable in ReadSettings
        if (m_cutVariable == "completeness")
        {
            if (completeness >= m_threshold)
                reducedSliceVarIndexMap.emplace(completeness, i);
        }
        else if (m_cutVariable == "purity")
        {
            if (purity >= m_threshold)
                reducedSliceVarIndexMap.emplace(purity, i);
        }
    }
    // Select the best m_maxSlices slices - prefix increment ensures all slices retained if m_maxSlices == 0
    std::vector<int> reducedSliceIndices{};
    int i = 0;
    for (const auto [cutVariable, index] : reducedSliceVarIndexMap)
    {                      // ATTN: Map is sorted on cut variable from max to min
        (void)cutVariable; // GCC 7 support, versions 8+ do not need this
        reducedSliceIndices.push_back(index);
        outputSliceVector.push_back(inputSliceVector[index]);
        if (++i == m_maxSlices)
            break;
    }
}

Member Data Documentation

std::string lar_content::CheatingSliceSelectionTool::m_cutVariable

protectedinherited

The variable to cut on ("purity" or "completeness") - default "completeness".

Definition at line 52 of file CheatingSliceSelectionTool.h.

Referenced by lar_content::CheatingSliceSelectionTool::CheatingSliceSelectionTool(), lar_content::CheatingSliceSelectionTool::ReadSettings(), and lar_content::CheatingSliceSelectionTool::SelectSlices().

int lar_content::CheatingSliceSelectionTool::m_maxSlices

protectedinherited

The maximum number of slices to retain (0 to retain all) - default 0.

Definition at line 50 of file CheatingSliceSelectionTool.h.

Referenced by lar_content::CheatingSliceSelectionTool::ReadSettings(), and lar_content::CheatingSliceSelectionTool::SelectSlices().

float lar_content::CheatingSliceSelectionTool::m_threshold

protectedinherited

The minimum cut threshold to retain a slice (< 0 for no threshold) - default -1.

Definition at line 51 of file CheatingSliceSelectionTool.h.

Referenced by lar_content::CheatingSliceSelectionTool::CheatingSliceSelectionTool(), lar_content::CheatingSliceSelectionTool::ReadSettings(), and lar_content::CheatingSliceSelectionTool::SelectSlices().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArCheating/CheatingNeutrinoSliceSelectionTool.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArCheating/CheatingNeutrinoSliceSelectionTool.cc