#include "EventValidationAlgorithm.h"

Inheritance diagram for lar_content::EventValidationAlgorithm:

Classes
class	ValidationInfo
	ValidationInfo class. More...

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

	~EventValidationAlgorithm ()
	Destructor. More...

Private Types
typedef std::unordered_map< const pandora::ParticleFlowObject *, unsigned int >	PfoToIdMap

typedef std::vector< pandora::HitType >	HitTypeVector

Private Member Functions
pandora::StatusCode	Run ()

void	FillValidationInfo (const pandora::MCParticleList const pMCParticleList, const pandora::CaloHitList const pCaloHitList, const pandora::PfoList *const pPfoList, ValidationInfo &validationInfo) const
	Fill the validation info containers. More...

void	PrintAllMatches (const ValidationInfo &validationInfo) const
	Print all/raw matching information to screen. More...

void	PrintInterpretedMatches (const ValidationInfo &validationInfo) const
	Print interpreted matching information to screen. More...

void	WriteInterpretedMatches (const ValidationInfo &validationInfo) const
	Write interpreted matching information to tree. More...

void	ProcessOutput (const ValidationInfo &validationInfo, const bool useInterpretedMatching, const bool printToScreen, const bool fillTree) const
	Print matching information in a provided validation info object, and write information to tree if configured to do so. More...

void	InterpretMatching (const ValidationInfo &validationInfo, LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const
	Apply an interpretative matching procedure to the comprehensive matches in the provided validation info object. More...

bool	GetStrongestPfoMatch (const ValidationInfo &validationInfo, const pandora::MCParticleVector &mcPrimaryVector, pandora::PfoSet &usedPfos, LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const
	Get the strongest pfo match (most matched hits) between an available mc primary and an available pfo. More...

void	GetRemainingPfoMatches (const ValidationInfo &validationInfo, const pandora::MCParticleVector &mcPrimaryVector, const pandora::PfoSet &usedPfos, LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const
	Get the best matches for any pfos left-over after the strong matching procedure. More...

bool	IsGoodMatch (const pandora::CaloHitList &trueHits, const pandora::CaloHitList &recoHits, const pandora::CaloHitList &sharedHits) const
	Whether a provided mc primary and pfo are deemed to be a good match. More...

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

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

std::string	m_mcParticleListName
	Name of input MC particle list. More...

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

bool	m_useTrueNeutrinosOnly
	Whether to consider only mc particles that were neutrino induced. More...

bool	m_testBeamMode
	Whether pandora is reconstructing test beam particles. More...

bool	m_selectInputHits
	Whether to use only hits passing mc-based quality (is "reconstructable") checks. More...

float	m_minHitSharingFraction
	Minimum fraction of energy deposited by selected primary in a single "good" hit. More...

float	m_maxPhotonPropagation
	Maximum distance travelled by photon, downstream of a track, in mc particle hierarchy. More...

bool	m_printAllToScreen
	Whether to print all/raw matching details to screen. More...

bool	m_printMatchingToScreen
	Whether to print matching output to screen. More...

bool	m_writeToTree
	Whether to write all/raw matching details to tree. More...

bool	m_useSmallPrimaries
	Whether to consider matches to mc primaries with fewer than m_matchingMinPrimaryHits. More...

unsigned int	m_matchingMinSharedHits
	The minimum number of shared hits used in matching scheme. More...

float	m_matchingMinCompleteness
	The minimum particle completeness to declare a match. More...

float	m_matchingMinPurity
	The minimum particle purity to declare a match. More...

std::string	m_treeName
	Name of output tree. More...

std::string	m_fileName
	Name of output file. More...

int	m_fileIdentifier
	The input file identifier. More...

int	m_eventNumber
	The event number. More...

Detailed Description

EventValidationAlgorithm class.

Definition at line 27 of file EventValidationAlgorithm.h.

Member Typedef Documentation

typedef std::vector<pandora::HitType> lar_content::EventValidationAlgorithm::HitTypeVector

private

Definition at line 216 of file EventValidationAlgorithm.h.

typedef std::unordered_map<const pandora::ParticleFlowObject*, unsigned int> lar_content::EventValidationAlgorithm::PfoToIdMap

private

Definition at line 138 of file EventValidationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::EventValidationAlgorithm::EventValidationAlgorithm ( )

Default constructor.

Definition at line 24 of file EventValidationAlgorithm.cc.

                                                    :
     m_useTrueNeutrinosOnly(false),
     m_testBeamMode(false),
     m_selectInputHits(true),
     m_minHitSharingFraction(0.9f),
     m_maxPhotonPropagation(2.5f),
     m_printAllToScreen(false),
     m_printMatchingToScreen(true),
     m_writeToTree(false),
     m_useSmallPrimaries(true),
     m_matchingMinSharedHits(5),
     m_matchingMinCompleteness(0.1f),
     m_matchingMinPurity(0.5f),
     m_fileIdentifier(0),
     m_eventNumber(0)
 {
 }

lar_content::EventValidationAlgorithm::~EventValidationAlgorithm ( )

Destructor.

Definition at line 44 of file EventValidationAlgorithm.cc.

References m_fileName, m_treeName, and m_writeToTree.

 {
     if (m_writeToTree)
     {
         try
         {
             PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_treeName.c_str(), m_fileName.c_str(), "UPDATE"));
         }
         catch (const StatusCodeException &)
         {
             std::cout << "EventValidationAlgorithm: Unable to write tree " << m_treeName << " to file " << m_fileName << std::endl;
         }
     }
 }

Member Function Documentation

void lar_content::EventValidationAlgorithm::FillValidationInfo	(	const pandora::MCParticleList *const	pMCParticleList,
		const pandora::CaloHitList *const	pCaloHitList,
		const pandora::PfoList *const	pPfoList,
		ValidationInfo &	validationInfo
	)		const

private

Fill the validation info containers.

Parameters

pMCParticleList	the address of the mc particle list
pCaloHitList	the address of the calo hit list
pPfoList	the address of the pfo list
validationInfo	to receive the validation info

Definition at line 91 of file EventValidationAlgorithm.cc.

Referenced by Run().

 {
     if (pMCParticleList && pCaloHitList)
     {
         LArMCParticleHelper::PrimaryParameters parameters;
 
         parameters.m_selectInputHits = m_selectInputHits;
         parameters.m_minHitSharingFraction = m_minHitSharingFraction;
         parameters.m_maxPhotonPropagation = m_maxPhotonPropagation;
         LArMCParticleHelper::MCContributionMap targetMCParticleToHitsMap;
         LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsBeamNeutrinoFinalState, targetMCParticleToHitsMap);
         if (!m_useTrueNeutrinosOnly) LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsBeamParticle, targetMCParticleToHitsMap);
         if (!m_useTrueNeutrinosOnly) LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsCosmicRay, targetMCParticleToHitsMap);
 
         parameters.m_minPrimaryGoodHits = 0;
         parameters.m_minHitsForGoodView = 0;
         parameters.m_minHitSharingFraction = 0.f;
         LArMCParticleHelper::MCContributionMap allMCParticleToHitsMap;
         LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsBeamNeutrinoFinalState, allMCParticleToHitsMap);
         if (!m_useTrueNeutrinosOnly) LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsBeamParticle, allMCParticleToHitsMap);
         if (!m_useTrueNeutrinosOnly) LArMCParticleHelper::SelectReconstructableMCParticles(pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsCosmicRay, allMCParticleToHitsMap);
 
         validationInfo.SetTargetMCParticleToHitsMap(targetMCParticleToHitsMap);
         validationInfo.SetAllMCParticleToHitsMap(allMCParticleToHitsMap);
     }
 
     if (pPfoList)
     {
         PfoList allConnectedPfos;
         LArPfoHelper::GetAllConnectedPfos(*pPfoList, allConnectedPfos);
 
         PfoList finalStatePfos;
         for (const ParticleFlowObject *const pPfo : allConnectedPfos)
         {
             if ((!m_testBeamMode && LArPfoHelper::IsFinalState(pPfo)) || (m_testBeamMode && pPfo->GetParentPfoList().empty()))
                 finalStatePfos.push_back(pPfo);
         }
 
         LArMCParticleHelper::PfoContributionMap pfoToHitsMap;
         LArMCParticleHelper::GetPfoToReconstructable2DHitsMap(finalStatePfos, validationInfo.GetAllMCParticleToHitsMap(), pfoToHitsMap);
         validationInfo.SetPfoToHitsMap(pfoToHitsMap);
     }
 
     LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCHitSharingMap;
     LArMCParticleHelper::MCParticleToPfoHitSharingMap mcToPfoHitSharingMap;
     LArMCParticleHelper::GetPfoMCParticleHitSharingMaps(validationInfo.GetPfoToHitsMap(), {validationInfo.GetAllMCParticleToHitsMap()}, pfoToMCHitSharingMap, mcToPfoHitSharingMap);
     validationInfo.SetMCToPfoHitSharingMap(mcToPfoHitSharingMap);
 
     LArMCParticleHelper::MCParticleToPfoHitSharingMap interpretedMCToPfoHitSharingMap;
     this->InterpretMatching(validationInfo, interpretedMCToPfoHitSharingMap);
     validationInfo.SetInterpretedMCToPfoHitSharingMap(interpretedMCToPfoHitSharingMap);
 }

void lar_content::EventValidationAlgorithm::GetRemainingPfoMatches	(	const ValidationInfo &	validationInfo,
		const pandora::MCParticleVector &	mcPrimaryVector,
		const pandora::PfoSet &	usedPfos,
		LArMCParticleHelper::MCParticleToPfoHitSharingMap &	interpretedMCToPfoHitSharingMap
	)		const

private

Get the best matches for any pfos left-over after the strong matching procedure.

Parameters

validationInfo	the validation info
mcPrimaryVector	the mc primary vector
usedPfos	the set of previously used pfos
interpretedMCToPfoHitSharingMap	the output, interpreted mc particle to pfo hit sharing map

Definition at line 565 of file EventValidationAlgorithm.cc.

References lar_content::EventValidationAlgorithm::ValidationInfo::GetMCToPfoHitSharingMap(), lar_content::EventValidationAlgorithm::ValidationInfo::GetTargetMCParticleToHitsMap(), and m_useSmallPrimaries.

Referenced by InterpretMatching().

 {
     LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCParticleHitSharingMap;
 
     for (const MCParticle *const pMCPrimary : mcPrimaryVector)
     {
         if (!m_useSmallPrimaries && !validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary))
             continue;
 
         if (!validationInfo.GetMCToPfoHitSharingMap().count(pMCPrimary))
             continue;
 
         for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : validationInfo.GetMCToPfoHitSharingMap().at(pMCPrimary))
         {
             if (usedPfos.count(pfoToSharedHits.first))
                 continue;
 
             const LArMCParticleHelper::MCParticleCaloHitListPair mcParticleToHits(pMCPrimary, pfoToSharedHits.second);
             LArMCParticleHelper::PfoToMCParticleHitSharingMap::iterator iter(pfoToMCParticleHitSharingMap.find(pfoToSharedHits.first));
 
             if (pfoToMCParticleHitSharingMap.end() == iter)
             {
                 pfoToMCParticleHitSharingMap[pfoToSharedHits.first].push_back(mcParticleToHits);
             }
             else
             {
                 if (1 != iter->second.size())
                     throw StatusCodeException(STATUS_CODE_FAILURE);
 
                 LArMCParticleHelper::MCParticleCaloHitListPair &originalMCParticleToHits(iter->second.at(0));
 
                 if (mcParticleToHits.second.size() > originalMCParticleToHits.second.size())
                     originalMCParticleToHits = mcParticleToHits;
             }
         }
     }
 
     for (const auto &mapEntry : pfoToMCParticleHitSharingMap)
     {
         const LArMCParticleHelper::MCParticleCaloHitListPair &mcParticleToHits(mapEntry.second.at(0));
         interpretedMCToPfoHitSharingMap[mcParticleToHits.first].push_back(LArMCParticleHelper::PfoCaloHitListPair(mapEntry.first, mcParticleToHits.second));
     }
 }

bool lar_content::EventValidationAlgorithm::GetStrongestPfoMatch	(	const ValidationInfo &	validationInfo,
		const pandora::MCParticleVector &	mcPrimaryVector,
		pandora::PfoSet &	usedPfos,
		LArMCParticleHelper::MCParticleToPfoHitSharingMap &	interpretedMCToPfoHitSharingMap
	)		const

private

Get the strongest pfo match (most matched hits) between an available mc primary and an available pfo.

Parameters

validationInfo	the validation info
mcPrimaryVector	the mc primary vector
usedPfos	the set of previously used pfos
interpretedMCToPfoHitSharingMap	the output, interpreted mc particle to pfo hit sharing map

Returns: whether a strong match was identified

Definition at line 522 of file EventValidationAlgorithm.cc.

References lar_content::EventValidationAlgorithm::ValidationInfo::GetAllMCParticleToHitsMap(), lar_content::EventValidationAlgorithm::ValidationInfo::GetMCToPfoHitSharingMap(), lar_content::EventValidationAlgorithm::ValidationInfo::GetPfoToHitsMap(), lar_content::EventValidationAlgorithm::ValidationInfo::GetTargetMCParticleToHitsMap(), IsGoodMatch(), and m_useSmallPrimaries.

Referenced by InterpretMatching().

 {
     const MCParticle *pBestMCParticle(nullptr);
     LArMCParticleHelper::PfoCaloHitListPair bestPfoHitPair(nullptr, CaloHitList());
 
     for (const MCParticle *const pMCPrimary : mcPrimaryVector)
     {
         if (interpretedMCToPfoHitSharingMap.count(pMCPrimary))
             continue;
 
         if (!m_useSmallPrimaries && !validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary))
             continue;
 
         if (!validationInfo.GetMCToPfoHitSharingMap().count(pMCPrimary))
             continue;
 
         for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : validationInfo.GetMCToPfoHitSharingMap().at(pMCPrimary))
         {
             if (usedPfos.count(pfoToSharedHits.first))
                 continue;
 
             if (!this->IsGoodMatch(validationInfo.GetAllMCParticleToHitsMap().at(pMCPrimary), validationInfo.GetPfoToHitsMap().at(pfoToSharedHits.first), pfoToSharedHits.second))
                 continue;
 
             if (pfoToSharedHits.second.size() > bestPfoHitPair.second.size())
             {
                 pBestMCParticle = pMCPrimary;
                 bestPfoHitPair = pfoToSharedHits;
             }
         }
     }
 
     if (!pBestMCParticle || !bestPfoHitPair.first)
         return false;
 
     interpretedMCToPfoHitSharingMap[pBestMCParticle].push_back(bestPfoHitPair);
     usedPfos.insert(bestPfoHitPair.first);
     return true;
 }

void lar_content::EventValidationAlgorithm::InterpretMatching	(	const ValidationInfo &	validationInfo,
		LArMCParticleHelper::MCParticleToPfoHitSharingMap &	interpretedMCToPfoHitSharingMap
	)		const

private

Apply an interpretative matching procedure to the comprehensive matches in the provided validation info object.

Parameters

validationInfo	the validation info
interpretedMCToPfoHitSharingMap	the output, interpreted mc particle to pfo hit sharing map

Definition at line 502 of file EventValidationAlgorithm.cc.

References lar_content::EventValidationAlgorithm::ValidationInfo::GetAllMCParticleToHitsMap(), lar_content::LArMonitoringHelper::GetOrderedMCParticleVector(), GetRemainingPfoMatches(), GetStrongestPfoMatch(), and lar_content::LArPfoHelper::SortByNHits().

Referenced by FillValidationInfo().

 {
     MCParticleVector mcPrimaryVector;
     LArMonitoringHelper::GetOrderedMCParticleVector({validationInfo.GetAllMCParticleToHitsMap()}, mcPrimaryVector);
 
     PfoSet usedPfos;
     while (this->GetStrongestPfoMatch(validationInfo, mcPrimaryVector, usedPfos, interpretedMCToPfoHitSharingMap)) {}
     this->GetRemainingPfoMatches(validationInfo, mcPrimaryVector, usedPfos, interpretedMCToPfoHitSharingMap);
 
     // Ensure all primaries have an entry, and sorting is as desired
     for (const MCParticle *const pMCPrimary : mcPrimaryVector)
     {
         LArMCParticleHelper::PfoToSharedHitsVector &pfoHitPairs(interpretedMCToPfoHitSharingMap[pMCPrimary]);
         std::sort(pfoHitPairs.begin(), pfoHitPairs.end(), [] (const LArMCParticleHelper::PfoCaloHitListPair &a, const LArMCParticleHelper::PfoCaloHitListPair &b) -> bool {
             return ((a.second.size() != b.second.size()) ? a.second.size() > b.second.size() : LArPfoHelper::SortByNHits(a.first, b.first)); });
     }
 }

bool lar_content::EventValidationAlgorithm::IsGoodMatch	(	const pandora::CaloHitList &	trueHits,
		const pandora::CaloHitList &	recoHits,
		const pandora::CaloHitList &	sharedHits
	)		const

private

Whether a provided mc primary and pfo are deemed to be a good match.

Parameters

trueHits	the list of true hits
recoHits	the list of reco hits
sharedHits	the list of shared hits

Returns: boolean

Definition at line 612 of file EventValidationAlgorithm.cc.

References f, m_matchingMinCompleteness, m_matchingMinPurity, and m_matchingMinSharedHits.

Referenced by GetStrongestPfoMatch(), and ProcessOutput().

 {
     const float purity((recoHits.size() > 0) ? static_cast<float>(sharedHits.size()) / static_cast<float>(recoHits.size()) : 0.f);
     const float completeness((trueHits.size() > 0) ? static_cast<float>(sharedHits.size()) / static_cast<float>(trueHits.size()) : 0.f);
 
     return ((sharedHits.size() >= m_matchingMinSharedHits) && (purity >= m_matchingMinPurity) && (completeness >= m_matchingMinCompleteness));
 }

void lar_content::EventValidationAlgorithm::PrintAllMatches ( const ValidationInfo & validationInfo ) const

inlineprivate

Print all/raw matching information to screen.

Parameters

validationInfo the validation info

Definition at line 320 of file EventValidationAlgorithm.h.

References ProcessOutput().

Referenced by Run().

 {
     return this->ProcessOutput(validationInfo, false, true, false);
 }

void lar_content::EventValidationAlgorithm::PrintInterpretedMatches ( const ValidationInfo & validationInfo ) const

inlineprivate

Print interpreted matching information to screen.

Parameters

validationInfo the validation info

Definition at line 327 of file EventValidationAlgorithm.h.

References ProcessOutput().

Referenced by Run().

 {
     return this->ProcessOutput(validationInfo, true, true, false);
 }

void lar_content::EventValidationAlgorithm::ProcessOutput	(	const ValidationInfo &	validationInfo,
		const bool	useInterpretedMatching,
		const bool	printToScreen,
		const bool	fillTree
	)		const

private

Print matching information in a provided validation info object, and write information to tree if configured to do so.

Parameters

validationInfo	the validation info
useInterpretedMatching	whether to use the interpreted (rather than raw) matching information
printToScreen	whether to print the information to screen
fillTree	whether to write the information to tree

Definition at line 147 of file EventValidationAlgorithm.cc.

Referenced by PrintAllMatches(), PrintInterpretedMatches(), and WriteInterpretedMatches().

 {
     if (printToScreen && useInterpretedMatching) std::cout << "---INTERPRETED-MATCHING-OUTPUT------------------------------------------------------------------" << std::endl;
     else if (printToScreen) std::cout << "---RAW-MATCHING-OUTPUT--------------------------------------------------------------------------" << std::endl;
 
     const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap(useInterpretedMatching ?
         validationInfo.GetInterpretedMCToPfoHitSharingMap() : validationInfo.GetMCToPfoHitSharingMap());
 
     MCParticleVector mcPrimaryVector;
     LArMonitoringHelper::GetOrderedMCParticleVector({validationInfo.GetTargetMCParticleToHitsMap()}, mcPrimaryVector);
 
     int nNeutrinoPrimaries(0);
     for (const MCParticle *const pMCPrimary : mcPrimaryVector)
         if (LArMCParticleHelper::IsBeamNeutrinoFinalState(pMCPrimary) && validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary)) ++nNeutrinoPrimaries;
 
     PfoVector primaryPfoVector;
     LArMonitoringHelper::GetOrderedPfoVector(validationInfo.GetPfoToHitsMap(), primaryPfoVector);
 
     int pfoIndex(0), neutrinoPfoIndex(0);
     PfoToIdMap pfoToIdMap, neutrinoPfoToIdMap;
     for (const Pfo *const pPrimaryPfo : primaryPfoVector)
     {
         pfoToIdMap.insert(PfoToIdMap::value_type(pPrimaryPfo, ++pfoIndex));
         const Pfo *const pRecoNeutrino(LArPfoHelper::IsNeutrinoFinalState(pPrimaryPfo) ? LArPfoHelper::GetParentNeutrino(pPrimaryPfo) : nullptr);
 
         if (pRecoNeutrino && !neutrinoPfoToIdMap.count(pRecoNeutrino))
             neutrinoPfoToIdMap.insert(PfoToIdMap::value_type(pRecoNeutrino, ++neutrinoPfoIndex));
     }
 
     PfoSet recoNeutrinos;
     MCParticleList associatedMCPrimaries;
 
     int nCorrectNu(0), nTotalNu(0), nCorrectTB(0), nTotalTB(0), nCorrectCR(0), nTotalCR(0), nFakeNu(0), nFakeCR(0), nSplitNu(0), nSplitCR(0), nLost(0);
     int mcPrimaryIndex(0), nTargetMatches(0), nTargetNuMatches(0), nTargetCRMatches(0), nTargetGoodNuMatches(0), nTargetNuSplits(0), nTargetNuLosses(0);
     IntVector mcPrimaryId, mcPrimaryPdg, nMCHitsTotal, nMCHitsU, nMCHitsV, nMCHitsW;
     FloatVector mcPrimaryE, mcPrimaryPX, mcPrimaryPY, mcPrimaryPZ;
     FloatVector mcPrimaryVtxX, mcPrimaryVtxY, mcPrimaryVtxZ, mcPrimaryEndX, mcPrimaryEndY, mcPrimaryEndZ;
     IntVector nPrimaryMatchedPfos, nPrimaryMatchedNuPfos, nPrimaryMatchedCRPfos;
     IntVector bestMatchPfoId, bestMatchPfoPdg, bestMatchPfoIsRecoNu, bestMatchPfoRecoNuId, bestMatchPfoIsTestBeam;
     IntVector bestMatchPfoNHitsTotal, bestMatchPfoNHitsU, bestMatchPfoNHitsV, bestMatchPfoNHitsW;
     IntVector bestMatchPfoNSharedHitsTotal, bestMatchPfoNSharedHitsU, bestMatchPfoNSharedHitsV, bestMatchPfoNSharedHitsW;
 
     std::stringstream targetSS;
 
     for (const MCParticle *const pMCPrimary : mcPrimaryVector)
     {
         const bool hasMatch(mcToPfoHitSharingMap.count(pMCPrimary) && !mcToPfoHitSharingMap.at(pMCPrimary).empty());
         const bool isTargetPrimary(validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary));
 
         if (!hasMatch && !isTargetPrimary)
             continue;
 
         associatedMCPrimaries.push_back(pMCPrimary);
         const int nTargetPrimaries(associatedMCPrimaries.size());
         const bool isLastNeutrinoPrimary(++mcPrimaryIndex == nNeutrinoPrimaries);
         const CaloHitList &mcPrimaryHitList(validationInfo.GetAllMCParticleToHitsMap().at(pMCPrimary));
 
         const int mcNuanceCode(LArMCParticleHelper::GetNuanceCode(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)));
         const int isBeamNeutrinoFinalState(LArMCParticleHelper::IsBeamNeutrinoFinalState(pMCPrimary));
         const int isBeamParticle(LArMCParticleHelper::IsBeamParticle(pMCPrimary));
         const int isCosmicRay(LArMCParticleHelper::IsCosmicRay(pMCPrimary));
 #ifdef MONITORING
         const CartesianVector &targetVertex(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)->GetVertex());
         const float targetVertexX(targetVertex.GetX()), targetVertexY(targetVertex.GetY()), targetVertexZ(targetVertex.GetZ());
 #endif
         targetSS << (!isTargetPrimary ? "(Non target) " : "")
                  << "PrimaryId " << mcPrimaryIndex
                  << ", Nu " << isBeamNeutrinoFinalState
                  << ", TB " << isBeamParticle
                  << ", CR " << isCosmicRay
                  << ", MCPDG " << pMCPrimary->GetParticleId()
                  << ", Energy " << pMCPrimary->GetEnergy()
                  << ", Dist. " << (pMCPrimary->GetEndpoint() - pMCPrimary->GetVertex()).GetMagnitude()
                  << ", nMCHits " << mcPrimaryHitList.size()
                  << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList)
                  << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList)
                  << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList) << ")" << std::endl;
 
         mcPrimaryId.push_back(mcPrimaryIndex);
         mcPrimaryPdg.push_back(pMCPrimary->GetParticleId());
         mcPrimaryE.push_back(pMCPrimary->GetEnergy());
         mcPrimaryPX.push_back(pMCPrimary->GetMomentum().GetX());
         mcPrimaryPY.push_back(pMCPrimary->GetMomentum().GetY());
         mcPrimaryPZ.push_back(pMCPrimary->GetMomentum().GetZ());
         mcPrimaryVtxX.push_back(pMCPrimary->GetVertex().GetX());
         mcPrimaryVtxY.push_back(pMCPrimary->GetVertex().GetY());
         mcPrimaryVtxZ.push_back(pMCPrimary->GetVertex().GetZ());
         mcPrimaryEndX.push_back(pMCPrimary->GetEndpoint().GetX());
         mcPrimaryEndY.push_back(pMCPrimary->GetEndpoint().GetY());
         mcPrimaryEndZ.push_back(pMCPrimary->GetEndpoint().GetZ());
         nMCHitsTotal.push_back(mcPrimaryHitList.size());
         nMCHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList));
         nMCHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList));
         nMCHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList));
 
         int matchIndex(0), nPrimaryMatches(0), nPrimaryNuMatches(0), nPrimaryCRMatches(0), nPrimaryGoodNuMatches(0), nPrimaryNuSplits(0);
 #ifdef MONITORING
         float recoVertexX(std::numeric_limits<float>::max()), recoVertexY(std::numeric_limits<float>::max()), recoVertexZ(std::numeric_limits<float>::max());
 #endif
         for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : mcToPfoHitSharingMap.at(pMCPrimary))
         {
             const CaloHitList &sharedHitList(pfoToSharedHits.second);
             const CaloHitList &pfoHitList(validationInfo.GetPfoToHitsMap().at(pfoToSharedHits.first));
 
             const bool isRecoNeutrinoFinalState(LArPfoHelper::IsNeutrinoFinalState(pfoToSharedHits.first));
             const bool isRecoTestBeam(LArPfoHelper::IsTestBeam(pfoToSharedHits.first));
             const bool isGoodMatch(this->IsGoodMatch(mcPrimaryHitList, pfoHitList, sharedHitList));
 
             const int pfoId(pfoToIdMap.at(pfoToSharedHits.first));
             const int recoNuId(isRecoNeutrinoFinalState ? neutrinoPfoToIdMap.at(LArPfoHelper::GetParentNeutrino(pfoToSharedHits.first)) : -1);
 
             if (0 == matchIndex++)
             {
                 bestMatchPfoId.push_back(pfoId);
                 bestMatchPfoPdg.push_back(pfoToSharedHits.first->GetParticleId());
                 bestMatchPfoIsRecoNu.push_back(isRecoNeutrinoFinalState ? 1 : 0);
                 bestMatchPfoRecoNuId.push_back(recoNuId);
                 bestMatchPfoIsTestBeam.push_back(isRecoTestBeam ? 1 : 0);
                 bestMatchPfoNHitsTotal.push_back(pfoHitList.size());
                 bestMatchPfoNHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList));
                 bestMatchPfoNHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList));
                 bestMatchPfoNHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList));
                 bestMatchPfoNSharedHitsTotal.push_back(sharedHitList.size());
                 bestMatchPfoNSharedHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList));
                 bestMatchPfoNSharedHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList));
                 bestMatchPfoNSharedHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList));
 #ifdef MONITORING
                 try
                 {
                     const Vertex *const pRecoVertex(LArPfoHelper::GetVertex(isRecoNeutrinoFinalState ? LArPfoHelper::GetParentNeutrino(pfoToSharedHits.first) : pfoToSharedHits.first));
                     recoVertexX = pRecoVertex->GetPosition().GetX();
                     recoVertexY = pRecoVertex->GetPosition().GetY();
                     recoVertexZ = pRecoVertex->GetPosition().GetZ();
                 }
                 catch (const StatusCodeException &) {}
 #endif
             }
 
             if (isGoodMatch) ++nPrimaryMatches;
 
             if (isRecoNeutrinoFinalState)
             {
                 const Pfo *const pRecoNeutrino(LArPfoHelper::GetParentNeutrino(pfoToSharedHits.first));
                 const bool isSplitRecoNeutrino(!recoNeutrinos.empty() && !recoNeutrinos.count(pRecoNeutrino));
                 if (!isSplitRecoNeutrino && isGoodMatch) ++nPrimaryGoodNuMatches;
                 if (isSplitRecoNeutrino && isBeamNeutrinoFinalState && isGoodMatch) ++nPrimaryNuSplits;
                 recoNeutrinos.insert(pRecoNeutrino);
             }
 
             if (!m_testBeamMode)
             {
                 if (isRecoNeutrinoFinalState && isGoodMatch) ++nPrimaryNuMatches;
                 if (!isRecoNeutrinoFinalState && isGoodMatch) ++nPrimaryCRMatches;
             }
             else
             {
                 bool isTestBeam(LArPfoHelper::IsTestBeam(pfoToSharedHits.first));
                 if (isTestBeam && isGoodMatch) ++nPrimaryNuMatches;
                 if (!isTestBeam && isGoodMatch) ++nPrimaryCRMatches;
             }
 
             targetSS << "-" << (!isGoodMatch ? "(Below threshold) " : "")
                      << "MatchedPfoId " << pfoId
                      << ", Nu " << isRecoNeutrinoFinalState;
             if (isRecoNeutrinoFinalState) targetSS << " [NuId: " << recoNuId << "]";
             targetSS << ", TB " << isRecoTestBeam
                      << ", CR " << (!isRecoNeutrinoFinalState && !isRecoTestBeam)
                      << ", PDG " << pfoToSharedHits.first->GetParticleId()
                      << ", nMatchedHits " << sharedHitList.size()
                      << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList)
                      << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList)
                      << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList) << ")"
                      << ", nPfoHits " << pfoHitList.size()
                      << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList)
                      << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList)
                      << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList) << ")" << std::endl;
         }
 
         if (mcToPfoHitSharingMap.at(pMCPrimary).empty())
         {
             targetSS << "-No matched Pfo" << std::endl;
             bestMatchPfoId.push_back(-1); bestMatchPfoPdg.push_back(0); bestMatchPfoIsRecoNu.push_back(0); bestMatchPfoRecoNuId.push_back(-1); bestMatchPfoIsTestBeam.push_back(0);
             bestMatchPfoNHitsTotal.push_back(0); bestMatchPfoNHitsU.push_back(0); bestMatchPfoNHitsV.push_back(0); bestMatchPfoNHitsW.push_back(0);
             bestMatchPfoNSharedHitsTotal.push_back(0); bestMatchPfoNSharedHitsU.push_back(0); bestMatchPfoNSharedHitsV.push_back(0); bestMatchPfoNSharedHitsW.push_back(0);
         }
 
         nPrimaryMatchedPfos.push_back(nPrimaryMatches);
         nPrimaryMatchedNuPfos.push_back(nPrimaryNuMatches);
         nPrimaryMatchedCRPfos.push_back(nPrimaryCRMatches);
         nTargetMatches += nPrimaryMatches;
         nTargetNuMatches += nPrimaryNuMatches;
         nTargetCRMatches += nPrimaryCRMatches;
         nTargetGoodNuMatches += nPrimaryGoodNuMatches;
         nTargetNuSplits += nPrimaryNuSplits;
         if (0 == nPrimaryMatches) ++nTargetNuLosses;
 
         if (fillTree)
         {
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "fileIdentifier", m_fileIdentifier));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "eventNumber", m_eventNumber - 1));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcNuanceCode", mcNuanceCode));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isNeutrino", isBeamNeutrinoFinalState));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isBeamParticle", isBeamParticle));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCosmicRay", isCosmicRay));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetPrimaries", nTargetPrimaries));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexX", targetVertexX));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexY", targetVertexY));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexZ", targetVertexZ));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexX", recoVertexX));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexY", recoVertexY));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexZ", recoVertexZ));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryId", &mcPrimaryId));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPdg", &mcPrimaryPdg));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryE", &mcPrimaryE));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPX", &mcPrimaryPX));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPY", &mcPrimaryPY));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPZ", &mcPrimaryPZ));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxX", &mcPrimaryVtxX));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxY", &mcPrimaryVtxY));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxZ", &mcPrimaryVtxZ));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndX", &mcPrimaryEndX));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndY", &mcPrimaryEndY));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndZ", &mcPrimaryEndZ));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsTotal", &nMCHitsTotal));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsU", &nMCHitsU));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsV", &nMCHitsV));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsW", &nMCHitsW));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedPfos", &nPrimaryMatchedPfos));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedNuPfos", &nPrimaryMatchedNuPfos));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedCRPfos", &nPrimaryMatchedCRPfos));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoId", &bestMatchPfoId));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoPdg", &bestMatchPfoPdg));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoIsRecoNu", &bestMatchPfoIsRecoNu));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoRecoNuId", &bestMatchPfoRecoNuId));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsTotal", &bestMatchPfoNHitsTotal));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsU", &bestMatchPfoNHitsU));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsV", &bestMatchPfoNHitsV));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsW", &bestMatchPfoNHitsW));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsTotal", &bestMatchPfoNSharedHitsTotal));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsU", &bestMatchPfoNSharedHitsU));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsV", &bestMatchPfoNSharedHitsV));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsW", &bestMatchPfoNSharedHitsW));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetMatches", nTargetMatches));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetNuMatches", nTargetNuMatches));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetCRMatches", nTargetCRMatches));
 
             if (m_testBeamMode)
             {
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoIsTestBeam", &bestMatchPfoIsTestBeam));
             }
 
             if (!m_testBeamMode)
             {
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetGoodNuMatches", nTargetGoodNuMatches));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetNuSplits", nTargetNuSplits));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetNuLosses", nTargetNuLosses));
             }
         }
 
         if (isLastNeutrinoPrimary || isBeamParticle || isCosmicRay)
         {
             const LArInteractionTypeHelper::InteractionType interactionType(LArInteractionTypeHelper::GetInteractionType(associatedMCPrimaries));
 #ifdef MONITORING
             const int interactionTypeInt(static_cast<int>(interactionType));
 #endif
             // ATTN Some redundancy introduced to contributing variables
             const int isCorrectNu(isBeamNeutrinoFinalState && (nTargetGoodNuMatches == nTargetNuMatches) && (nTargetGoodNuMatches == nTargetPrimaries) && (nTargetCRMatches == 0) && (nTargetNuSplits == 0) && (nTargetNuLosses == 0));
             const int isCorrectTB(isBeamParticle && (nTargetNuMatches == 1) && (nTargetCRMatches == 0));
             const int isCorrectCR(isCosmicRay && (nTargetNuMatches == 0) && (nTargetCRMatches == 1));
             const int isFakeNu(isCosmicRay && (nTargetNuMatches > 0));
             const int isFakeCR(!isCosmicRay && (nTargetCRMatches > 0));
             const int isSplitNu(!isCosmicRay && ((nTargetNuMatches > nTargetPrimaries) || (nTargetNuSplits > 0)));
             const int isSplitCR(isCosmicRay && (nTargetCRMatches > 1));
             const int isLost(nTargetMatches == 0);
 
             std::stringstream outcomeSS;
             outcomeSS << LArInteractionTypeHelper::ToString(interactionType) << " (Nuance " << mcNuanceCode << ", Nu " << isBeamNeutrinoFinalState << ", TB " << isBeamParticle << ", CR " << isCosmicRay << ")" << std::endl;
 
             if (isLastNeutrinoPrimary) ++nTotalNu;
             if (isBeamParticle) ++nTotalTB;
             if (isCosmicRay) ++nTotalCR;
             if (isCorrectNu) ++nCorrectNu;
             if (isCorrectTB) ++nCorrectTB;
             if (isCorrectCR) ++nCorrectCR;
             if (isFakeNu) ++nFakeNu;
             if (isFakeCR) ++nFakeCR;
             if (isSplitNu) ++nSplitNu;
             if (isSplitCR) ++nSplitCR;
             if (isLost) ++nLost;
 
             if (isCorrectNu) outcomeSS << "IsCorrectNu ";
             if (isCorrectTB) outcomeSS << "IsCorrectTB ";
             if (isCorrectCR) outcomeSS << "IsCorrectCR ";
             if (isFakeNu) outcomeSS << "IsFakeNu ";
             if (isFakeCR) outcomeSS << "IsFakeCR ";
             if (isSplitNu) outcomeSS << "isSplitNu ";
             if (isSplitCR) outcomeSS << "IsSplitCR ";
             if (isLost) outcomeSS << "IsLost ";
             if (nTargetNuMatches > 0) outcomeSS << "(NNuMatches: " << nTargetNuMatches << ") ";
             if (nTargetNuLosses > 0) outcomeSS << "(NNuLosses: " << nTargetNuLosses << ") ";
             if (nTargetNuSplits > 0) outcomeSS << "(NNuSplits: " << nTargetNuSplits << ") ";
             if (nTargetCRMatches > 0) outcomeSS << "(NCRMatches: " << nTargetCRMatches << ") ";
             if (printToScreen) std::cout << outcomeSS.str() << std::endl << targetSS.str() << std::endl;
 
             if (fillTree)
             {
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "interactionType", interactionTypeInt));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectNu", isCorrectNu));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectTB", isCorrectTB));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectCR", isCorrectCR));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeNu", isFakeNu));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeCR", isFakeCR));
                 if (!m_testBeamMode)
                 {
                     PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitNu", isSplitNu));
                 }
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitCR", isSplitCR));
                 PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isLost", isLost));
                 PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treeName.c_str()));
             }
 
             targetSS.str(std::string()); targetSS.clear();
             recoNeutrinos.clear(); associatedMCPrimaries.clear();
             nTargetMatches = 0; nTargetNuMatches = 0; nTargetCRMatches = 0; nTargetGoodNuMatches = 0; nTargetNuSplits = 0; nTargetNuLosses = 0;
             mcPrimaryId.clear(); mcPrimaryPdg.clear(); nMCHitsTotal.clear(); nMCHitsU.clear(); nMCHitsV.clear(); nMCHitsW.clear();
             mcPrimaryE.clear(); mcPrimaryPX.clear(); mcPrimaryPY.clear(); mcPrimaryPZ.clear();
             mcPrimaryVtxX.clear(); mcPrimaryVtxY.clear(); mcPrimaryVtxZ.clear(); mcPrimaryEndX.clear(); mcPrimaryEndY.clear(); mcPrimaryEndZ.clear();
             nPrimaryMatchedPfos.clear(); nPrimaryMatchedNuPfos.clear(); nPrimaryMatchedCRPfos.clear();
             bestMatchPfoId.clear(); bestMatchPfoPdg.clear(); bestMatchPfoIsRecoNu.clear(); bestMatchPfoRecoNuId.clear(); bestMatchPfoIsTestBeam.clear();
             bestMatchPfoNHitsTotal.clear(); bestMatchPfoNHitsU.clear(); bestMatchPfoNHitsV.clear(); bestMatchPfoNHitsW.clear();
             bestMatchPfoNSharedHitsTotal.clear(); bestMatchPfoNSharedHitsU.clear(); bestMatchPfoNSharedHitsV.clear(); bestMatchPfoNSharedHitsW.clear();
         }
     }
 
     if (useInterpretedMatching)
     {
         std::stringstream summarySS;
         summarySS << "---SUMMARY--------------------------------------------------------------------------------------" << std::endl;
         if (nTotalNu > 0) summarySS << "#CorrectNu: " << nCorrectNu << "/" << nTotalNu << ", Fraction: " << (nTotalNu > 0 ? static_cast<float>(nCorrectNu) / static_cast<float>(nTotalNu) : 0.f) << std::endl;
         if (nTotalTB > 0) summarySS << "#CorrectTB: " << nCorrectTB << "/" << nTotalTB << ", Fraction: " << (nTotalTB > 0 ? static_cast<float>(nCorrectTB) / static_cast<float>(nTotalTB) : 0.f) << std::endl;
         if (nTotalCR > 0) summarySS << "#CorrectCR: " << nCorrectCR << "/" << nTotalCR << ", Fraction: " << (nTotalCR > 0 ? static_cast<float>(nCorrectCR) / static_cast<float>(nTotalCR) : 0.f) << std::endl;
         if (nFakeNu > 0) summarySS << "#FakeNu: " << nFakeNu << " ";
         if (nFakeCR > 0) summarySS << "#FakeCR: " << nFakeCR << " ";
         if (nSplitNu > 0) summarySS << "#SplitNu: " << nSplitNu << " ";
         if (nSplitCR > 0) summarySS << "#SplitCR: " << nSplitCR << " ";
         if (nLost > 0) summarySS << "#Lost: " << nLost << " ";
         if (nFakeNu || nFakeCR || nSplitNu || nSplitCR || nLost) summarySS << std::endl;
         if (printToScreen) std::cout << summarySS.str();
     }
 
     if (printToScreen) std::cout << "------------------------------------------------------------------------------------------------" << std::endl << std::endl;
 }

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

private

Definition at line 622 of file EventValidationAlgorithm.cc.

References m_caloHitListName, m_fileIdentifier, m_fileName, m_matchingMinCompleteness, m_matchingMinPurity, m_matchingMinSharedHits, m_maxPhotonPropagation, m_mcParticleListName, m_minHitSharingFraction, m_pfoListName, m_printAllToScreen, m_printMatchingToScreen, m_selectInputHits, m_testBeamMode, m_treeName, m_useSmallPrimaries, m_useTrueNeutrinosOnly, and m_writeToTree.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListName", m_caloHitListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MCParticleListName", m_mcParticleListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "PfoListName", m_pfoListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "UseTrueNeutrinosOnly", m_useTrueNeutrinosOnly));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "TestBeamMode", m_testBeamMode));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "SelectInputHits", m_selectInputHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinHitSharingFraction", m_minHitSharingFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MaxPhotonPropagation", m_maxPhotonPropagation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "PrintAllToScreen", m_printAllToScreen));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "PrintMatchingToScreen", m_printMatchingToScreen));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "WriteToTree", m_writeToTree));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "UseSmallPrimaries", m_useSmallPrimaries));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MatchingMinSharedHits", m_matchingMinSharedHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MatchingMinCompleteness", m_matchingMinCompleteness));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MatchingMinPurity", m_matchingMinPurity));
 
     if (m_writeToTree)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputTree", m_treeName));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputFile", m_fileName));
 
         PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
             "FileIdentifier", m_fileIdentifier));
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::EventValidationAlgorithm::Run ( )

private

Definition at line 61 of file EventValidationAlgorithm.cc.

References FillValidationInfo(), m_caloHitListName, m_eventNumber, m_mcParticleListName, m_pfoListName, m_printAllToScreen, m_printMatchingToScreen, m_writeToTree, PrintAllMatches(), PrintInterpretedMatches(), and WriteInterpretedMatches().

 {
     ++m_eventNumber;
 
     const MCParticleList *pMCParticleList = nullptr;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));
 
     const CaloHitList *pCaloHitList = nullptr;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pCaloHitList));
 
     const PfoList *pPfoList = nullptr;
     (void) PandoraContentApi::GetList(*this, m_pfoListName, pPfoList);
 
     ValidationInfo validationInfo;
     this->FillValidationInfo(pMCParticleList, pCaloHitList, pPfoList, validationInfo);
 
     if (m_printAllToScreen)
         this->PrintAllMatches(validationInfo);
 
     if (m_printMatchingToScreen)
         this->PrintInterpretedMatches(validationInfo);
 
     if (m_writeToTree)
         this->WriteInterpretedMatches(validationInfo);
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::EventValidationAlgorithm::WriteInterpretedMatches ( const ValidationInfo & validationInfo ) const

inlineprivate

Write interpreted matching information to tree.

Parameters

validationInfo the validation info

Definition at line 334 of file EventValidationAlgorithm.h.

References ProcessOutput().

Referenced by Run().

 {
     return this->ProcessOutput(validationInfo, true, false, true);
 }

Member Data Documentation

std::string lar_content::EventValidationAlgorithm::m_caloHitListName

private

Name of input calo hit list.

Definition at line 218 of file EventValidationAlgorithm.h.

Referenced by ReadSettings(), and Run().

int lar_content::EventValidationAlgorithm::m_eventNumber

private

The event number.

Definition at line 243 of file EventValidationAlgorithm.h.

Referenced by ProcessOutput(), and Run().

int lar_content::EventValidationAlgorithm::m_fileIdentifier

private

The input file identifier.

Definition at line 242 of file EventValidationAlgorithm.h.

Referenced by ProcessOutput(), and ReadSettings().

std::string lar_content::EventValidationAlgorithm::m_fileName

private

Name of output file.

Definition at line 240 of file EventValidationAlgorithm.h.

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

float lar_content::EventValidationAlgorithm::m_matchingMinCompleteness

private

The minimum particle completeness to declare a match.

Definition at line 236 of file EventValidationAlgorithm.h.

Referenced by IsGoodMatch(), and ReadSettings().

float lar_content::EventValidationAlgorithm::m_matchingMinPurity

private

The minimum particle purity to declare a match.

Definition at line 237 of file EventValidationAlgorithm.h.

Referenced by IsGoodMatch(), and ReadSettings().

unsigned int lar_content::EventValidationAlgorithm::m_matchingMinSharedHits

private

The minimum number of shared hits used in matching scheme.

Definition at line 235 of file EventValidationAlgorithm.h.

Referenced by IsGoodMatch(), and ReadSettings().

float lar_content::EventValidationAlgorithm::m_maxPhotonPropagation

private

Maximum distance travelled by photon, downstream of a track, in mc particle hierarchy.

Definition at line 227 of file EventValidationAlgorithm.h.

Referenced by FillValidationInfo(), and ReadSettings().

std::string lar_content::EventValidationAlgorithm::m_mcParticleListName

private

Name of input MC particle list.

Definition at line 219 of file EventValidationAlgorithm.h.

Referenced by ReadSettings(), and Run().

float lar_content::EventValidationAlgorithm::m_minHitSharingFraction

private

Minimum fraction of energy deposited by selected primary in a single "good" hit.

Definition at line 226 of file EventValidationAlgorithm.h.

Referenced by FillValidationInfo(), and ReadSettings().

std::string lar_content::EventValidationAlgorithm::m_pfoListName

private

Name of input Pfo list.

Definition at line 220 of file EventValidationAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::EventValidationAlgorithm::m_printAllToScreen

private

Whether to print all/raw matching details to screen.

Definition at line 229 of file EventValidationAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::EventValidationAlgorithm::m_printMatchingToScreen

private

Whether to print matching output to screen.

Definition at line 230 of file EventValidationAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::EventValidationAlgorithm::m_selectInputHits

private

Whether to use only hits passing mc-based quality (is "reconstructable") checks.

Definition at line 225 of file EventValidationAlgorithm.h.

Referenced by FillValidationInfo(), and ReadSettings().

bool lar_content::EventValidationAlgorithm::m_testBeamMode

private

Whether pandora is reconstructing test beam particles.

Definition at line 223 of file EventValidationAlgorithm.h.

Referenced by FillValidationInfo(), ProcessOutput(), and ReadSettings().

std::string lar_content::EventValidationAlgorithm::m_treeName

private

Name of output tree.

Definition at line 239 of file EventValidationAlgorithm.h.

Referenced by ProcessOutput(), ReadSettings(), and ~EventValidationAlgorithm().

bool lar_content::EventValidationAlgorithm::m_useSmallPrimaries

private

Whether to consider matches to mc primaries with fewer than m_matchingMinPrimaryHits.

Definition at line 234 of file EventValidationAlgorithm.h.

Referenced by GetRemainingPfoMatches(), GetStrongestPfoMatch(), and ReadSettings().

bool lar_content::EventValidationAlgorithm::m_useTrueNeutrinosOnly

private

Whether to consider only mc particles that were neutrino induced.

Definition at line 222 of file EventValidationAlgorithm.h.

Referenced by FillValidationInfo(), and ReadSettings().

bool lar_content::EventValidationAlgorithm::m_writeToTree

private

Whether to write all/raw matching details to tree.

Definition at line 232 of file EventValidationAlgorithm.h.

Referenced by ReadSettings(), Run(), and ~EventValidationAlgorithm().

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

larpandoracontent/v03_13_02/source/larpandoracontent/LArMonitoring/EventValidationAlgorithm.h
larpandoracontent/v03_13_02/source/larpandoracontent/LArMonitoring/EventValidationAlgorithm.cc

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation