CheatingSliceSelectionTool class. More...

#include "CheatingSliceSelectionTool.h"

Inheritance diagram for lar_content::CheatingSliceSelectionTool:

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

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

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

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

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

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

Detailed Description

CheatingSliceSelectionTool class.

Definition at line 20 of file CheatingSliceSelectionTool.h.

Member Typedef Documentation

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

Definition at line 37 of file CheatingSliceSelectionTool.h.

Constructor & Destructor Documentation

lar_content::CheatingSliceSelectionTool::CheatingSliceSelectionTool ( )

Default constructor.

Definition at line 20 of file CheatingSliceSelectionTool.cc.

References m_cutVariable, and m_threshold.

                                                        :
     m_maxSlices{1},
     m_threshold{-1.f},
     m_cutVariable{"completeness"}
 {
 }

Member Function Documentation

virtual bool lar_content::CheatingSliceSelectionTool::IsTarget ( const pandora::MCParticle *const mcParticle ) const

protectedpure virtual

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

Implemented in lar_content::CheatingBeamParticleSliceSelectionTool, and lar_content::CheatingNeutrinoSliceSelectionTool.

Referenced by SelectSlices().

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

protected

Definition at line 125 of file CheatingSliceSelectionTool.cc.

References m_cutVariable, m_maxSlices, and m_threshold.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxSlices", m_maxSlices));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Threshold", m_threshold));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CutVariable", m_cutVariable));
     std::transform(m_cutVariable.begin(), m_cutVariable.end(), m_cutVariable.begin(), [](unsigned char c) { return std::tolower(c); });
     if (m_cutVariable != "completeness" && m_cutVariable != "purity")
     {
         std::cout << "CheatingSliceSelectionTool::ReadSettings: Unknown cut variable \'" << m_cutVariable << "\'" << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     return STATUS_CODE_SUCCESS;
 }

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

virtual

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(), IsTarget(), m_cutVariable, m_maxSlices, 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

protected

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

Definition at line 52 of file CheatingSliceSelectionTool.h.

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

int lar_content::CheatingSliceSelectionTool::m_maxSlices

protected

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

Definition at line 50 of file CheatingSliceSelectionTool.h.

Referenced by ReadSettings(), and SelectSlices().

float lar_content::CheatingSliceSelectionTool::m_threshold

protected

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

Definition at line 51 of file CheatingSliceSelectionTool.h.

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

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArCheating/CheatingSliceSelectionTool.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArCheating/CheatingSliceSelectionTool.cc

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation