EventClusterValidationAlgorithm class. More...

#include "EventClusterValidationAlgorithm.h"

Inheritance diagram for lar_content::EventClusterValidationAlgorithm:

Classes
struct	CaloHitParents

struct	ClusterMetrics

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

	~EventClusterValidationAlgorithm ()
	Destructor saves the validation TTree along with making and saving a metadata TTree. More...

Private Types
enum	ValidationType { ALL, SHOWER, TRACK }

typedef std::map< const pandora::Cluster const, std::map< const pandora::MCParticle const, int > >	ContingencyTable

Private Member Functions
pandora::StatusCode	Run ()

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

void	GetMetrics (const std::map< const pandora::CaloHit *const, CaloHitParents > &hitParents, ClusterMetrics &metrics) const
	Retrieve the metrics of every cluster in a view. More...

float	CalcRandIndex (std::map< const pandora::CaloHit *const, CaloHitParents > &hitParents) const
	Calculate Rand Index for the clusters with the clusters of true MCParticles. (Ref. for Adjusted Rand Index: https://link.springer.com/article/10.1007/BF01908075) More...

void	GetHitParents (const pandora::CaloHitList &caloHits, const pandora::ClusterList &clusters, std::map< const pandora::CaloHit *const, CaloHitParents > &hitParents) const
	Find the cluster and MCParticle each hit belongs to. More...

void	ApplyMCParticleMinSumHits (std::map< const pandora::CaloHit *const, CaloHitParents > &hitParents) const
	Erase hits associated to an MCParticle that does meet a minimum number of hits in the view. More...

std::map< const pandora::CaloHit *const, CaloHitParents >	ApplyPDGCut (std::map< const pandora::CaloHit *const, CaloHitParents > &hitParents, const ValidationType &valType) const
	Erase hits not associated with an MCParticle PDG incompatible with track/shower/all. More...

void	SetBranches (ClusterMetrics &metrics, float randIdx, std::string branchPrefix) const
	Update the branches of the TTree for this entry. More...

Private Attributes
int	m_eventNumber
	To track the current event number. More...

std::string	m_fileName
	The filename of the ROOT output file. More...

std::string	m_treeName
	The name of the ROOT tree. More...

std::string	m_caloHitListName
	The name of the hit list containing all 2D hits. More...

std::vector< std::string >	m_clusterListNames
	The names of the lists of 2D clusters to process. More...

int	m_minMCHitsPerView
	Threshold on total main MCParticle hits in each view for consideration in metric calculations. More...

Detailed Description

EventClusterValidationAlgorithm class.

Definition at line 19 of file EventClusterValidationAlgorithm.h.

Member Typedef Documentation

typedef std::map<const pandora::Cluster *const, std::map<const pandora::MCParticle *const, int> > lar_content::EventClusterValidationAlgorithm::ContingencyTable

private

Definition at line 61 of file EventClusterValidationAlgorithm.h.

Member Enumeration Documentation

enum lar_content::EventClusterValidationAlgorithm::ValidationType

private

Enumerator
ALL
SHOWER
TRACK

Definition at line 34 of file EventClusterValidationAlgorithm.h.

     {
         ALL,
         SHOWER,
         TRACK
     };

Constructor & Destructor Documentation

lar_content::EventClusterValidationAlgorithm::EventClusterValidationAlgorithm ( )

Default constructor.

Definition at line 43 of file EventClusterValidationAlgorithm.cc.

References m_caloHitListName, and m_minMCHitsPerView.

                                                                  :
     m_eventNumber{0},
     m_caloHitListName{"CaloHitList2D"},
     m_minMCHitsPerView{0}
 {
 }

lar_content::EventClusterValidationAlgorithm::~EventClusterValidationAlgorithm ( )

Destructor saves the validation TTree along with making and saving a metadata TTree.

Definition at line 52 of file EventClusterValidationAlgorithm.cc.

References m_fileName, m_minMCHitsPerView, and m_treeName.

 {
     PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_treeName, m_fileName, "UPDATE"));
 
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName + "_meta", "min_mc_hits_per_view", m_minMCHitsPerView));
     PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treeName + "_meta"));
     PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_treeName + "_meta", m_fileName, "UPDATE"));
 }

Member Function Documentation

void lar_content::EventClusterValidationAlgorithm::ApplyMCParticleMinSumHits ( std::map< const pandora::CaloHit *const, CaloHitParents > & hitParents ) const

private

Erase hits associated to an MCParticle that does meet a minimum number of hits in the view.

Parameters

[in,out] hitParents Map of hits to the Cluster/MCParticle they belong to

Definition at line 172 of file EventClusterValidationAlgorithm.cc.

References m_minMCHitsPerView.

Referenced by Run().

 {
     std::map<const MCParticle *const, int> mcSumHits;
     for (const auto &[pCaloHit, parents] : hitParents)
     {
         const MCParticle *const pMainMC{parents.m_pMainMC};
         if (mcSumHits.find(pMainMC) == mcSumHits.end())
             mcSumHits[pMainMC] = 0;
         mcSumHits.at(pMainMC)++;
     }
 
     for (auto it = hitParents.begin(); it != hitParents.end();)
     {
         if (mcSumHits.at(it->second.m_pMainMC) < m_minMCHitsPerView)
             it = hitParents.erase(it);
         else
             it++;
     }
 }

std::map< const CaloHit *const, EventClusterValidationAlgorithm::CaloHitParents > lar_content::EventClusterValidationAlgorithm::ApplyPDGCut	(	std::map< const pandora::CaloHit *const, CaloHitParents > &	hitParents,
		const ValidationType &	valType
	)		const

private

Erase hits not associated with an MCParticle PDG incompatible with track/shower/all.

Parameters

[in]	hitParents	Map of hits to the Cluster/MCParticle they belong to
[in]	valType	Enum for track/shower/all

Definition at line 194 of file EventClusterValidationAlgorithm.cc.

References util::abs().

Referenced by Run().

 {
     std::map<const CaloHit *const, CaloHitParents> hitParentsValid;
     for (const auto &[pCaloHit, parents] : hitParents)
     {
         const MCParticle *const pMainMC{parents.m_pMainMC};
         if (valType != ValidationType::ALL)
         {
             const int pdg{std::abs(pMainMC->GetParticleId())};
             if ((valType == ValidationType::SHOWER && (pdg != PHOTON && pdg != E_MINUS)) ||
                 (valType == ValidationType::TRACK && (pdg == PHOTON || pdg == E_MINUS)))
                 continue;
         }
         hitParentsValid[pCaloHit] = parents;
     }
 
     return hitParentsValid;
 }

float lar_content::EventClusterValidationAlgorithm::CalcRandIndex ( std::map< const pandora::CaloHit *const, CaloHitParents > & hitParents ) const

private

Calculate Rand Index for the clusters with the clusters of true MCParticles. (Ref. for Adjusted Rand Index: https://link.springer.com/article/10.1007/BF01908075)

Parameters

[in] hitParents Map of hits being considered to the Cluster/MCParticle they belong to

Definition at line 291 of file EventClusterValidationAlgorithm.cc.

References lar_content::LArMonitoringHelper::CalcRandIndex().

Referenced by Run().

 {
     // Fill contingency table
     ContingencyTable cTable;
     for (const auto &[pCaloHit, parents] : hitParents)
     {
         const MCParticle *const pMC = parents.m_pMainMC;
         const Cluster *const pCluster = parents.m_pCluster;
 
         if (cTable.find(pCluster) == cTable.end() || cTable.at(pCluster).find(pMC) == cTable.at(pCluster).end())
             cTable[pCluster][pMC] = 0;
         cTable.at(pCluster).at(pMC)++;
     }
 
     return LArMonitoringHelper::CalcRandIndex(cTable);
 }

void lar_content::EventClusterValidationAlgorithm::GetHitParents	(	const pandora::CaloHitList &	caloHits,
		const pandora::ClusterList &	clusters,
		std::map< const pandora::CaloHit *const, CaloHitParents > &	hitParents
	)		const

private

Find the cluster and MCParticle each hit belongs to.

Parameters

[in]	caloHits	List of hits
[in]	clusters	List of clusters
[out]	hitParents	Map of hits to the Cluster/MCParticle they belong to

Definition at line 131 of file EventClusterValidationAlgorithm.cc.

References weight.

Referenced by Run().

 {
     for (const CaloHit *const pCaloHit : caloHits)
     {
         const MCParticle *pMainMC{nullptr};
         const MCParticleWeightMap &weightMap{pCaloHit->GetMCParticleWeightMap()};
         float maxWeight{std::numeric_limits<float>::lowest()};
         for (const auto &[pMC, weight] : weightMap)
         {
             if (weight > maxWeight)
             {
                 pMainMC = pMC;
                 maxWeight = weight;
             }
         }
         if (pMainMC)
         {
             hitParents[pCaloHit] = CaloHitParents();
             hitParents[pCaloHit].m_pMainMC = pMainMC;
         }
     }
 
     for (const Cluster *const pCluster : clusters)
     {
         const CaloHitList &isolatedHits{pCluster->GetIsolatedCaloHitList()};
         CaloHitList clusterCaloHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(clusterCaloHits);
         clusterCaloHits.insert(clusterCaloHits.end(), isolatedHits.begin(), isolatedHits.end());
         for (const CaloHit *const pCaloHit : clusterCaloHits)
         {
             // Ignoring the calo hit if truth matching is missing
             if (hitParents.find(pCaloHit) == hitParents.end())
                 continue;
             hitParents[pCaloHit].m_pCluster = pCluster;
         }
     }
 }

void lar_content::EventClusterValidationAlgorithm::GetMetrics	(	const std::map< const pandora::CaloHit *const, CaloHitParents > &	hitParents,
		ClusterMetrics &	metrics
	)		const

private

Retrieve the metrics of every cluster in a view.

Parameters

[in]	hitParents	Map of hits being considered to the Cluster/MCParticle they belong to
[out]	metrics	Metrics for the clusters in this view

Definition at line 216 of file EventClusterValidationAlgorithm.cc.

References lar_content::EventClusterValidationAlgorithm::ClusterMetrics::m_completenesses, lar_content::EventClusterValidationAlgorithm::ClusterMetrics::m_nClusters, lar_content::EventClusterValidationAlgorithm::ClusterMetrics::m_nHits, lar_content::EventClusterValidationAlgorithm::ClusterMetrics::m_nMainMCs, lar_content::EventClusterValidationAlgorithm::ClusterMetrics::m_nRecoHits, and lar_content::EventClusterValidationAlgorithm::ClusterMetrics::m_purities.

Referenced by Run().

 {
     // Adapted from Andy's code for calculating cluster purity and completeness (ClusterValidationAlgorithm)
     std::set<const Cluster *> validClusters;
     std::set<const MCParticle *> validMCParticles;
     for (const auto &[pCaloHit, parents] : hitParents)
     {
         validClusters.insert(parents.m_pCluster);
         validMCParticles.insert(parents.m_pMainMC);
     }
     metrics.m_nHits = hitParents.size();
     metrics.m_nClusters = validClusters.size();
     metrics.m_nMainMCs = validMCParticles.size();
 
     for (const Cluster *const pCluster : validClusters)
     {
         CaloHitList clusterCaloHits;
         if (pCluster)
         {
             const CaloHitList &isolatedHits{pCluster->GetIsolatedCaloHitList()};
             pCluster->GetOrderedCaloHitList().FillCaloHitList(clusterCaloHits);
             clusterCaloHits.insert(clusterCaloHits.end(), isolatedHits.begin(), isolatedHits.end());
         }
         else // The hit has a null cluster ie. it is unclustered, treat all such hits as being clustered together
         {
             for (const auto &[pCaloHit, parents] : hitParents)
             {
                 if (!parents.m_pCluster)
                     clusterCaloHits.emplace_back(pCaloHit);
             }
         }
 
         std::map<const MCParticle *const, int> mainMCParticleHits;
         float totalHits{0};
         for (const CaloHit *const pCaloHit : clusterCaloHits)
         {
             if (hitParents.find(pCaloHit) == hitParents.end())
                 continue;
 
             const MCParticle *const pMC = hitParents.at(pCaloHit).m_pMainMC;
             if (mainMCParticleHits.find(pMC) == mainMCParticleHits.end())
                 mainMCParticleHits[pMC] = 0;
             mainMCParticleHits.at(pMC)++;
             totalHits++;
         }
         if (totalHits == 0) // Something went wrong and won't be able to get metrics from this cluster
             continue;
 
         // Determine which MC particle contributes the most weight across the cluster
         const MCParticle *pMainMC{nullptr};
         int maxHits{0};
         for (const auto &[pMC, nHits] : mainMCParticleHits)
         {
             if (nHits > maxHits)
             {
                 pMainMC = pMC;
                 maxHits = nHits;
             }
         }
         metrics.m_purities.emplace_back(maxHits / totalHits);
         metrics.m_nRecoHits.emplace_back(totalHits);
 
         // Calculate cluster completeness
         int nTotalMainMCHits{0};
         for (const auto &[pCaloHit, parents] : hitParents)
         {
             if (pMainMC == parents.m_pMainMC)
                 nTotalMainMCHits++;
         }
         metrics.m_completenesses.emplace_back(maxHits / static_cast<float>(nTotalMainMCHits));
     }
 }

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

private

Definition at line 333 of file EventClusterValidationAlgorithm.cc.

References m_caloHitListName, m_clusterListNames, m_fileName, m_minMCHitsPerView, and m_treeName.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FileName", m_fileName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TreeName", m_treeName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListName", m_caloHitListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "ClusterListNames", m_clusterListNames));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinMCHitsPerView", m_minMCHitsPerView));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::EventClusterValidationAlgorithm::Run ( )

private

Definition at line 63 of file EventClusterValidationAlgorithm.cc.

References ApplyMCParticleMinSumHits(), ApplyPDGCut(), CalcRandIndex(), lar_content::LArClusterHelper::GetClusterHitType(), GetHitParents(), GetMetrics(), m_caloHitListName, m_clusterListNames, m_eventNumber, m_minMCHitsPerView, m_treeName, and SetBranches().

 {
     m_eventNumber++;
 
     // Gather hits by view
     const CaloHitList *pFullCaloHitList{nullptr};
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pFullCaloHitList));
     std::map<HitType, CaloHitList> viewToCaloHits;
     for (const CaloHit *const pCaloHit : *pFullCaloHitList)
         viewToCaloHits[pCaloHit->GetHitType()].emplace_back(pCaloHit);
 
     // Gather clusters by view
     std::map<HitType, ClusterList> viewToClusters;
     for (std::string listName : m_clusterListNames)
     {
         const ClusterList *pClusterList{nullptr};
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, listName, pClusterList));
         for (const Cluster *const pCluster : *pClusterList)
         {
             const HitType view{LArClusterHelper::GetClusterHitType(pCluster)};
             viewToClusters[view].emplace_back(pCluster);
         }
     }
 
     const std::vector<ValidationType> valTypes{ValidationType::ALL, ValidationType::SHOWER, ValidationType::TRACK};
     for (const auto &[view, caloHits] : viewToCaloHits)
     {
         const ClusterList &clusters{viewToClusters[view]};
 
         // For each hit, get the main MCParticle and the cluster it belongs to (if the truth matching is not missing)
         // NOTE Using hitParents map to track which hits are being considered in metric calculations
         std::map<const CaloHit *const, CaloHitParents> hitParents;
         GetHitParents(caloHits, clusters, hitParents);
 
         // Drop any hits with a main MC particle with insufficient activity
         if (m_minMCHitsPerView > 0)
             ApplyMCParticleMinSumHits(hitParents);
 
         for (const ValidationType valType : valTypes)
         {
             // Apply the track/shower/all criteria
             std::map<const CaloHit *const, CaloHitParents> hitParentsValid{ApplyPDGCut(hitParents, valType)};
 
             ClusterMetrics metrics;
             GetMetrics(hitParentsValid, metrics);
 
             float adjustedRandI{CalcRandIndex(hitParentsValid)};
 
             std::string branchPrefix;
             if (valType == ValidationType::ALL)
                 branchPrefix = "all_";
             else if (valType == ValidationType::SHOWER)
                 branchPrefix = "shower_";
             else if (valType == ValidationType::TRACK)
                 branchPrefix = "track_";
             SetBranches(metrics, adjustedRandI, branchPrefix);
         }
 
         PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, "event", m_eventNumber - 1));
         PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, "view", static_cast<int>(view)));
         PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treeName));
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::EventClusterValidationAlgorithm::SetBranches	(	ClusterMetrics &	metrics,
		float	randIdx,
		std::string	branchPrefix
	)		const

private

Update the branches of the TTree for this entry.

Parameters

[in]	metrics	Metrics for clusters in a view
[in]	randIfx	Adjusted Rand index
[in]	branchPrefix	Prefix for the branch name

Definition at line 310 of file EventClusterValidationAlgorithm.cc.

References m_treeName.

Referenced by Run().

 {
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "n_hits", metrics.m_nHits));
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "n_clusters", metrics.m_nClusters));
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "n_mainMCs", metrics.m_nMainMCs));
 #ifdef MONITORING
     double meanPurity{-1.0}, meanCompleteness{-1.0}, meanNRecoHits{-1.0};
     if (!metrics.m_purities.empty() && !metrics.m_completenesses.empty() && !metrics.m_nRecoHits.empty())
     {
         meanPurity = std::accumulate(metrics.m_purities.begin(), metrics.m_purities.end(), 0.0) / metrics.m_purities.size();
         meanCompleteness = std::accumulate(metrics.m_completenesses.begin(), metrics.m_completenesses.end(), 0.0) / metrics.m_completenesses.size();
         meanNRecoHits = std::accumulate(metrics.m_nRecoHits.begin(), metrics.m_nRecoHits.end(), 0.0) / metrics.m_nRecoHits.size();
     }
 #endif
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "mean_purity", meanPurity));
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "mean_completeness", meanCompleteness));
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "mean_n_reco_hits", meanNRecoHits));
     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName, branchPrefix + "adjusted_rand_idx", randIndex));
 }

Member Data Documentation

std::string lar_content::EventClusterValidationAlgorithm::m_caloHitListName

private

The name of the hit list containing all 2D hits.

Definition at line 120 of file EventClusterValidationAlgorithm.h.

Referenced by EventClusterValidationAlgorithm(), ReadSettings(), and Run().

std::vector<std::string> lar_content::EventClusterValidationAlgorithm::m_clusterListNames

private

The names of the lists of 2D clusters to process.

Definition at line 121 of file EventClusterValidationAlgorithm.h.

Referenced by ReadSettings(), and Run().

int lar_content::EventClusterValidationAlgorithm::m_eventNumber

private

To track the current event number.

Definition at line 117 of file EventClusterValidationAlgorithm.h.

Referenced by Run().

std::string lar_content::EventClusterValidationAlgorithm::m_fileName

private

The filename of the ROOT output file.

Definition at line 118 of file EventClusterValidationAlgorithm.h.

Referenced by ReadSettings(), and ~EventClusterValidationAlgorithm().

int lar_content::EventClusterValidationAlgorithm::m_minMCHitsPerView

private

Threshold on total main MCParticle hits in each view for consideration in metric calculations.

Definition at line 122 of file EventClusterValidationAlgorithm.h.

Referenced by ApplyMCParticleMinSumHits(), EventClusterValidationAlgorithm(), ReadSettings(), Run(), and ~EventClusterValidationAlgorithm().

std::string lar_content::EventClusterValidationAlgorithm::m_treeName

private

The name of the ROOT tree.

Definition at line 119 of file EventClusterValidationAlgorithm.h.

Referenced by ReadSettings(), Run(), SetBranches(), and ~EventClusterValidationAlgorithm().

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

larpandoracontent/v04_15_01/source/larpandoracontent/LArMonitoring/EventClusterValidationAlgorithm.h
larpandoracontent/v04_15_01/source/larpandoracontent/LArMonitoring/EventClusterValidationAlgorithm.cc

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation