HierarchyMonitoringAlgorithm class. More...

#include <HierarchyMonitoringAlgorithm.h>

Inheritance diagram for lar_content::HierarchyMonitoringAlgorithm:

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

virtual	~HierarchyMonitoringAlgorithm ()

Private Member Functions
pandora::StatusCode	Run ()

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

void	VisualizeMC (const LArHierarchyHelper::MCHierarchy &hierarchy) const
	Visualize MC nodes. More...

void	VisualizeMCDistinct (const LArHierarchyHelper::MCHierarchy &hierarchy) const
	Visualize MC nodes without grouping by particle id. More...

void	VisualizeMCProcess (const LArHierarchyHelper::MCHierarchy &hierarchy) const
	Visualize MC nodes based on the MC process that created them. More...

void	VisualizeReco (const LArHierarchyHelper::RecoHierarchy &hierarchy) const
	Visualize the reco nodes. More...

void	VisualizeMatches (const LArHierarchyHelper::MatchInfo &matchInfo) const
	Visualize reco to MC matches. More...

void	VisualizeMatchedMC (const LArHierarchyHelper::MCMatches &matches, const int mcIdx) const
	Visualize the reco nodes matched to a single MC node. More...

void	VisualizeUnmatchedReco (const LArHierarchyHelper::RecoHierarchy::Node *pNode) const
	Visualize the unmatched reco node. More...

void	Visualize (const pandora::CaloHitList &hits, const std::string &label, const int color) const
	Visualize a calo hit list. More...

void	FillHitLists (const pandora::CaloHitList &hits, pandora::CaloHitList &uHits, pandora::CaloHitList &vHits, pandora::CaloHitList &wHits) const
	Fill per view hit lists. More...

Private Attributes
std::string	m_caloHitListName
	Name of input calo hit list. More...

std::string	m_pfoListName
	Name of input PFO list. More...

bool	m_visualizeMC
	Whether or not to visualize the MC nodes. More...

bool	m_visualizeReco
	Whether or not to visualize the reco nodes. More...

bool	m_visualizeDistinct
	If true, allocate colours without consideration of particle id. More...

bool	m_visualizeProcess
	If true, allocate colours based on the MC process. More...

bool	m_match
	Whether or not to visualize the reco to MC matches. More...

bool	m_collectionOnly
	Limit display to the collection plane only. More...

bool	m_foldToPrimaries
	Whether or not to fold everything back to primaries. More...

bool	m_foldDynamic
	Whether or not to fold based on process information. More...

float	m_transparencyThresholdE
	Cell energy for which transparency is saturated (0%, fully opaque) More...

float	m_energyScaleThresholdE
	Cell energy for which color is at top end of continous color palette. More...

float	m_scalingFactor
	TEve works with [cm], Pandora usually works with [mm] (but LArContent went with cm too) More...

Detailed Description

HierarchyMonitoringAlgorithm class.

Definition at line 22 of file HierarchyMonitoringAlgorithm.h.

Constructor & Destructor Documentation

lar_content::HierarchyMonitoringAlgorithm::HierarchyMonitoringAlgorithm ( )

Default constructor.

Definition at line 18 of file HierarchyMonitoringAlgorithm.cc.

                                                            :
     m_visualizeMC(false),
     m_visualizeReco(false),
     m_visualizeDistinct(false),
     m_visualizeProcess{false},
     m_match(false),
     m_collectionOnly{false},
     m_foldToPrimaries{false},
     m_foldDynamic{true},
     m_transparencyThresholdE{-1.f},
     m_energyScaleThresholdE{1.f},
     m_scalingFactor{1.f}
 {
 }

lar_content::HierarchyMonitoringAlgorithm::~HierarchyMonitoringAlgorithm ( )

virtual

Definition at line 35 of file HierarchyMonitoringAlgorithm.cc.

 {
     PANDORA_MONITORING_API(SaveTree(this->GetPandora(), "processes", "processes.root", "UPDATE"));
 }

Member Function Documentation

void lar_content::HierarchyMonitoringAlgorithm::FillHitLists	(	const pandora::CaloHitList &	hits,
		pandora::CaloHitList &	uHits,
		pandora::CaloHitList &	vHits,
		pandora::CaloHitList &	wHits
	)		const

private

Fill per view hit lists.

Parameters

hits	The input list of hits
uHits	The output list of hits in U
vHits	The output list of hits in V
wHits	The output list of hits in W

Definition at line 378 of file HierarchyMonitoringAlgorithm.cc.

 {
     for (const CaloHit *pCaloHit : hits)
     {
         const HitType view{pCaloHit->GetHitType()};
         if (view == HitType::TPC_VIEW_U)
             uHits.emplace_back(pCaloHit);
         else if (view == HitType::TPC_VIEW_V)
             vHits.emplace_back(pCaloHit);
         else if (view == HitType::TPC_VIEW_W)
             wHits.emplace_back(pCaloHit);
     }
 }

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

private

Definition at line 394 of file HierarchyMonitoringAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListName", m_caloHitListName));
     if (m_caloHitListName.empty())
         m_caloHitListName = "CaloHitList2D";
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PfoListName", m_pfoListName));
     if (m_pfoListName.empty())
         m_pfoListName = "RecreatedPfos";
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VisualizeMC", m_visualizeMC));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VisualizeReco", m_visualizeReco));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VisualizeDistinct", m_visualizeDistinct));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VisualizeProcess", m_visualizeProcess));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PerformMatching", m_match));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CollectionOnly", m_collectionOnly));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FoldToPrimaries", m_foldToPrimaries));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FoldDynamic", m_foldDynamic));
     if (m_foldToPrimaries)
         m_foldDynamic = false;
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TransparencyThresholdE", m_transparencyThresholdE));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EnergyScaleThresholdE", m_energyScaleThresholdE));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ScalingFactor", m_scalingFactor));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::HierarchyMonitoringAlgorithm::Run ( )

private

Definition at line 42 of file HierarchyMonitoringAlgorithm.cc.

 {
     PANDORA_MONITORING_API(
         SetEveDisplayParameters(this->GetPandora(), true, DETECTOR_VIEW_XZ, m_transparencyThresholdE, m_energyScaleThresholdE, m_scalingFactor));
 
     const CaloHitList *pCaloHitList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pCaloHitList));
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));
     const PfoList *pPfoList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_pfoListName, pPfoList));
 
     LArHierarchyHelper::MCHierarchy::ReconstructabilityCriteria criteria(15, 5, 2, false);
     LArHierarchyHelper::MCHierarchy mcHierarchy(criteria);
     LArHierarchyHelper::RecoHierarchy recoHierarchy;
     LArHierarchyHelper::FoldingParameters foldParameters;
     if (m_foldToPrimaries)
         foldParameters.m_foldToTier = true;
     else if (m_foldDynamic)
         foldParameters.m_foldDynamic = true;
 
     if (m_visualizeMC || m_match)
         LArHierarchyHelper::FillMCHierarchy(*pMCParticleList, *pCaloHitList, foldParameters, mcHierarchy);
     if (m_visualizeReco || m_match)
         LArHierarchyHelper::FillRecoHierarchy(*pPfoList, foldParameters, recoHierarchy);
     if (m_match)
     {
         LArHierarchyHelper::MatchInfo matchInfo;
         LArHierarchyHelper::MatchHierarchies(mcHierarchy, recoHierarchy, matchInfo);
         matchInfo.Print(mcHierarchy);
         this->VisualizeMatches(matchInfo);
     }
     else
     {
         if (m_visualizeMC)
         {
             if (m_visualizeDistinct)
                 this->VisualizeMCDistinct(mcHierarchy);
             else if (m_visualizeProcess)
                 this->VisualizeMCProcess(mcHierarchy);
             else
                 this->VisualizeMC(mcHierarchy);
         }
         if (m_visualizeReco)
             this->VisualizeReco(recoHierarchy);
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::HierarchyMonitoringAlgorithm::Visualize	(	const pandora::CaloHitList &	hits,
		const std::string &	label,
		const int	color
	)		const

private

Visualize a calo hit list.

Parameters

hits	The hits to visualize
label	The label to apply to the hits
color	The color to apply to the hits

Definition at line 366 of file HierarchyMonitoringAlgorithm.cc.

 {
     if (!hits.empty() && hits.size() > 1)
     {
         if (m_collectionOnly && hits.front()->GetHitType() != TPC_VIEW_W)
             return;
         PANDORA_MONITORING_API(VisualizeCaloHits(this->GetPandora(), &hits, label, static_cast<Color>(color)));
     }
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeMatchedMC	(	const LArHierarchyHelper::MCMatches &	matches,
		const int	mcIdx
	)		const

private

Visualize the reco nodes matched to a single MC node.

Parameters

matches	The MC to reco matches
mcIdx	The unique identifier for the MC particle

Definition at line 273 of file HierarchyMonitoringAlgorithm.cc.

 {
     const std::map<int, const std::string> keys = {{13, "mu"}, {11, "e"}, {22, "gamma"}, {321, "kaon"}, {211, "pi"}, {2212, "p"}};
     const int green{3}, gray{14};
     const std::map<int, int> colors = {{0, 5}, {1, 2}, {2, 9}, {3, 1}, {4, 4}};
 
     const LArHierarchyHelper::MCHierarchy::Node *pMCNode{matches.GetMC()};
     const int pdg{pMCNode->GetParticleId()};
 
     std::string key("other");
     if (keys.find(pdg) != keys.end())
         key = keys.at(pdg);
 
     CaloHitList mcUHits, mcVHits, mcWHits;
     this->FillHitLists(pMCNode->GetCaloHits(), mcUHits, mcVHits, mcWHits);
     std::string leading{pMCNode->IsLeadingLepton() ? "_leading" : ""};
     if (!matches.GetRecoMatches().empty())
     {
         std::string suffix{std::to_string(mcIdx) + "_" + key + leading};
         this->Visualize(mcUHits, "u_" + suffix, green);
         this->Visualize(mcVHits, "v_" + suffix, green);
         this->Visualize(mcWHits, "w_" + suffix, green);
     }
     else
     {
         std::string suffix{std::to_string(mcIdx) + "_" + key + "_unmatched"};
         this->Visualize(mcUHits, "u_" + suffix, gray);
         this->Visualize(mcVHits, "v_" + suffix, gray);
         this->Visualize(mcWHits, "w_" + suffix, gray);
     }
 
     int recoIdx{0};
     size_t colorIdx{0};
     for (const LArHierarchyHelper::RecoHierarchy::Node *pRecoNode : matches.GetRecoMatches())
     {
         CaloHitList recoUHits, recoVHits, recoWHits;
         this->FillHitLists(pRecoNode->GetCaloHits(), recoUHits, recoVHits, recoWHits);
         const int characterisation{pRecoNode->GetParticleId()};
         const std::string recoKey{characterisation == MU_MINUS ? "T" : characterisation == E_MINUS ? "S" : "?"};
         const std::string recoSuffix{std::to_string(mcIdx) + "->" + std::to_string(recoIdx) + "_" + recoKey};
         if (!recoUHits.empty())
         {
             const float purity{matches.GetPurity(pRecoNode, TPC_VIEW_U, true)};
             const float completeness{matches.GetCompleteness(pRecoNode, TPC_VIEW_U, true)};
             std::ostringstream metrics;
             metrics.precision(2);
             metrics << std::fixed << " p: " << purity << " c: " << completeness;
             PANDORA_MONITORING_API(
                 VisualizeCaloHits(this->GetPandora(), &recoUHits, "u_" + recoSuffix + metrics.str(), static_cast<Color>(colors.at(colorIdx))));
         }
         if (!recoVHits.empty())
         {
             const float purity{matches.GetPurity(pRecoNode, TPC_VIEW_V, true)};
             const float completeness{matches.GetCompleteness(pRecoNode, TPC_VIEW_V, true)};
             std::ostringstream metrics;
             metrics.precision(2);
             metrics << std::fixed << " p: " << purity << " c: " << completeness;
             PANDORA_MONITORING_API(
                 VisualizeCaloHits(this->GetPandora(), &recoVHits, "v_" + recoSuffix + metrics.str(), static_cast<Color>(colors.at(colorIdx))));
         }
         if (!recoWHits.empty())
         {
             const float purity{matches.GetPurity(pRecoNode, TPC_VIEW_W, true)};
             const float completeness{matches.GetCompleteness(pRecoNode, TPC_VIEW_W, true)};
             std::ostringstream metrics;
             metrics.precision(2);
             metrics << std::fixed << " p: " << purity << " c: " << completeness;
             PANDORA_MONITORING_API(
                 VisualizeCaloHits(this->GetPandora(), &recoWHits, "w_" + recoSuffix + metrics.str(), static_cast<Color>(colors.at(colorIdx))));
         }
         colorIdx = (colorIdx + 1) >= colors.size() ? 0 : colorIdx + 1;
         ++recoIdx;
     }
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeMatches ( const LArHierarchyHelper::MatchInfo & matchInfo ) const

private

Visualize reco to MC matches.

Parameters

matchInfo The match information between reco and MC hierarchies

Definition at line 254 of file HierarchyMonitoringAlgorithm.cc.

 {
     std::map<const LArHierarchyHelper::MCHierarchy::Node *, int> mcIdxMap;
     int mcIdx{0};
     for (const LArHierarchyHelper::MCMatches &matches : matchInfo.GetMatches())
         if (mcIdxMap.find(matches.GetMC()) == mcIdxMap.end())
             mcIdxMap[matches.GetMC()] = mcIdx++;
 
     for (const LArHierarchyHelper::MCMatches &matches : matchInfo.GetMatches())
         this->VisualizeMatchedMC(matches, mcIdxMap.at(matches.GetMC()));
 
     for (const LArHierarchyHelper::RecoHierarchy::Node *pNode : matchInfo.GetUnmatchedReco())
         this->VisualizeUnmatchedReco(pNode);
 
     PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeMC ( const LArHierarchyHelper::MCHierarchy & hierarchy ) const

private

Visualize MC nodes.

Parameters

hierarchy The MC hierarchy to render

Definition at line 94 of file HierarchyMonitoringAlgorithm.cc.

 {
     const std::map<int, const std::string> keys = {{13, "mu"}, {11, "e"}, {22, "gamma"}, {321, "kaon"}, {211, "pi"}, {2212, "p"}};
     const std::map<std::string, int> colors = {{"mu", 5}, {"e", 2}, {"gamma", 9}, {"kaon", 1}, {"pi", 3}, {"p", 4}, {"other", 14}};
 
     LArHierarchyHelper::MCHierarchy::NodeVector nodes;
     hierarchy.GetFlattenedNodes(nodes);
 
     int nodeIdx{0};
     for (const LArHierarchyHelper::MCHierarchy::Node *pNode : nodes)
     {
         std::string key("other");
         const int pdg{std::abs(pNode->GetParticleId())};
         if (keys.find(pdg) != keys.end())
             key = keys.at(pdg);
 
         CaloHitList uHits, vHits, wHits;
         this->FillHitLists(pNode->GetCaloHits(), uHits, vHits, wHits);
         std::string suffix{std::to_string(nodeIdx) + "_" + key};
         this->Visualize(uHits, "u_" + suffix, colors.at(key));
         this->Visualize(vHits, "v_" + suffix, colors.at(key));
         this->Visualize(wHits, "w_" + suffix, colors.at(key));
         ++nodeIdx;
     }
 
     PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeMCDistinct ( const LArHierarchyHelper::MCHierarchy & hierarchy ) const

private

Visualize MC nodes without grouping by particle id.

Parameters

hierarchy The MC hierarchy to render

Definition at line 124 of file HierarchyMonitoringAlgorithm.cc.

 {
     const std::map<int, const std::string> keys = {{13, "mu"}, {11, "e"}, {22, "gamma"}, {321, "kaon"}, {211, "pi"}, {2212, "p"}};
     const int nColours{9};
     const int colors[nColours] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 
     LArHierarchyHelper::MCHierarchy::NodeVector nodes;
     hierarchy.GetFlattenedNodes(nodes);
 
     int nodeIdx{0}, colorIdx{0};
     for (const LArHierarchyHelper::MCHierarchy::Node *pNode : nodes)
     {
         std::string key("other");
         const int pdg{std::abs(pNode->GetParticleId())};
         if (keys.find(pdg) != keys.end())
             key = keys.at(pdg);
 
         CaloHitList uHits, vHits, wHits;
         this->FillHitLists(pNode->GetCaloHits(), uHits, vHits, wHits);
         std::string suffix{std::to_string(nodeIdx) + "_" + key};
         this->Visualize(uHits, "u_" + suffix, colors[colorIdx]);
         this->Visualize(vHits, "v_" + suffix, colors[colorIdx]);
         this->Visualize(wHits, "w_" + suffix, colors[colorIdx]);
         colorIdx = (colorIdx + 1) >= nColours ? 0 : colorIdx + 1;
         ++nodeIdx;
     }
 
     PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeMCProcess ( const LArHierarchyHelper::MCHierarchy & hierarchy ) const

private

Visualize MC nodes based on the MC process that created them.

Parameters

hierarchy The MC hierarchy to render

Definition at line 156 of file HierarchyMonitoringAlgorithm.cc.

 {
     const std::map<MCProcess, std::string> procToCategoryMap = {{MC_PROC_INCIDENT_NU, "invisible"}, {MC_PROC_UNKNOWN, "invisible"},
         {MC_PROC_PRIMARY, "primary"}, {MC_PROC_COMPT, "compt"}, {MC_PROC_PHOT, "phot"}, {MC_PROC_ANNIHIL, "annihil"}, {MC_PROC_E_IONI, "ioni"},
         {MC_PROC_E_BREM, "brem"}, {MC_PROC_CONV, "conv"}, {MC_PROC_MU_IONI, "ioni"}, {MC_PROC_MU_MINUS_CAPTURE_AT_REST, "capture"},
         {MC_PROC_NEUTRON_INELASTIC, "inelastic"}, {MC_PROC_N_CAPTURE, "capture"}, {MC_PROC_HAD_ELASTIC, "elastic"}, {MC_PROC_DECAY, "decay"},
         {MC_PROC_COULOMB_SCAT, "coulomb"}, {MC_PROC_MU_BREM, "brem"}, {MC_PROC_MU_PAIR_PROD, "pair_prod"}, {MC_PROC_PHOTON_INELASTIC, "inelastic"},
         {MC_PROC_HAD_IONI, "ioni"}, {MC_PROC_PROTON_INELASTIC, "inelastic"}, {MC_PROC_PI_PLUS_INELASTIC, "inelastic"},
         {MC_PROC_CHIPS_NUCLEAR_CAPTURE_AT_REST, "capture"}, {MC_PROC_PI_MINUS_INELASTIC, "inelastic"}, {MC_PROC_TRANSPORTATION, "transport"},
         {MC_PROC_RAYLEIGH, "rayleigh"}, {MC_PROC_HAD_BREM, "brem"}, {MC_PROC_HAD_PAIR_PROD, "pair_prod"}, {MC_PROC_ION_IONI, "ioni"},
         {MC_PROC_NEUTRON_KILLER, "kill"}, {MC_PROC_ION_INELASTIC, "inelastic"}, {MC_PROC_HE3_INELASTIC, "inelastic"},
         {MC_PROC_ALPHA_INELASTIC, "inelastic"}, {MC_PROC_ANTI_HE3_INELASTIC, "inelastic"}, {MC_PROC_ANTI_ALPHA_INELASTIC, "inelastic"},
         {MC_PROC_HAD_FRITIOF_CAPTURE_AT_REST, "inelastic"}, {MC_PROC_ANTI_DEUTERON_INELASTIC, "inelastic"},
         {MC_PROC_ANTI_NEUTRON_INELASTIC, "inelastic"}, {MC_PROC_ANTI_PROTON_INELASTIC, "inelastic"},
         {MC_PROC_ANTI_TRITON_INELASTIC, "inelastic"}, {MC_PROC_DEUTERON_INELASTIC, "inelastic"}, {MC_PROC_ELECTRON_NUCLEAR, "nuclear"},
         {MC_PROC_PHOTON_NUCLEAR, "nuclear"}, {MC_PROC_KAON_PLUS_INELASTIC, "inelastic"}, {MC_PROC_KAON_MINUS_INELASTIC, "inelastic"},
         {MC_PROC_HAD_BERTINI_CAPTURE_AT_REST, "capture"}, {MC_PROC_LAMBDA_INELASTIC, "inelastic"}, {MC_PROC_MU_NUCLEAR, "nuclear"},
         {MC_PROC_TRITON_INELASTIC, "inelastic"}, {MC_PROC_PRIMARY_BACKGROUND, "background"}};
 
     const std::map<std::string, int> categoryToColorMap = {{"invisible", 0}, {"primary", 1}, {"compt", 2}, {"phot", 3}, {"annihil", 4},
         {"ioni", 5}, {"brem", 6}, {"conv", 3}, {"capture", 6}, {"inelastic", 9}, {"elastic", 8}, {"decay", 7}, {"coulomb", 9},
         {"pair_prod", 4}, {"transport", 1}, {"rayleigh", 9}, {"kill", 2}, {"nuclear", 5}, {"background", 7}};
 
     LArHierarchyHelper::MCHierarchy::NodeVector nodes;
     hierarchy.GetFlattenedNodes(nodes);
 
     int nodeIdx{0};
     for (const LArHierarchyHelper::MCHierarchy::Node *pNode : nodes)
     {
         const LArMCParticle *pMC{dynamic_cast<const LArMCParticle *>(pNode->GetLeadingMCParticle())};
         if (!pMC)
             continue;
         const MCProcess process{pMC->GetProcess()};
         const std::string category{procToCategoryMap.at(process)};
         const int pdg{std::abs(pNode->GetParticleId())};
         const int tier{LArMCParticleHelper::GetHierarchyTier(pMC)};
 
         CaloHitList uHits, vHits, wHits;
         this->FillHitLists(pNode->GetCaloHits(), uHits, vHits, wHits);
         std::string suffix{std::to_string(nodeIdx) + " (" + std::to_string(tier) + ") " + std::to_string(pdg) + " " + category + " " +
                            std::to_string(process)};
         if (process == MC_PROC_DECAY)
         {
             const MCParticleList &parentList{pMC->GetParentList()};
             if (!parentList.empty())
             {
                 const MCParticle *pParent{parentList.front()};
                 const int parentPdg{std::abs(pParent->GetParticleId())};
                 suffix += " from " + std::to_string(parentPdg);
             }
         }
 
         this->Visualize(uHits, "U " + suffix, categoryToColorMap.at(category));
         this->Visualize(vHits, "V " + suffix, categoryToColorMap.at(category));
         this->Visualize(wHits, "W " + suffix, categoryToColorMap.at(category));
         ++nodeIdx;
 
         const int proc{static_cast<int>(process)};
         const float mom{pMC->GetMomentum().GetMagnitude()};
         PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), "processes", "process", proc));
         PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), "processes", "momentum", mom));
         PANDORA_MONITORING_API(FillTree(this->GetPandora(), "processes"));
     }
 
     PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeReco ( const LArHierarchyHelper::RecoHierarchy & hierarchy ) const

private

Visualize the reco nodes.

Parameters

hierarchy The reco hierarchy to render

Definition at line 225 of file HierarchyMonitoringAlgorithm.cc.

 {
     const int nColors{7};
     const int colors[nColors] = {5, 2, 9, 1, 3, 4, 14};
 
     LArHierarchyHelper::RecoHierarchy::NodeVector nodes;
     hierarchy.GetFlattenedNodes(nodes);
 
     int colorIdx{0};
     int pfoIdx{0};
     for (const LArHierarchyHelper::RecoHierarchy::Node *pNode : nodes)
     {
         CaloHitList uHits, vHits, wHits;
         this->FillHitLists(pNode->GetCaloHits(), uHits, vHits, wHits);
         const int pdg{pNode->GetParticleId()};
         const std::string key{pdg == MU_MINUS ? "T" : pdg == E_MINUS ? "S" : "?"};
         const std::string suffix{std::to_string(pfoIdx) + "_" + key};
         this->Visualize(uHits, "u_" + suffix, colors[colorIdx]);
         this->Visualize(vHits, "v_" + suffix, colors[colorIdx]);
         this->Visualize(wHits, "w_" + suffix, colors[colorIdx]);
         colorIdx = (colorIdx + 1) >= nColors ? 0 : colorIdx + 1;
         ++pfoIdx;
     }
 
     PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
 }

void lar_content::HierarchyMonitoringAlgorithm::VisualizeUnmatchedReco ( const LArHierarchyHelper::RecoHierarchy::Node * pNode ) const

private

Visualize the unmatched reco node.

Parameters

pNode The unmatched reco node

Definition at line 350 of file HierarchyMonitoringAlgorithm.cc.

 {
     const int gray{14};
 
     CaloHitList uHits, vHits, wHits;
     this->FillHitLists(pNode->GetCaloHits(), uHits, vHits, wHits);
     const int pdg{pNode->GetParticleId()};
     const std::string key{pdg == MU_MINUS ? "T" : pdg == E_MINUS ? "S" : "?"};
     const std::string suffix{"unmatched_reco"};
     this->Visualize(uHits, "u_" + suffix, gray);
     this->Visualize(vHits, "v_" + suffix, gray);
     this->Visualize(wHits, "w_" + suffix, gray);
 }