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

Detailed Description

LArMonitoringHelper class.

Definition at line 21 of file LArMonitoringHelper.h.

Member Function Documentation

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::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_08_01/source/larpandoracontent/LArHelpers/LArMonitoringHelper.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArHelpers/LArMonitoringHelper.cc

Static Public Member Functions

Detailed Description

Member Function Documentation