LArMonitoringHelper class. More...

#include "LArMonitoringHelper.h"

Static Public Member Functions
static unsigned int	CountHitsByType (const pandora::HitType hitType, const pandora::CaloHitList &caloHitList)
	Count the number of calo hits, in a provided list, of a specified type. More...

static void	GetOrderedMCParticleVector (const LArMCParticleHelper::MCContributionMapVector &selectedMCParticleToGoodHitsMaps, pandora::MCParticleVector &orderedMCParticleVector)
	Order input MCParticles by their number of hits. More...

static void	GetOrderedPfoVector (const LArMCParticleHelper::PfoContributionMap &pfoToReconstructable2DHitsMap, pandora::PfoVector &orderedPfoVector)
	Order input Pfos by their number of hits. More...

static void	PrintMCParticleTable (const LArMCParticleHelper::MCContributionMap &selectedMCParticleToGoodHitsMaps, const pandora::MCParticleVector &orderedMCParticleVector)
	Print details of selected MCParticles to the terminal in a table. More...

static void	PrintPfoTable (const LArMCParticleHelper::PfoContributionMap &pfoToReconstructable2DHitsMap, const pandora::PfoVector &orderedPfoVector)
	Print details of input Pfos to the terminal in a table. More...

static void	PrintMatchingTable (const pandora::PfoVector &orderedPfoVector, const pandora::MCParticleVector &orderedMCParticleVector, const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcParticleToPfoHitSharingMap, const unsigned int nMatches)
	Print the shared good hits between all Pfos and MCParticles. More...

template<typename Ti , typename Tj >
static float	CalcRandIndex (const std::map< const Ti, std::map< const Tj, int >> &cTable)
	Calculate the adjusted Rand Index for a given contingency table that summarises two clusterings A and B. Adjusted Rand Index is a measure of the similarity of two clusterings that is bounded above by 1 (identical), is 0 when the two clusterings are as similar as two random clusterings with the same number of clusters, and has no lower bound. An index < 0 means very discordant clusterings and is rare in most cases. Reference - https://link.springer.com/article/10.1007/BF01908075. More...

static float	CalcRandIndex (const pandora::CaloHitList &caloHits, const pandora::ClusterList &clusters)
	Calculate the adjusted Rand Index for the clustering defined by MCPartices and by CaloHits. Adjusted Rand Index is a measure of the similarity of two clusterings that is bounded above by 1 (identical), is 0 when the two clusterings are as similar as two random clusterings with the same number of clusters, and has no lower bound. An index < 0 means very discordant clusterings and is rare in most cases. Reference - https://link.springer.com/article/10.1007/BF01908075. More...

static void	FillContingencyTable (const pandora::CaloHitList &caloHits, const pandora::ClusterList &clusters, std::map< const pandora::Cluster const, std::map< const pandora::MCParticle const, int >> &cTable)
	Fill the contingency table for a set of CaloHits partitioned by Cluster and parent MCParticle. More...

Detailed Description

LArMonitoringHelper class.

Definition at line 21 of file LArMonitoringHelper.h.

Member Function Documentation

template<typename Ti , typename Tj >

float lar_content::LArMonitoringHelper::CalcRandIndex ( const std::map< const Ti, std::map< const Tj, int >> & cTable )

static

Calculate the adjusted Rand Index for a given contingency table that summarises two clusterings A and B. Adjusted Rand Index is a measure of the similarity of two clusterings that is bounded above by 1 (identical), is 0 when the two clusterings are as similar as two random clusterings with the same number of clusters, and has no lower bound. An index < 0 means very discordant clusterings and is rare in most cases. Reference - https://link.springer.com/article/10.1007/BF01908075.

Parameters

[in] cTable Contingency table as a map of the object that defines the clustering A (e.g. pandora::Cluster) to a map of the object that defines the clustering B (e.g. pandora::MCParticle) to the value of the table at this entry (which is the intersection of the two clusters)

Definition at line 319 of file LArMonitoringHelper.cc.

References util::abs(), f, and n.

Referenced by lar_content::EventClusterValidationAlgorithm::CalcRandIndex().

 {
     double aTerm{0.}; // Term made from summing over columns
     int n{0};         // Total entries in table
     for (const auto &[i, jToVal] : cTable)
     {
         int a{0};
         for (const auto &[j, val] : jToVal)
         {
             a += val;
             n += val;
         }
         aTerm += static_cast<double>(a * (a - 1)) / 2.;
     }
     if (n == 0 || n == 1) // Clustering of a set with cardinality 0 or 1 can only be perfect
         return 1.f;
 
     double bTerm{0.}; // Term made from summing over rows
     std::set<Tj> js;
     for (const auto &[i, jToVal] : cTable)
     {
         for (const auto &[j, val] : jToVal)
         {
             js.insert(j);
         }
     }
     for (const auto j : js)
     {
         int b{0};
         for (const auto &[i, jToVal] : cTable)
         {
             if (jToVal.find(j) != jToVal.end())
                 b += cTable.at(i).at(j);
         }
         bTerm += static_cast<double>(b * (b - 1)) / 2.;
     }
 
     double indexTerm{0.};
     for (const auto &[i, jToVal] : cTable)
     {
         for (const auto &[j, val] : jToVal)
         {
             indexTerm += static_cast<double>(val * (val - 1)) / 2.;
         }
     }
 
     double expIndexTerm{(aTerm * bTerm) / static_cast<double>(n * (n - 1)) / 2.};
     double maxIndexTerm{0.5 * (aTerm + bTerm)};
     if (std::abs(maxIndexTerm - expIndexTerm) < std::numeric_limits<double>::epsilon())
         return indexTerm >= expIndexTerm ? 1.f : -1.f;
     double adjustedRandIndex{(indexTerm - expIndexTerm) / (maxIndexTerm - expIndexTerm)};
 
     return adjustedRandIndex;
 }

static float lar_content::LArMonitoringHelper::CalcRandIndex	(	const pandora::CaloHitList &	caloHits,
		const pandora::ClusterList &	clusters
	)

static

Calculate the adjusted Rand Index for the clustering defined by MCPartices and by CaloHits. Adjusted Rand Index is a measure of the similarity of two clusterings that is bounded above by 1 (identical), is 0 when the two clusterings are as similar as two random clusterings with the same number of clusters, and has no lower bound. An index < 0 means very discordant clusterings and is rare in most cases. Reference - https://link.springer.com/article/10.1007/BF01908075.

Parameters

[in]	caloHits	List of hits
[in]	clusters	List of clusters

unsigned int lar_content::LArMonitoringHelper::CountHitsByType	(	const pandora::HitType	hitType,
		const pandora::CaloHitList &	caloHitList
	)

static

Count the number of calo hits, in a provided list, of a specified type.

Parameters

hitType	the hit type
caloHitList	the calo hit list

Returns: the number of calo hits of the specified type

Definition at line 28 of file LArMonitoringHelper.cc.

Referenced by lar_content::MCParticleMonitoringAlgorithm::PrintMCParticle(), lar_content::CosmicRayTaggingMonitoringTool::PrintPfoTable(), lar_content::MCParticleMonitoringAlgorithm::PrintPrimaryMCParticles(), lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), lar_content::MuonLeadingEventValidationAlgorithm::ProcessOutput(), and lar_content::LArMCParticleHelper::SelectParticlesByHitCount().

 {
     unsigned int nHitsOfSpecifiedType(0);
 
     for (const CaloHit *const pCaloHit : caloHitList)
     {
         if (hitType == pCaloHit->GetHitType())
             ++nHitsOfSpecifiedType;
     }
 
     return nHitsOfSpecifiedType;
 }

void lar_content::LArMonitoringHelper::FillContingencyTable	(	const pandora::CaloHitList &	caloHits,
		const pandora::ClusterList &	clusters,
		std::map< const pandora::Cluster const, std::map< const pandora::MCParticle const, int >> &	cTable
	)

static

Fill the contingency table for a set of CaloHits partitioned by Cluster and parent MCParticle.

Parameters

[in]	caloHits	List of hits to be considered
[in]	clusters	List of clusters that contain the hits
[out]	cTable	Contingency table as a map of Cluster to a map of MCParticle to the value of the table at this entry which is the intersection of clusterings defined by each object

Definition at line 385 of file LArMonitoringHelper.cc.

References weight.

 {
     struct CaloHitParents
     {
         const pandora::MCParticle *m_pMainMC;
         const pandora::Cluster *m_pCluster;
 
         CaloHitParents() :
             m_pMainMC{nullptr},
             m_pCluster{nullptr} {};
     };
     std::map<const CaloHit *const, CaloHitParents> hitParents;
 
     // Track the parent MC particle of each hit
     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;
         }
     }
 
     // Also track the reco cluster the hits are in
     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)
         {
             if (hitParents.find(pCaloHit) == hitParents.end()) // Hit not being considered or truth mathching was missing
                 continue;
             hitParents[pCaloHit].m_pCluster = pCluster;
         }
     }
 
     // The reco clusters and parent MC particle are the two partitions of the set of hits, fill the contingency table
     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)++;
     }
 }

void lar_content::LArMonitoringHelper::GetOrderedMCParticleVector	(	const LArMCParticleHelper::MCContributionMapVector &	selectedMCParticleToGoodHitsMaps,
		pandora::MCParticleVector &	orderedMCParticleVector
	)

static

Order input MCParticles by their number of hits.

Parameters

selectedMCParticleToGoodHitsMaps	the input vector of mappings from selected reconstructable MCParticles to their good hits
orderedMCParticleVector	the output vector of ordered MCParticles

Definition at line 43 of file LArMonitoringHelper.cc.

Referenced by lar_content::MuonLeadingEventValidationAlgorithm::DetermineIncorrectlyReconstructedCosmicRays(), lar_content::NeutrinoEventValidationAlgorithm::FillValidationInfo(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::EventValidationBaseAlgorithm::InterpretMatching(), lar_content::MCParticleMonitoringAlgorithm::PrintPrimaryMCParticles(), lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), and lar_content::PfoValidationAlgorithm::Run().

 {
     for (const LArMCParticleHelper::MCContributionMap &mcParticleToGoodHitsMap : selectedMCParticleToGoodHitsMaps)
     {
         if (mcParticleToGoodHitsMap.empty())
             continue;
 
         // Copy map contents to vector it can be sorted
         std::vector<LArMCParticleHelper::MCParticleCaloHitListPair> mcParticleToGoodHitsVect;
         std::copy(mcParticleToGoodHitsMap.begin(), mcParticleToGoodHitsMap.end(), std::back_inserter(mcParticleToGoodHitsVect));
 
         // Sort by number of hits descending
         std::sort(mcParticleToGoodHitsVect.begin(), mcParticleToGoodHitsVect.end(),
             [](const LArMCParticleHelper::MCParticleCaloHitListPair &a, const LArMCParticleHelper::MCParticleCaloHitListPair &b) -> bool
             {
                 // Neutrinos, then beam particles, then cosmic rays
                 const bool isANuFinalState(LArMCParticleHelper::IsBeamNeutrinoFinalState(a.first)),
                     isBNuFinalState(LArMCParticleHelper::IsBeamNeutrinoFinalState(b.first));
 
                 if (isANuFinalState != isBNuFinalState)
                     return isANuFinalState;
 
                 const bool isABeamParticle(LArMCParticleHelper::IsBeamParticle(a.first)),
                     isBBeamParticle(LArMCParticleHelper::IsBeamParticle(b.first));
 
                 if (isABeamParticle != isBBeamParticle)
                     return isABeamParticle;
 
                 // Then sort by numbers of true hits
                 if (a.second.size() != b.second.size())
                     return (a.second.size() > b.second.size());
 
                 // Default to normal MCParticle sorting
                 return LArMCParticleHelper::SortByMomentum(a.first, b.first);
             });
 
         for (const LArMCParticleHelper::MCParticleCaloHitListPair &mcParticleCaloHitPair : mcParticleToGoodHitsVect)
             orderedMCParticleVector.push_back(mcParticleCaloHitPair.first);
     }
 
     // Check that all elements of the vector are unique
     const unsigned int nMCParticles(orderedMCParticleVector.size());
     if (std::distance(orderedMCParticleVector.begin(), std::unique(orderedMCParticleVector.begin(), orderedMCParticleVector.end())) != nMCParticles)
         throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 }

void lar_content::LArMonitoringHelper::GetOrderedPfoVector	(	const LArMCParticleHelper::PfoContributionMap &	pfoToReconstructable2DHitsMap,
		pandora::PfoVector &	orderedPfoVector
	)

static

Order input Pfos by their number of hits.

Parameters

pfoToReconstructable2DHitsMap	the input vector of mappings from Pfos to their reconstructable hits
orderedPfoVector	the output vector of ordered Pfos

Definition at line 92 of file LArMonitoringHelper.cc.

Referenced by lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), and lar_content::PfoValidationAlgorithm::Run().

 {
     // Copy map contents to vector it can be sorted
     std::vector<LArMCParticleHelper::PfoCaloHitListPair> pfoToReconstructable2DHitsVect;
     std::copy(pfoToReconstructable2DHitsMap.begin(), pfoToReconstructable2DHitsMap.end(), std::back_inserter(pfoToReconstructable2DHitsVect));
 
     // Sort by number of hits descending putting neutrino final states first
     std::sort(pfoToReconstructable2DHitsVect.begin(), pfoToReconstructable2DHitsVect.end(),
         [](const LArMCParticleHelper::PfoCaloHitListPair &a, const LArMCParticleHelper::PfoCaloHitListPair &b) -> bool
         {
             // Neutrinos before cosmic rays
             const bool isANuFinalState(LArPfoHelper::IsNeutrinoFinalState(a.first)), isBNuFinalState(LArPfoHelper::IsNeutrinoFinalState(b.first));
 
             if (isANuFinalState != isBNuFinalState)
                 return isANuFinalState;
 
             if (a.second.size() != b.second.size())
                 return (a.second.size() > b.second.size());
 
             // Default to normal pfo sorting
             return LArPfoHelper::SortByNHits(a.first, b.first);
         });
 
     for (const LArMCParticleHelper::PfoCaloHitListPair &pfoCaloHitPair : pfoToReconstructable2DHitsVect)
         orderedPfoVector.push_back(pfoCaloHitPair.first);
 
     // Check that all elements of the vector are unique
     const unsigned int nPfos(orderedPfoVector.size());
     if (std::distance(orderedPfoVector.begin(), std::unique(orderedPfoVector.begin(), orderedPfoVector.end())) != nPfos)
         throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 }

void lar_content::LArMonitoringHelper::PrintMatchingTable	(	const pandora::PfoVector &	orderedPfoVector,
		const pandora::MCParticleVector &	orderedMCParticleVector,
		const LArMCParticleHelper::MCParticleToPfoHitSharingMap &	mcParticleToPfoHitSharingMap,
		const unsigned int	nMatches
	)

static

Print the shared good hits between all Pfos and MCParticles.

Parameters

orderedPfoVector	the input vector of ordered Pfos
orderedMCParticleVector	the input vector of ordered MCParticles
mcParticleToPfoHitSharingMap	the output mapping from selected reconstructable MCParticles to Pfos and the number hits shared
nMatches	the maximum number of Pfo matches to show

Definition at line 205 of file LArMonitoringHelper.cc.

References lar_content::LArFormattingHelper::Table::AddElement(), and lar_content::LArFormattingHelper::Table::Print().

Referenced by lar_content::PfoValidationAlgorithm::Run().

 {
     if (orderedPfoVector.empty())
     {
         std::cout << "No Pfos supplied." << std::endl;
         return;
     }
 
     if (orderedMCParticleVector.empty())
     {
         std::cout << "No MCParticles supplied." << std::endl;
         return;
     }
 
     // Get the maximum number of MCParticle to Pfos matches that need to be shown
     unsigned int maxMatches(0);
     for (const auto &entry : mcParticleToPfoHitSharingMap)
         maxMatches = std::max(static_cast<unsigned int>(entry.second.size()), maxMatches);
 
     const bool showOthersColumn(maxMatches > nMatches);
     const unsigned int nMatchesToShow(std::min(maxMatches, nMatches));
 
     // Set up the table headers
     std::vector<std::string> tableHeaders({"MCParticle", ""});
     for (unsigned int i = 0; i < nMatchesToShow; ++i)
     {
         tableHeaders.push_back("");
         tableHeaders.push_back("Pfo");
         tableHeaders.push_back("nSharedHits");
     }
 
     if (showOthersColumn)
     {
         tableHeaders.push_back("");
         tableHeaders.push_back("");
         tableHeaders.push_back("nOtherPfos");
         tableHeaders.push_back("nSharedHits");
     }
 
     LArFormattingHelper::Table table(tableHeaders);
 
     // Make a new row for each MCParticle
     for (unsigned int mcParticleId = 0; mcParticleId < orderedMCParticleVector.size(); ++mcParticleId)
     {
         const MCParticle *const pMCParticle(orderedMCParticleVector.at(mcParticleId));
         LArMCParticleHelper::MCParticleToPfoHitSharingMap::const_iterator it = mcParticleToPfoHitSharingMap.find(pMCParticle);
         LArMCParticleHelper::PfoToSharedHitsVector pfoToSharedHitsVector;
 
         if (it != mcParticleToPfoHitSharingMap.end())
             pfoToSharedHitsVector = it->second;
 
         const LArFormattingHelper::Color mcCol(LArMCParticleHelper::IsBeamNeutrinoFinalState(pMCParticle)
                 ? LArFormattingHelper::LIGHT_GREEN
                 : (LArMCParticleHelper::IsBeamParticle(pMCParticle) ? LArFormattingHelper::LIGHT_BLUE : LArFormattingHelper::LIGHT_RED));
 
         // ATTN enumerate from 1 to match event validation algorithm
         table.AddElement(mcParticleId + 1, LArFormattingHelper::REGULAR, mcCol);
 
         // Get the matched Pfos
         unsigned int nPfosShown(0);
         unsigned int nOtherHits(0);
         for (const auto &pfoNSharedHitsPair : pfoToSharedHitsVector)
         {
             for (unsigned int pfoId = 0; pfoId < orderedPfoVector.size(); ++pfoId)
             {
                 if (pfoNSharedHitsPair.first != orderedPfoVector.at(pfoId))
                     continue;
 
                 if (nPfosShown < nMatchesToShow)
                 {
                     // ATTN enumerate from 1 to match event validation algorithm
                     const LArFormattingHelper::Color pfoCol(
                         LArPfoHelper::IsNeutrinoFinalState(pfoNSharedHitsPair.first) ? LArFormattingHelper::LIGHT_GREEN : LArFormattingHelper::LIGHT_RED);
                     table.AddElement(pfoId + 1, LArFormattingHelper::REGULAR, pfoCol);
                     table.AddElement(pfoNSharedHitsPair.second.size(), LArFormattingHelper::REGULAR, pfoCol);
                     nPfosShown++;
                 }
                 else
                 {
                     nOtherHits += pfoNSharedHitsPair.second.size();
                 }
                 break;
             }
         }
 
         // Pad the rest of the row with empty entries
         for (unsigned int i = 0; i < nMatchesToShow - nPfosShown; ++i)
         {
             table.AddElement("");
             table.AddElement("");
         }
 
         // Print any remaining matches
         if (!showOthersColumn)
             continue;
 
         if (nOtherHits != 0)
         {
             table.AddElement(pfoToSharedHitsVector.size() - nPfosShown);
             table.AddElement(nOtherHits);
         }
         else
         {
             table.AddElement("");
             table.AddElement("");
         }
     }
     table.Print();
 }

void lar_content::LArMonitoringHelper::PrintMCParticleTable	(	const LArMCParticleHelper::MCContributionMap &	selectedMCParticleToGoodHitsMaps,
		const pandora::MCParticleVector &	orderedMCParticleVector
	)

static

Print details of selected MCParticles to the terminal in a table.

Parameters

selectedMCParticleToGoodHitsMap	the input mapping from selected reconstructable MCParticles to their good hits
orderedMCParticleVector	the input vector of ordered MCParticles

Definition at line 126 of file LArMonitoringHelper.cc.

Referenced by lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), and lar_content::PfoValidationAlgorithm::Run().

 {
     if (selectedMCParticleToGoodHitsMap.empty())
     {
         std::cout << "No MCParticles supplied." << std::endl;
         return;
     }
 
     LArFormattingHelper::Table table({"ID", "NUANCE", "TYPE", "", "E", "dist", "", "nGoodHits", "U", "V", "W"});
 
     unsigned int usedParticleCount(0);
     for (unsigned int id = 0; id < orderedMCParticleVector.size(); ++id)
     {
         const MCParticle *const pMCParticle(orderedMCParticleVector.at(id));
 
         LArMCParticleHelper::MCContributionMap::const_iterator it = selectedMCParticleToGoodHitsMap.find(pMCParticle);
         if (selectedMCParticleToGoodHitsMap.end() == it)
             continue; // ATTN MCParticles in selectedMCParticleToGoodHitsMap may be a subset of orderedMCParticleVector
 
         // ATTN enumerate from 1 to match event validation algorithm
         table.AddElement(id + 1);
         table.AddElement(LArMCParticleHelper::GetNuanceCode(pMCParticle));
         table.AddElement(PdgTable::GetParticleName(pMCParticle->GetParticleId()));
 
         table.AddElement(pMCParticle->GetEnergy());
         table.AddElement((pMCParticle->GetEndpoint() - pMCParticle->GetVertex()).GetMagnitude());
 
         table.AddElement(it->second.size());
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, it->second));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, it->second));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, it->second));
 
         usedParticleCount++;
     }
 
     // Check every MCParticle in selectedMCParticleToGoodHitsMap has been printed
     if (usedParticleCount != selectedMCParticleToGoodHitsMap.size())
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     table.Print();
 }

void lar_content::LArMonitoringHelper::PrintPfoTable	(	const LArMCParticleHelper::PfoContributionMap &	pfoToReconstructable2DHitsMap,
		const pandora::PfoVector &	orderedPfoVector
	)

static

Print details of input Pfos to the terminal in a table.

Parameters

pfoToReconstructable2DHitsMap	the input vector of mappings from Pfos to their reconstructable hits
orderedPfoVector	the input vector of ordered Pfos

Definition at line 171 of file LArMonitoringHelper.cc.

Referenced by lar_content::PfoValidationAlgorithm::Run().

 {
     if (pfoToReconstructable2DHitsMap.empty())
     {
         std::cout << "No Pfos supplied." << std::endl;
         return;
     }
 
     LArFormattingHelper::Table table({"ID", "PID", "Is Nu FS", "", "nGoodHits", "U", "V", "W"});
 
     for (unsigned int id = 0; id < orderedPfoVector.size(); ++id)
     {
         const ParticleFlowObject *const pPfo(orderedPfoVector.at(id));
 
         LArMCParticleHelper::PfoContributionMap::const_iterator it = pfoToReconstructable2DHitsMap.find(pPfo);
         if (pfoToReconstructable2DHitsMap.end() == it)
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         // ATTN enumerate from 1 to match event validation algorithm
         table.AddElement(id + 1);
         table.AddElement(pPfo->GetParticleId());
         table.AddElement(LArPfoHelper::IsNeutrinoFinalState(pPfo));
 
         table.AddElement(it->second.size());
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, it->second));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, it->second));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, it->second));
     }
 
     table.Print();
 }

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

larpandoracontent/v04_15_01/source/larpandoracontent/LArHelpers/LArMonitoringHelper.h
larpandoracontent/v04_15_01/source/larpandoracontent/LArHelpers/LArMonitoringHelper.cc

Static Public Member Functions

Detailed Description

Member Function Documentation