LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | List of all members
lar_content::TestBeamHierarchyEventValidationAlgorithm Class Reference

TestBeamHierarchyEventValidationAlgorithm class. More...

#include "TestBeamHierarchyEventValidationAlgorithm.h"

Inheritance diagram for lar_content::TestBeamHierarchyEventValidationAlgorithm:
lar_content::EventValidationBaseAlgorithm

Public Member Functions

 TestBeamHierarchyEventValidationAlgorithm ()
 Default constructor. More...
 
 ~TestBeamHierarchyEventValidationAlgorithm ()
 Destructor. More...
 

Protected Member Functions

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

Protected Attributes

LArMCParticleHelper::PrimaryParameters m_primaryParameters
 The mc particle primary selection parameters. More...
 
int m_fileIdentifier
 The input file identifier. More...
 
int m_eventNumber
 The event number. More...
 
std::string m_treeName
 Name of output tree. More...
 

Private Types

typedef std::unordered_map< const pandora::ParticleFlowObject *, unsigned int > PfoToIdMap
 
typedef std::vector< pandora::HitType > HitTypeVector
 

Private Member Functions

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 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...
 
pandora::StatusCode ReadSettings (const pandora::TiXmlHandle xmlHandle)
 

Detailed Description

TestBeamHierarchyEventValidationAlgorithm class.

Definition at line 29 of file TestBeamHierarchyEventValidationAlgorithm.h.

Member Typedef Documentation

typedef std::vector<pandora::HitType> lar_content::TestBeamHierarchyEventValidationAlgorithm::HitTypeVector
private

Definition at line 68 of file TestBeamHierarchyEventValidationAlgorithm.h.

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

Definition at line 54 of file TestBeamHierarchyEventValidationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TestBeamHierarchyEventValidationAlgorithm::TestBeamHierarchyEventValidationAlgorithm ( )

Default constructor.

Definition at line 24 of file TestBeamHierarchyEventValidationAlgorithm.cc.

25 {
26 }
lar_content::TestBeamHierarchyEventValidationAlgorithm::~TestBeamHierarchyEventValidationAlgorithm ( )

Destructor.

Definition at line 30 of file TestBeamHierarchyEventValidationAlgorithm.cc.

31 {
32 }

Member Function Documentation

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

Fill the validation info containers.

Parameters
pMCParticleListthe address of the mc particle list
pCaloHitListthe address of the calo hit list
pPfoListthe address of the pfo list
validationInfoto receive the validation info

Implements lar_content::EventValidationBaseAlgorithm.

Definition at line 36 of file TestBeamHierarchyEventValidationAlgorithm.cc.

References lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetAllMCParticleToHitsMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetPfoToHitsMap(), lar_content::LArMCParticleHelper::PrimaryParameters::m_minHitsForGoodView, lar_content::LArMCParticleHelper::PrimaryParameters::m_minHitSharingFraction, lar_content::LArMCParticleHelper::PrimaryParameters::m_minPrimaryGoodHits, lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetAllMCParticleToHitsMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetInterpretedMCToPfoHitSharingMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetMCToPfoHitSharingMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetPfoToHitsMap(), and lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetTargetMCParticleToHitsMap().

38 {
39  if (pMCParticleList && pCaloHitList)
40  {
41  LArMCParticleHelper::MCContributionMap targetMCParticleToHitsMap;
42  LArMCParticleHelper::SelectReconstructableTestBeamHierarchyMCParticles(
43  pMCParticleList, pCaloHitList, m_primaryParameters, LArMCParticleHelper::IsLeadingBeamParticle, targetMCParticleToHitsMap);
44  LArMCParticleHelper::SelectReconstructableMCParticles(
45  pMCParticleList, pCaloHitList, m_primaryParameters, LArMCParticleHelper::IsCosmicRay, targetMCParticleToHitsMap);
46 
47  LArMCParticleHelper::PrimaryParameters parameters(m_primaryParameters);
48  parameters.m_minPrimaryGoodHits = 0;
49  parameters.m_minHitsForGoodView = 0;
50  parameters.m_minHitSharingFraction = 0.f;
51  LArMCParticleHelper::MCContributionMap allMCParticleToHitsMap;
52  LArMCParticleHelper::SelectReconstructableTestBeamHierarchyMCParticles(
53  pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsLeadingBeamParticle, allMCParticleToHitsMap);
54  LArMCParticleHelper::SelectReconstructableMCParticles(
55  pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsCosmicRay, allMCParticleToHitsMap);
56 
57  validationInfo.SetTargetMCParticleToHitsMap(targetMCParticleToHitsMap);
58  validationInfo.SetAllMCParticleToHitsMap(allMCParticleToHitsMap);
59  }
60 
61  if (pPfoList)
62  {
63  PfoList allConnectedPfos;
64  LArPfoHelper::GetAllConnectedPfos(*pPfoList, allConnectedPfos);
65 
66  PfoList finalStatePfos;
67  for (const ParticleFlowObject *const pPfo : allConnectedPfos)
68  {
69  // ATTN: Is test beam only set for parent pfo, therefor add parent and daughters for that particle
70  if (LArPfoHelper::IsTestBeam(pPfo))
71  {
72  finalStatePfos.push_back(pPfo);
73  for (const ParticleFlowObject *const pDaughterPfo : pPfo->GetDaughterPfoList())
74  finalStatePfos.push_back(pDaughterPfo);
75  }
76  else if (pPfo->GetParentPfoList().empty())
77  {
78  finalStatePfos.push_back(pPfo);
79  }
80  }
81 
82  LArMCParticleHelper::PfoContributionMap pfoToHitsMap;
83  LArMCParticleHelper::GetTestBeamHierarchyPfoToReconstructable2DHitsMap(
84  finalStatePfos, validationInfo.GetAllMCParticleToHitsMap(), pfoToHitsMap, m_primaryParameters.m_foldBackHierarchy);
85  validationInfo.SetPfoToHitsMap(pfoToHitsMap);
86  }
87 
88  LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCHitSharingMap;
89  LArMCParticleHelper::MCParticleToPfoHitSharingMap mcToPfoHitSharingMap;
90  LArMCParticleHelper::GetPfoMCParticleHitSharingMaps(
91  validationInfo.GetPfoToHitsMap(), {validationInfo.GetAllMCParticleToHitsMap()}, pfoToMCHitSharingMap, mcToPfoHitSharingMap);
92  validationInfo.SetMCToPfoHitSharingMap(mcToPfoHitSharingMap);
93 
94  LArMCParticleHelper::MCParticleToPfoHitSharingMap interpretedMCToPfoHitSharingMap;
95  this->InterpretMatching(validationInfo, interpretedMCToPfoHitSharingMap);
96  validationInfo.SetInterpretedMCToPfoHitSharingMap(interpretedMCToPfoHitSharingMap);
97 }
lar_content::LArMCParticleHelper::MCContributionMap
std::unordered_map< const pandora::MCParticle *, pandora::CaloHitList > MCContributionMap
Definition: LArMCParticleHelper.h:35
lar_content::LArMCParticleHelper::GetTestBeamHierarchyPfoToReconstructable2DHitsMap
static void GetTestBeamHierarchyPfoToReconstructable2DHitsMap(const pandora::PfoList &pfoList, const MCContributionMap &selectedMCParticleToHitsMap, PfoContributionMap &pfoToReconstructable2DHitsMap, const bool foldBackHierarchy)
Get mapping from Pfo in reconstructed test beam hierarchy to reconstructable 2D hits (=good hits belo...
lar_content::LArMCParticleHelper::IsLeadingBeamParticle
static bool IsLeadingBeamParticle(const pandora::MCParticle *const pMCParticle)
Returns true if passed a leading beam MCParticle.
Definition: LArMCParticleHelper.cc:101
lar_content::EventValidationBaseAlgorithm::InterpretMatching
void InterpretMatching(const ValidationInfo &validationInfo, LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const
Apply an interpretative matching procedure to the comprehensive matches in the provided validation in...
Definition: EventValidationBaseAlgorithm.cc:86
lar_content::LArMCParticleHelper::GetPfoMCParticleHitSharingMaps
static void GetPfoMCParticleHitSharingMaps(const PfoContributionMap &pfoToReconstructable2DHitsMap, const MCContributionMapVector &selectedMCParticleToHitsMaps, PfoToMCParticleHitSharingMap &pfoToMCParticleHitSharingMap, MCParticleToPfoHitSharingMap &mcParticleToPfoHitSharingMap)
Get the mappings from Pfo -> pair (reconstructable MCparticles, number of reconstructable 2D hits sha...
Definition: LArMCParticleHelper.cc:686
lar_content::LArMCParticleHelper::MCParticleToPfoHitSharingMap
std::map< const pandora::MCParticle *, PfoToSharedHitsVector > MCParticleToPfoHitSharingMap
Definition: LArMCParticleHelper.h:50
lar_content::LArMCParticleHelper::PrimaryParameters::m_foldBackHierarchy
bool m_foldBackHierarchy
whether to fold the hierarchy back to the primary (neutrino) or leading particles (test beam) ...
Definition: LArMCParticleHelper.h:69
lar_content::LArMCParticleHelper::SelectReconstructableTestBeamHierarchyMCParticles
static void SelectReconstructableTestBeamHierarchyMCParticles(const pandora::MCParticleList *pMCParticleList, const pandora::CaloHitList *pCaloHitList, const PrimaryParameters &parameters, std::function< bool(const pandora::MCParticle *const)> fCriteria, MCContributionMap &selectedMCParticlesToHitsMap)
Select target, reconstructable mc particles in the relevant hierarchy that match given criteria...
Definition: LArMCParticleHelper.cc:585
lar_content::LArMCParticleHelper::IsCosmicRay
static bool IsCosmicRay(const pandora::MCParticle *const pMCParticle)
Return true if passed a primary cosmic ray MCParticle.
Definition: LArMCParticleHelper.cc:110
lar_content::LArMCParticleHelper::SelectReconstructableMCParticles
static void SelectReconstructableMCParticles(const pandora::MCParticleList *pMCParticleList, const pandora::CaloHitList *pCaloHitList, const PrimaryParameters &parameters, std::function< bool(const pandora::MCParticle *const)> fCriteria, MCContributionMap &selectedMCParticlesToHitsMap)
Select target, reconstructable mc particles that match given criteria.
Definition: LArMCParticleHelper.cc:546
lar_content::LArPfoHelper::IsTestBeam
static bool IsTestBeam(const pandora::ParticleFlowObject *const pPfo)
Whether a pfo is a test beam particle.
Definition: LArPfoHelper.cc:418
lar_content::EventValidationBaseAlgorithm::m_primaryParameters
LArMCParticleHelper::PrimaryParameters m_primaryParameters
The mc particle primary selection parameters.
Definition: EventValidationBaseAlgorithm.h:192
lar_content::LArMCParticleHelper::PfoContributionMap
std::unordered_map< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoContributionMap
Definition: LArMCParticleHelper.h:39
lar_content::LArPfoHelper::GetAllConnectedPfos
static void GetAllConnectedPfos(const pandora::PfoList &inputPfoList, pandora::PfoList &outputPfoList)
Get a flat list of all pfos, recursively including all daughters and parents associated with those pf...
lar_content::LArMCParticleHelper::PfoToMCParticleHitSharingMap
std::map< const pandora::ParticleFlowObject *, MCParticleToSharedHitsVector > PfoToMCParticleHitSharingMap
Definition: LArMCParticleHelper.h:49
void lar_content::EventValidationBaseAlgorithm::GetRemainingPfoMatches ( const ValidationInfo &  validationInfo,
const pandora::MCParticleVector &  mcPrimaryVector,
const pandora::PfoSet &  usedPfos,
LArMCParticleHelper::MCParticleToPfoHitSharingMap &  interpretedMCToPfoHitSharingMap 
) const
protectedinherited

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

Parameters
validationInfothe validation info
mcPrimaryVectorthe mc primary vector
usedPfosthe set of previously used pfos
interpretedMCToPfoHitSharingMapthe output, interpreted mc particle to pfo hit sharing map

Definition at line 155 of file EventValidationBaseAlgorithm.cc.

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

Referenced by lar_content::EventValidationBaseAlgorithm::InterpretMatching().

157 {
158  LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCParticleHitSharingMap;
159 
160  for (const MCParticle *const pMCPrimary : mcPrimaryVector)
161  {
162  if (!m_useSmallPrimaries && !validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary))
163  continue;
164 
165  if (!validationInfo.GetMCToPfoHitSharingMap().count(pMCPrimary))
166  continue;
167 
168  for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : validationInfo.GetMCToPfoHitSharingMap().at(pMCPrimary))
169  {
170  if (usedPfos.count(pfoToSharedHits.first))
171  continue;
172 
173  const LArMCParticleHelper::MCParticleCaloHitListPair mcParticleToHits(pMCPrimary, pfoToSharedHits.second);
174  LArMCParticleHelper::PfoToMCParticleHitSharingMap::iterator iter(pfoToMCParticleHitSharingMap.find(pfoToSharedHits.first));
175 
176  if (pfoToMCParticleHitSharingMap.end() == iter)
177  {
178  pfoToMCParticleHitSharingMap[pfoToSharedHits.first].push_back(mcParticleToHits);
179  }
180  else
181  {
182  if (1 != iter->second.size())
183  throw StatusCodeException(STATUS_CODE_FAILURE);
184 
185  LArMCParticleHelper::MCParticleCaloHitListPair &originalMCParticleToHits(iter->second.at(0));
186 
187  if (mcParticleToHits.second.size() > originalMCParticleToHits.second.size())
188  originalMCParticleToHits = mcParticleToHits;
189  }
190  }
191  }
192 
193  for (const auto &mapEntry : pfoToMCParticleHitSharingMap)
194  {
195  const LArMCParticleHelper::MCParticleCaloHitListPair &mcParticleToHits(mapEntry.second.at(0));
196  interpretedMCToPfoHitSharingMap[mcParticleToHits.first].push_back(
197  LArMCParticleHelper::PfoCaloHitListPair(mapEntry.first, mcParticleToHits.second));
198  }
199 }
iterator
intermediate_table::iterator iterator
Definition: intermediate_table.cc:27
lar_content::LArMCParticleHelper::MCParticleCaloHitListPair
std::pair< const pandora::MCParticle *, pandora::CaloHitList > MCParticleCaloHitListPair
Definition: LArMCParticleHelper.h:42
lar_content::EventValidationBaseAlgorithm::m_useSmallPrimaries
bool m_useSmallPrimaries
Whether to consider matches to mc primaries with fewer than m_matchingMinPrimaryHits.
Definition: EventValidationBaseAlgorithm.h:230
lar_content::LArMCParticleHelper::PfoCaloHitListPair
std::pair< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoCaloHitListPair
Definition: LArMCParticleHelper.h:43
lar_content::LArMCParticleHelper::PfoToMCParticleHitSharingMap
std::map< const pandora::ParticleFlowObject *, MCParticleToSharedHitsVector > PfoToMCParticleHitSharingMap
Definition: LArMCParticleHelper.h:49
bool lar_content::EventValidationBaseAlgorithm::GetStrongestPfoMatch ( const ValidationInfo &  validationInfo,
const pandora::MCParticleVector &  mcPrimaryVector,
pandora::PfoSet &  usedPfos,
LArMCParticleHelper::MCParticleToPfoHitSharingMap &  interpretedMCToPfoHitSharingMap 
) const
protectedinherited

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

Parameters
validationInfothe validation info
mcPrimaryVectorthe mc primary vector
usedPfosthe set of previously used pfos
interpretedMCToPfoHitSharingMapthe output, interpreted mc particle to pfo hit sharing map
Returns
whether a strong match was identified

Definition at line 111 of file EventValidationBaseAlgorithm.cc.

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

Referenced by lar_content::EventValidationBaseAlgorithm::InterpretMatching().

113 {
114  const MCParticle *pBestMCParticle(nullptr);
115  LArMCParticleHelper::PfoCaloHitListPair bestPfoHitPair(nullptr, CaloHitList());
116 
117  for (const MCParticle *const pMCPrimary : mcPrimaryVector)
118  {
119  if (interpretedMCToPfoHitSharingMap.count(pMCPrimary))
120  continue;
121 
122  if (!m_useSmallPrimaries && !validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary))
123  continue;
124 
125  if (!validationInfo.GetMCToPfoHitSharingMap().count(pMCPrimary))
126  continue;
127 
128  for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : validationInfo.GetMCToPfoHitSharingMap().at(pMCPrimary))
129  {
130  if (usedPfos.count(pfoToSharedHits.first))
131  continue;
132 
133  if (!this->IsGoodMatch(validationInfo.GetAllMCParticleToHitsMap().at(pMCPrimary),
134  validationInfo.GetPfoToHitsMap().at(pfoToSharedHits.first), pfoToSharedHits.second))
135  continue;
136 
137  if (pfoToSharedHits.second.size() > bestPfoHitPair.second.size())
138  {
139  pBestMCParticle = pMCPrimary;
140  bestPfoHitPair = pfoToSharedHits;
141  }
142  }
143  }
144 
145  if (!pBestMCParticle || !bestPfoHitPair.first)
146  return false;
147 
148  interpretedMCToPfoHitSharingMap[pBestMCParticle].push_back(bestPfoHitPair);
149  usedPfos.insert(bestPfoHitPair.first);
150  return true;
151 }
lar_content::EventValidationBaseAlgorithm::m_useSmallPrimaries
bool m_useSmallPrimaries
Whether to consider matches to mc primaries with fewer than m_matchingMinPrimaryHits.
Definition: EventValidationBaseAlgorithm.h:230
lar_content::LArMCParticleHelper::PfoCaloHitListPair
std::pair< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoCaloHitListPair
Definition: LArMCParticleHelper.h:43
lar_content::EventValidationBaseAlgorithm::IsGoodMatch
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.
Definition: EventValidationBaseAlgorithm.cc:203
void lar_content::EventValidationBaseAlgorithm::InterpretMatching ( const ValidationInfo &  validationInfo,
LArMCParticleHelper::MCParticleToPfoHitSharingMap &  interpretedMCToPfoHitSharingMap 
) const
protectedinherited

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

Parameters
validationInfothe validation info
interpretedMCToPfoHitSharingMapthe output, interpreted mc particle to pfo hit sharing map

Definition at line 86 of file EventValidationBaseAlgorithm.cc.

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

Referenced by lar_content::NeutrinoEventValidationAlgorithm::FillValidationInfo(), and lar_content::MuonLeadingEventValidationAlgorithm::PerformUnfoldedMatching().

88 {
89  MCParticleVector mcPrimaryVector;
90  LArMonitoringHelper::GetOrderedMCParticleVector({validationInfo.GetAllMCParticleToHitsMap()}, mcPrimaryVector);
91 
92  PfoSet usedPfos;
93  while (this->GetStrongestPfoMatch(validationInfo, mcPrimaryVector, usedPfos, interpretedMCToPfoHitSharingMap))
94  {
95  }
96  this->GetRemainingPfoMatches(validationInfo, mcPrimaryVector, usedPfos, interpretedMCToPfoHitSharingMap);
97 
98  // Ensure all primaries have an entry, and sorting is as desired
99  for (const MCParticle *const pMCPrimary : mcPrimaryVector)
100  {
101  LArMCParticleHelper::PfoToSharedHitsVector &pfoHitPairs(interpretedMCToPfoHitSharingMap[pMCPrimary]);
102  std::sort(pfoHitPairs.begin(), pfoHitPairs.end(),
103  [](const LArMCParticleHelper::PfoCaloHitListPair &a, const LArMCParticleHelper::PfoCaloHitListPair &b) -> bool {
104  return ((a.second.size() != b.second.size()) ? a.second.size() > b.second.size() : LArPfoHelper::SortByNHits(a.first, b.first));
105  });
106  }
107 }
lar_content::LArPfoHelper::SortByNHits
static bool SortByNHits(const pandora::ParticleFlowObject *const pLhs, const pandora::ParticleFlowObject *const pRhs)
Sort pfos by number of constituent hits.
Definition: LArPfoHelper.cc:610
lar_content::LArMCParticleHelper::PfoToSharedHitsVector
std::vector< PfoCaloHitListPair > PfoToSharedHitsVector
Definition: LArMCParticleHelper.h:47
lar_content::LArMonitoringHelper::GetOrderedMCParticleVector
static void GetOrderedMCParticleVector(const LArMCParticleHelper::MCContributionMapVector &selectedMCParticleToGoodHitsMaps, pandora::MCParticleVector &orderedMCParticleVector)
Order input MCParticles by their number of hits.
Definition: LArMonitoringHelper.cc:43
lar_pandora::MCParticleVector
std::vector< art::Ptr< simb::MCParticle > > MCParticleVector
Definition: LArPandoraHelper.h:69
lar_content::EventValidationBaseAlgorithm::GetStrongestPfoMatch
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...
Definition: EventValidationBaseAlgorithm.cc:111
lar_content::EventValidationBaseAlgorithm::GetRemainingPfoMatches
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.
Definition: EventValidationBaseAlgorithm.cc:155
lar_content::LArMCParticleHelper::PfoCaloHitListPair
std::pair< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoCaloHitListPair
Definition: LArMCParticleHelper.h:43
bool lar_content::EventValidationBaseAlgorithm::IsGoodMatch ( const pandora::CaloHitList &  trueHits,
const pandora::CaloHitList &  recoHits,
const pandora::CaloHitList &  sharedHits 
) const
protectedinherited

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

Parameters
trueHitsthe list of true hits
recoHitsthe list of reco hits
sharedHitsthe list of shared hits
Returns
boolean

Definition at line 203 of file EventValidationBaseAlgorithm.cc.

References f, lar_content::EventValidationBaseAlgorithm::m_matchingMinCompleteness, lar_content::EventValidationBaseAlgorithm::m_matchingMinPurity, and lar_content::EventValidationBaseAlgorithm::m_matchingMinSharedHits.

Referenced by lar_content::MuonLeadingEventValidationAlgorithm::DetermineIncorrectlyReconstructedCosmicRays(), lar_content::EventValidationBaseAlgorithm::GetStrongestPfoMatch(), lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), and lar_content::MuonLeadingEventValidationAlgorithm::ProcessOutput().

204 {
205  const float purity((recoHits.size() > 0) ? static_cast<float>(sharedHits.size()) / static_cast<float>(recoHits.size()) : 0.f);
206  const float completeness((trueHits.size() > 0) ? static_cast<float>(sharedHits.size()) / static_cast<float>(trueHits.size()) : 0.f);
207 
208  return ((sharedHits.size() >= m_matchingMinSharedHits) && (purity >= m_matchingMinPurity) && (completeness >= m_matchingMinCompleteness));
209 }
lar_content::EventValidationBaseAlgorithm::m_matchingMinPurity
float m_matchingMinPurity
The minimum particle purity to declare a match.
Definition: EventValidationBaseAlgorithm.h:233
f
TFile f
Definition: plotHisto.C:6
lar_content::EventValidationBaseAlgorithm::m_matchingMinSharedHits
unsigned int m_matchingMinSharedHits
The minimum number of shared hits used in matching scheme.
Definition: EventValidationBaseAlgorithm.h:231
lar_content::EventValidationBaseAlgorithm::m_matchingMinCompleteness
float m_matchingMinCompleteness
The minimum particle completeness to declare a match.
Definition: EventValidationBaseAlgorithm.h:232
void lar_content::TestBeamHierarchyEventValidationAlgorithm::ProcessOutput ( const ValidationInfo &  validationInfo,
const bool  useInterpretedMatching,
const bool  printToScreen,
const bool  fillTree 
) const
privatevirtual

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

Parameters
validationInfothe validation info
useInterpretedMatchingwhether to use the interpreted (rather than raw) matching information
printToScreenwhether to print the information to screen
fillTreewhether to write the information to tree

Implements lar_content::EventValidationBaseAlgorithm.

Definition at line 101 of file TestBeamHierarchyEventValidationAlgorithm.cc.

References lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetAllMCParticleToHitsMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetInterpretedMCToPfoHitSharingMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetMCToPfoHitSharingMap(), lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetPfoToHitsMap(), and lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetTargetMCParticleToHitsMap().

103 {
104  static int eventNumber{-1};
105  ++eventNumber;
106  if (printToScreen && useInterpretedMatching)
107  std::cout << "---INTERPRETED-MATCHING-OUTPUT------------------------------------------------------------------" << std::endl;
108  else if (printToScreen)
109  std::cout << "---RAW-MATCHING-OUTPUT--------------------------------------------------------------------------" << std::endl;
110 
111  PfoVector primaryPfoVector;
112  LArMonitoringHelper::GetOrderedPfoVector(validationInfo.GetPfoToHitsMap(), primaryPfoVector);
113 
114  // Test Beam Hierarchy Validation Pfo Bookkeeping
115  int pfoIndex(0), testBeamPfoIndex(0);
116  PfoToIdMap pfoToIdMap, testBeamPfoToIdMap;
117 
118  for (const Pfo *const pPrimaryPfo : primaryPfoVector)
119  {
120  pfoToIdMap.insert(PfoToIdMap::value_type(pPrimaryPfo, ++pfoIndex));
121  const Pfo *const pRecoTestBeam(LArPfoHelper::IsTestBeamFinalState(pPrimaryPfo) ? LArPfoHelper::GetParentPfo(pPrimaryPfo) : nullptr);
122 
123  if (pRecoTestBeam && !testBeamPfoToIdMap.count(pRecoTestBeam))
124  testBeamPfoToIdMap.insert(PfoToIdMap::value_type(pRecoTestBeam, ++testBeamPfoIndex));
125  }
126 
127  const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap(
128  useInterpretedMatching ? validationInfo.GetInterpretedMCToPfoHitSharingMap() : validationInfo.GetMCToPfoHitSharingMap());
129 
130  // Test Beam Hierarchy Validation MCParticle Bookkeeping
131  MCParticleVector mcPrimaryVector;
132  LArMonitoringHelper::GetOrderedMCParticleVector({validationInfo.GetTargetMCParticleToHitsMap()}, mcPrimaryVector);
133  LArMCParticleHelper::MCParticleIntMap triggeredToLeading, triggeredToLeadingCounter;
134 
135  // ATTN: At this stage the mcPrimaryVector is ordered from neutrinos, beam and then cosmics. Here we extract the beam and reorder
136  // to ensure the order follows primary parent beam 1, daughter 1 of beam 1, daughter 2 of beam 1, ..., primary parent beam 2,
137  // daughter 1 of beam 2, etc... as expected by downstream logic
138  MCParticleVector mcPrimaryVectorCopy(mcPrimaryVector), triggeredBeamParticles;
139  LArMCParticleHelper::MCRelationMap leadingToTriggeredMap;
140  mcPrimaryVector.clear();
141 
142  for (const MCParticle *const pMCPrimary : mcPrimaryVectorCopy)
143  {
144  if (LArMCParticleHelper::IsLeadingBeamParticle(pMCPrimary))
145  {
146  const MCParticle *const pParentMCParticle(LArMCParticleHelper::GetParentMCParticle(pMCPrimary));
147  leadingToTriggeredMap.insert(LArMCParticleHelper::MCRelationMap::value_type(pMCPrimary, pParentMCParticle));
148 
149  if (std::find(triggeredBeamParticles.begin(), triggeredBeamParticles.end(), pParentMCParticle) == triggeredBeamParticles.end())
150  triggeredBeamParticles.push_back(pParentMCParticle);
151  }
152  else
153  {
154  mcPrimaryVector.push_back(pMCPrimary);
155  }
156  }
157 
158  for (const MCParticle *const pMCParent : triggeredBeamParticles)
159  {
160  // Parent appears first
161  mcPrimaryVector.push_back(pMCParent);
162  triggeredToLeading.insert(LArMCParticleHelper::MCParticleIntMap::value_type(pMCParent, 1));
163  triggeredToLeadingCounter.insert(LArMCParticleHelper::MCParticleIntMap::value_type(pMCParent, 0));
164 
165  for (const auto iter : leadingToTriggeredMap)
166  {
167  // Followed by daughters, veto parent <-> parent matche
168  if (iter.second == pMCParent && iter.first != pMCParent)
169  {
170  mcPrimaryVector.push_back(iter.first);
171  triggeredToLeading.at(pMCParent)++;
172  }
173  }
174  }
175 
176  PfoSet recoTestBeamHierarchies;
177  MCParticleList associatedMCPrimaries;
178 
179  int nCorrectTB(0), nTotalTB(0), nCorrectTBHierarchy(0), nTotalTBHierarchy(0), nCorrectCR(0), nTotalCR(0);
180  int nFakeTBHierarchy(0), nFakeCR(0), nSplitTBHierarchy(0), nSplitCR(0), nLost(0), mcPrimaryIndex(0), nTargetMatches(0),
181  nTargetTBHierarchyMatches(0);
182  int nTargetCRMatches(0), nTargetGoodTBHierarchyMatches(0), nTargetTBHierarchySplits(0), nTargetTBHierarchyLosses(0);
183  IntVector mcPrimaryId, mcPrimaryPdg, mcPrimaryTier, nMCHitsTotal, nMCHitsU, nMCHitsV, nMCHitsW;
184  FloatVector mcPrimaryE, mcPrimaryPX, mcPrimaryPY, mcPrimaryPZ;
185  FloatVector mcPrimaryVtxX, mcPrimaryVtxY, mcPrimaryVtxZ, mcPrimaryEndX, mcPrimaryEndY, mcPrimaryEndZ;
186  IntVector nPrimaryMatchedPfos, nPrimaryMatchedTBHierarchyPfos, nPrimaryMatchedCRPfos;
187  IntVector bestMatchPfoId, bestMatchPfoPdg, bestMatchPfoTier, bestMatchPfoIsTestBeam, bestMatchPfoIsTestBeamHierarchy;
188  IntVector bestMatchPfoRecoTBId, bestMatchPfoNHitsTotal, bestMatchPfoNHitsU, bestMatchPfoNHitsV, bestMatchPfoNHitsW;
189  IntVector bestMatchPfoNSharedHitsTotal, bestMatchPfoNSharedHitsU, bestMatchPfoNSharedHitsV, bestMatchPfoNSharedHitsW;
190  FloatVector bestMatchPfoX0;
191 
192  std::stringstream targetSS;
193  const std::string name("TB");
194 
195  for (const MCParticle *const pMCPrimary : mcPrimaryVector)
196  {
197  const bool hasMatch(mcToPfoHitSharingMap.count(pMCPrimary) && !mcToPfoHitSharingMap.at(pMCPrimary).empty());
198  const bool isTargetPrimary(validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary));
199 
200  if (!isTargetPrimary)
201  continue;
202 
203  // Parent in hierarchy needed even if no match
204  const bool hasVisibleTargets(
205  (!triggeredToLeading.empty() && LArMCParticleHelper::IsBeamParticle(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)))
206  ? triggeredToLeading.at(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)) != 1
207  : false);
208 
209  if (!hasMatch && !hasVisibleTargets)
210  continue;
211 
212  associatedMCPrimaries.push_back(pMCPrimary);
213  const int nTargetPrimaries(associatedMCPrimaries.size());
214  ++mcPrimaryIndex;
215  const CaloHitList &mcPrimaryHitList(validationInfo.GetAllMCParticleToHitsMap().at(pMCPrimary));
216 
217  const int mcNuanceCode(LArMCParticleHelper::GetNuanceCode(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)));
218  const int isBeamParticle(LArMCParticleHelper::IsBeamParticle(pMCPrimary));
219 
220  // Leading beam particle is the primary beam particle or a daughter of that particle
221  const int isLeadingBeamParticle(LArMCParticleHelper::IsLeadingBeamParticle(pMCPrimary));
222  const int isCosmicRay(LArMCParticleHelper::IsCosmicRay(pMCPrimary));
223 
224  // Tier (0) : Primary, (1) : Daughter, (2) : Granddaughter etc... Note tier increases for both visible and invisible particles
225  const int mcHierarchyTier(LArMCParticleHelper::GetHierarchyTier(pMCPrimary));
226 
227  // Identify the number of matched leading particles and flag whether last particle in hierarchy is being considered
228  bool isLastTestBeamLeading(false);
229  if (isLeadingBeamParticle)
230  {
231  triggeredToLeadingCounter.at(LArMCParticleHelper::GetParentMCParticle(pMCPrimary))++;
232  const int nHierarchyLeading(triggeredToLeadingCounter.at(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)));
233  isLastTestBeamLeading = (nHierarchyLeading == triggeredToLeading.at(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)));
234  }
235 
236 #ifdef MONITORING
237  const CartesianVector &targetVertex(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)->GetVertex());
238  const float targetVertexX(targetVertex.GetX()), targetVertexY(targetVertex.GetY()), targetVertexZ(targetVertex.GetZ());
239 #endif
240 
241  for (int tier = 0; tier < mcHierarchyTier; tier++)
242  targetSS << " -> ";
243 
244  targetSS << (!isTargetPrimary ? "(Non target) " : "") << "PrimaryId " << mcPrimaryIndex << ", TB " << isBeamParticle << ", TB Hierarchy "
245  << isLeadingBeamParticle << ", CR " << isCosmicRay << ", MCPDG " << pMCPrimary->GetParticleId() << ", Tier " << mcHierarchyTier
246  << ", Energy " << pMCPrimary->GetEnergy() << ", Dist. " << (pMCPrimary->GetEndpoint() - pMCPrimary->GetVertex()).GetMagnitude()
247  << ", nMCHits " << mcPrimaryHitList.size() << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList)
248  << ", " << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList) << ", "
249  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList) << ")" << std::endl;
250 
251  mcPrimaryId.push_back(mcPrimaryIndex);
252  mcPrimaryPdg.push_back(pMCPrimary->GetParticleId());
253  mcPrimaryTier.push_back(mcHierarchyTier);
254  mcPrimaryE.push_back(pMCPrimary->GetEnergy());
255  mcPrimaryPX.push_back(pMCPrimary->GetMomentum().GetX());
256  mcPrimaryPY.push_back(pMCPrimary->GetMomentum().GetY());
257  mcPrimaryPZ.push_back(pMCPrimary->GetMomentum().GetZ());
258  mcPrimaryVtxX.push_back(pMCPrimary->GetVertex().GetX());
259  mcPrimaryVtxY.push_back(pMCPrimary->GetVertex().GetY());
260  mcPrimaryVtxZ.push_back(pMCPrimary->GetVertex().GetZ());
261  mcPrimaryEndX.push_back(pMCPrimary->GetEndpoint().GetX());
262  mcPrimaryEndY.push_back(pMCPrimary->GetEndpoint().GetY());
263  mcPrimaryEndZ.push_back(pMCPrimary->GetEndpoint().GetZ());
264  nMCHitsTotal.push_back(mcPrimaryHitList.size());
265  nMCHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList));
266  nMCHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList));
267  nMCHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList));
268 
269  int matchIndex(0), nPrimaryMatches(0), nPrimaryTBHierarchyMatches(0), nPrimaryCRMatches(0), nPrimaryGoodTBHierarchyMatches(0),
270  nPrimaryTBHierarchySplits(0);
271 #ifdef MONITORING
272  float recoVertexX(std::numeric_limits<float>::max()), recoVertexY(std::numeric_limits<float>::max()),
273  recoVertexZ(std::numeric_limits<float>::max());
274 #endif
275  for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : mcToPfoHitSharingMap.at(pMCPrimary))
276  {
277  const CaloHitList &sharedHitList(pfoToSharedHits.second);
278  const CaloHitList &pfoHitList(validationInfo.GetPfoToHitsMap().at(pfoToSharedHits.first));
279 
280  const bool isRecoTestBeam(LArPfoHelper::IsTestBeam(pfoToSharedHits.first));
281  const bool isRecoTestBeamHierarchy(LArPfoHelper::IsTestBeamFinalState(pfoToSharedHits.first));
282  const bool isGoodMatch(this->IsGoodMatch(mcPrimaryHitList, pfoHitList, sharedHitList));
283 
284  // Tier (0) : Primary, (1) : Daughter, (2) : Granddaughter etc... Note that the tier only increases for visible particle
285  const int pfoHierarchyTier(LArPfoHelper::GetHierarchyTier(pfoToSharedHits.first));
286  const int pfoId(pfoToIdMap.at(pfoToSharedHits.first));
287  const int recoTBId(
288  isRecoTestBeam || isRecoTestBeamHierarchy ? testBeamPfoToIdMap.at(LArPfoHelper::GetParentPfo(pfoToSharedHits.first)) : -1);
289 
290  if (0 == matchIndex++)
291  {
292  bestMatchPfoId.push_back(pfoId);
293  bestMatchPfoPdg.push_back(pfoToSharedHits.first->GetParticleId());
294  bestMatchPfoTier.push_back(pfoHierarchyTier);
295  bestMatchPfoIsTestBeam.push_back(isRecoTestBeam ? 1 : 0);
296  bestMatchPfoIsTestBeamHierarchy.push_back(isRecoTestBeamHierarchy ? 1 : 0);
297  bestMatchPfoRecoTBId.push_back(recoTBId);
298  bestMatchPfoNHitsTotal.push_back(pfoHitList.size());
299  bestMatchPfoNHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList));
300  bestMatchPfoNHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList));
301  bestMatchPfoNHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList));
302  bestMatchPfoNSharedHitsTotal.push_back(sharedHitList.size());
303  bestMatchPfoNSharedHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList));
304  bestMatchPfoNSharedHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList));
305  bestMatchPfoNSharedHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList));
306  bestMatchPfoX0.push_back(pfoToSharedHits.first->GetPropertiesMap().count("X0") ? pfoToSharedHits.first->GetPropertiesMap().at("X0")
307  : std::numeric_limits<float>::max());
308 #ifdef MONITORING
309  try
310  {
311  const Vertex *const pRecoVertex(isRecoTestBeamHierarchy
312  ? LArPfoHelper::GetTestBeamInteractionVertex(LArPfoHelper::GetParentPfo(pfoToSharedHits.first))
313  : LArPfoHelper::GetVertex(pfoToSharedHits.first));
314  recoVertexX = pRecoVertex->GetPosition().GetX();
315  recoVertexY = pRecoVertex->GetPosition().GetY();
316  recoVertexZ = pRecoVertex->GetPosition().GetZ();
317  }
318  catch (const StatusCodeException &)
319  {
320  }
321 #endif
322  }
323 
324  if (isGoodMatch)
325  ++nPrimaryMatches;
326 
327  // ATTN: In hierarchy mode let TBHierarchyMatches become effective TBHierarchyMatches and treat the same
328  if (isRecoTestBeamHierarchy && isGoodMatch)
329  ++nPrimaryTBHierarchyMatches;
330  if (!isRecoTestBeamHierarchy && isGoodMatch)
331  ++nPrimaryCRMatches;
332 
333  if (isRecoTestBeamHierarchy)
334  {
335  // Account for splitting of test beam particle into separate reconstructed primary pfos
336  const Pfo *const pRecoTB(LArPfoHelper::GetParentPfo(pfoToSharedHits.first));
337  const bool isSplitRecoTBHierarchy(!recoTestBeamHierarchies.empty() && !recoTestBeamHierarchies.count(pRecoTB));
338  if (!isSplitRecoTBHierarchy && isGoodMatch)
339  ++nPrimaryGoodTBHierarchyMatches;
340  if (isSplitRecoTBHierarchy && isLeadingBeamParticle && isGoodMatch)
341  ++nPrimaryTBHierarchySplits;
342  recoTestBeamHierarchies.insert(pRecoTB);
343  }
344 
345  for (int tier = 0; tier < mcHierarchyTier; tier++)
346  targetSS << " ";
347 
348  targetSS << "-" << (!isGoodMatch ? "(Below threshold) " : "") << "MatchedPfoId " << pfoId << ", TB " << isRecoTestBeam
349  << ", TB Hierarchy " << isRecoTestBeamHierarchy;
350  if (isRecoTestBeamHierarchy)
351  targetSS << " [TBId: " << recoTBId << "]";
352  targetSS << ", CR " << (!isRecoTestBeam && !isRecoTestBeamHierarchy) << ", PDG " << pfoToSharedHits.first->GetParticleId()
353  << ", Tier " << pfoHierarchyTier << ", nMatchedHits " << sharedHitList.size() << " ("
354  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList) << ", "
355  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList) << ", "
356  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList) << ")"
357  << ", nPfoHits " << pfoHitList.size() << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList) << ", "
358  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList) << ", "
359  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList) << ")" << std::endl;
360  }
361 
362  if (mcToPfoHitSharingMap.at(pMCPrimary).empty())
363  {
364  for (int tier = 0; tier < mcHierarchyTier; tier++)
365  targetSS << " ";
366  targetSS << "-No matched Pfo" << std::endl;
367  bestMatchPfoId.push_back(-1);
368  bestMatchPfoPdg.push_back(0);
369  bestMatchPfoTier.push_back(-1);
370  bestMatchPfoIsTestBeam.push_back(0);
371  bestMatchPfoIsTestBeamHierarchy.push_back(0);
372  bestMatchPfoRecoTBId.push_back(-1);
373  bestMatchPfoNHitsTotal.push_back(0);
374  bestMatchPfoNHitsU.push_back(0);
375  bestMatchPfoNHitsV.push_back(0);
376  bestMatchPfoNHitsW.push_back(0);
377  bestMatchPfoNSharedHitsTotal.push_back(0);
378  bestMatchPfoNSharedHitsU.push_back(0);
379  bestMatchPfoNSharedHitsV.push_back(0);
380  bestMatchPfoNSharedHitsW.push_back(0);
381  bestMatchPfoX0.push_back(std::numeric_limits<float>::max());
382  }
383 
384  nPrimaryMatchedPfos.push_back(nPrimaryMatches);
385  nPrimaryMatchedTBHierarchyPfos.push_back(nPrimaryTBHierarchyMatches);
386  nPrimaryMatchedCRPfos.push_back(nPrimaryCRMatches);
387  nTargetMatches += nPrimaryMatches;
388  nTargetTBHierarchyMatches += nPrimaryTBHierarchyMatches;
389  nTargetCRMatches += nPrimaryCRMatches;
390  nTargetGoodTBHierarchyMatches += nPrimaryGoodTBHierarchyMatches;
391  nTargetTBHierarchySplits += nPrimaryTBHierarchySplits;
392  if (0 == nPrimaryMatches)
393  ++nTargetTBHierarchyLosses;
394 
395  if (fillTree)
396  {
397  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "fileIdentifier", m_fileIdentifier));
398  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "eventNumber", eventNumber));
399  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcNuanceCode", mcNuanceCode));
400  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isBeamParticle", isBeamParticle));
401  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCosmicRay", isCosmicRay));
402  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetPrimaries", nTargetPrimaries));
403  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexX", targetVertexX));
404  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexY", targetVertexY));
405  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexZ", targetVertexZ));
406  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexX", recoVertexX));
407  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexY", recoVertexY));
408  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexZ", recoVertexZ));
409  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryId", &mcPrimaryId));
410  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPdg", &mcPrimaryPdg));
411  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryTier", &mcPrimaryTier));
412  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryE", &mcPrimaryE));
413  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPX", &mcPrimaryPX));
414  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPY", &mcPrimaryPY));
415  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPZ", &mcPrimaryPZ));
416  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxX", &mcPrimaryVtxX));
417  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxY", &mcPrimaryVtxY));
418  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxZ", &mcPrimaryVtxZ));
419  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndX", &mcPrimaryEndX));
420  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndY", &mcPrimaryEndY));
421  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndZ", &mcPrimaryEndZ));
422  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsTotal", &nMCHitsTotal));
423  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsU", &nMCHitsU));
424  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsV", &nMCHitsV));
425  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsW", &nMCHitsW));
426  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedPfos", &nPrimaryMatchedPfos));
427  PANDORA_MONITORING_API(
428  SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedTBHierarchyPfos", &nPrimaryMatchedTBHierarchyPfos));
429  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedCRPfos", &nPrimaryMatchedCRPfos));
430  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoId", &bestMatchPfoId));
431  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoPdg", &bestMatchPfoPdg));
432  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoTier", &bestMatchPfoTier));
433  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsTotal", &bestMatchPfoNHitsTotal));
434  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsU", &bestMatchPfoNHitsU));
435  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsV", &bestMatchPfoNHitsV));
436  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsW", &bestMatchPfoNHitsW));
437  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsTotal", &bestMatchPfoNSharedHitsTotal));
438  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsU", &bestMatchPfoNSharedHitsU));
439  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsV", &bestMatchPfoNSharedHitsV));
440  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsW", &bestMatchPfoNSharedHitsW));
441  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoX0", &bestMatchPfoX0));
442  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetMatches", nTargetMatches));
443  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetTBHierarchyMatches", nTargetTBHierarchyMatches));
444  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetCRMatches", nTargetCRMatches));
445 
446  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoIsTestBeam", &bestMatchPfoIsTestBeam));
447  PANDORA_MONITORING_API(
448  SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoIsTestBeamHierarchy", &bestMatchPfoIsTestBeamHierarchy));
449  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoRecoTBId", &bestMatchPfoRecoTBId));
450  PANDORA_MONITORING_API(
451  SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetGoodTBHierarchyMatches", nTargetGoodTBHierarchyMatches));
452  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetTBHierarchySplits", nTargetTBHierarchySplits));
453  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetTBHierarchyLosses", nTargetTBHierarchyLosses));
454  }
455 
456  if (isCosmicRay || isLastTestBeamLeading)
457  {
458  const LArInteractionTypeHelper::InteractionType interactionType(
459  LArInteractionTypeHelper::GetTestBeamHierarchyInteractionType(associatedMCPrimaries));
460 #ifdef MONITORING
461  const int interactionTypeInt(static_cast<int>(interactionType));
462 #endif
463  // ATTN Some redundancy introduced to contributing variables
464  const int isCorrectTB(isBeamParticle && (nTargetTBHierarchyMatches == 1) && (nTargetCRMatches == 0));
465  const int isCorrectTBHierarchy(isLeadingBeamParticle && (nTargetGoodTBHierarchyMatches == nTargetTBHierarchyMatches) &&
466  (nTargetGoodTBHierarchyMatches == nTargetPrimaries) && (nTargetCRMatches == 0) && (nTargetTBHierarchySplits == 0) &&
467  (nTargetTBHierarchyLosses == 0));
468  const int isCorrectCR(isCosmicRay && (nTargetTBHierarchyMatches == 0) && (nTargetCRMatches == 1));
469  const int isFakeTBHierarchy(isCosmicRay && (nTargetTBHierarchyMatches > 0));
470  const int isFakeCR(!isCosmicRay && (nTargetCRMatches > 0));
471  const int isSplitTBHierarchy(!isCosmicRay && ((nTargetTBHierarchyMatches > nTargetPrimaries) || (nTargetTBHierarchySplits > 0)));
472  const int isSplitCR(isCosmicRay && (nTargetCRMatches > 1));
473  const int isLost(nTargetMatches == 0);
474 
475  std::stringstream outcomeSS;
476  const bool isBeamHierarchy((mcNuanceCode == 2001) | (mcNuanceCode == 2000));
477  outcomeSS << LArInteractionTypeHelper::ToString(interactionType) << " (Nuance " << mcNuanceCode << ", TB " << isBeamHierarchy
478  << ", CR " << isCosmicRay << ")" << std::endl;
479 
480  if (isBeamParticle)
481  ++nTotalTB;
482  if (isLastTestBeamLeading)
483  ++nTotalTBHierarchy;
484  if (isCosmicRay)
485  ++nTotalCR;
486  if (isCorrectTB)
487  ++nCorrectTB;
488  if (isCorrectTBHierarchy)
489  ++nCorrectTBHierarchy;
490  if (isCorrectCR)
491  ++nCorrectCR;
492  if (isFakeTBHierarchy)
493  ++nFakeTBHierarchy;
494  if (isFakeCR)
495  ++nFakeCR;
496  if (isSplitTBHierarchy)
497  ++nSplitTBHierarchy;
498  if (isSplitCR)
499  ++nSplitCR;
500  if (isLost)
501  ++nLost;
502 
503  if (isCorrectTBHierarchy)
504  outcomeSS << "IsCorrectTBHierarchy";
505  if (isCorrectCR)
506  outcomeSS << "IsCorrectCR ";
507  if (isFakeTBHierarchy)
508  outcomeSS << "IsFake" << name << " ";
509  if (isFakeCR)
510  outcomeSS << "IsFakeCR ";
511  if (isSplitTBHierarchy)
512  outcomeSS << "isSplit" << name << " ";
513  if (isSplitCR)
514  outcomeSS << "IsSplitCR ";
515  if (isLost)
516  outcomeSS << "IsLost ";
517  if (nTargetTBHierarchyMatches > 0)
518  outcomeSS << "(N" << name << "Matches: " << nTargetTBHierarchyMatches << ") ";
519  if (nTargetTBHierarchyLosses > 0)
520  outcomeSS << "(N" << name << "Losses: " << nTargetTBHierarchyLosses << ") ";
521  if (nTargetTBHierarchySplits > 0)
522  outcomeSS << "(N" << name << "Splits: " << nTargetTBHierarchySplits << ") ";
523  if (nTargetCRMatches > 0)
524  outcomeSS << "(NCRMatches: " << nTargetCRMatches << ") ";
525  if (printToScreen)
526  std::cout << outcomeSS.str() << std::endl << targetSS.str() << std::endl;
527 
528  if (fillTree)
529  {
530  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "interactionType", interactionTypeInt));
531  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectTBHierarchy", isCorrectTBHierarchy));
532  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectCR", isCorrectCR));
533  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeTBHierarchy", isFakeTBHierarchy));
534  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeCR", isFakeCR));
535  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitTBHierarchy", isSplitTBHierarchy));
536  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitCR", isSplitCR));
537  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isLost", isLost));
538  PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treeName.c_str()));
539  }
540 
541  targetSS.str(std::string());
542  targetSS.clear();
543  associatedMCPrimaries.clear();
544  nTargetMatches = 0;
545  nTargetTBHierarchyMatches = 0;
546  nTargetCRMatches = 0;
547  nTargetGoodTBHierarchyMatches = 0;
548  nTargetTBHierarchySplits = 0;
549  nTargetTBHierarchyLosses = 0;
550  mcPrimaryId.clear();
551  mcPrimaryPdg.clear();
552  mcPrimaryTier.clear();
553  nMCHitsTotal.clear();
554  nMCHitsU.clear();
555  nMCHitsV.clear();
556  nMCHitsW.clear();
557  mcPrimaryE.clear();
558  mcPrimaryPX.clear();
559  mcPrimaryPY.clear();
560  mcPrimaryPZ.clear();
561  mcPrimaryVtxX.clear();
562  mcPrimaryVtxY.clear();
563  mcPrimaryVtxZ.clear();
564  mcPrimaryEndX.clear();
565  mcPrimaryEndY.clear();
566  mcPrimaryEndZ.clear();
567  nPrimaryMatchedPfos.clear();
568  nPrimaryMatchedTBHierarchyPfos.clear();
569  nPrimaryMatchedCRPfos.clear();
570  bestMatchPfoId.clear();
571  bestMatchPfoPdg.clear();
572  bestMatchPfoTier.clear();
573  bestMatchPfoIsTestBeam.clear();
574  bestMatchPfoIsTestBeamHierarchy.clear();
575  bestMatchPfoRecoTBId.clear();
576  bestMatchPfoNHitsTotal.clear();
577  bestMatchPfoNHitsU.clear();
578  bestMatchPfoNHitsV.clear();
579  bestMatchPfoNHitsW.clear();
580  bestMatchPfoNSharedHitsTotal.clear();
581  bestMatchPfoNSharedHitsU.clear();
582  bestMatchPfoNSharedHitsV.clear();
583  bestMatchPfoNSharedHitsW.clear();
584  bestMatchPfoX0.clear();
585  }
586  }
587 
588  if (useInterpretedMatching)
589  {
590  std::stringstream summarySS;
591  summarySS << "---SUMMARY--------------------------------------------------------------------------------------" << std::endl;
592  if (nTotalTBHierarchy > 0)
593  summarySS << "#CorrectTBHierarchy: " << nCorrectTBHierarchy << "/" << nTotalTBHierarchy << ", Fraction: "
594  << (nTotalTBHierarchy > 0 ? static_cast<float>(nCorrectTBHierarchy) / static_cast<float>(nTotalTBHierarchy) : 0.f)
595  << std::endl;
596  if (nTotalCR > 0)
597  summarySS << "#CorrectCR: " << nCorrectCR << "/" << nTotalCR
598  << ", Fraction: " << (nTotalCR > 0 ? static_cast<float>(nCorrectCR) / static_cast<float>(nTotalCR) : 0.f) << std::endl;
599  if (nFakeTBHierarchy > 0)
600  summarySS << "#Fake" << name << ": " << nFakeTBHierarchy << " ";
601  if (nFakeCR > 0)
602  summarySS << "#FakeCR: " << nFakeCR << " ";
603  if (nSplitTBHierarchy > 0)
604  summarySS << "#Split" << name << ": " << nSplitTBHierarchy << " ";
605  if (nSplitCR > 0)
606  summarySS << "#SplitCR: " << nSplitCR << " ";
607  if (nLost > 0)
608  summarySS << "#Lost: " << nLost << " ";
609  if (nFakeTBHierarchy || nFakeCR || nSplitTBHierarchy || nSplitCR || nLost)
610  summarySS << std::endl;
611  if (printToScreen)
612  std::cout << summarySS.str();
613  }
614 
615  if (printToScreen)
616  std::cout << "------------------------------------------------------------------------------------------------" << std::endl
617  << std::endl;
618 }
lar_content::LArMCParticleHelper::IsLeadingBeamParticle
static bool IsLeadingBeamParticle(const pandora::MCParticle *const pMCParticle)
Returns true if passed a leading beam MCParticle.
Definition: LArMCParticleHelper.cc:101
lar_content::EventValidationBaseAlgorithm::m_fileIdentifier
int m_fileIdentifier
The input file identifier.
Definition: EventValidationBaseAlgorithm.h:193
lar_content::LArPfoHelper::GetVertex
static const pandora::Vertex * GetVertex(const pandora::ParticleFlowObject *const pPfo)
Get the pfo vertex.
Definition: LArPfoHelper.cc:471
lar_content::LArMCParticleHelper::GetHierarchyTier
static int GetHierarchyTier(const pandora::MCParticle *const pMCParticle)
Determine the position in the hierarchy for the MCParticle.
Definition: LArMCParticleHelper.cc:173
lar_content::LArPfoHelper::GetTestBeamInteractionVertex
static const pandora::Vertex * GetTestBeamInteractionVertex(const pandora::ParticleFlowObject *const pPfo)
Get the pfo test beam interaction vertex.
Definition: LArPfoHelper.cc:499
std
STL namespace.
lar_content::LArMCParticleHelper::MCParticleToPfoHitSharingMap
std::map< const pandora::MCParticle *, PfoToSharedHitsVector > MCParticleToPfoHitSharingMap
Definition: LArMCParticleHelper.h:50
pandora::IntVector
std::vector< int > IntVector
Definition: LArPandoraHelper.h:27
lar_content::LArMCParticleHelper::GetNuanceCode
static unsigned int GetNuanceCode(const pandora::MCParticle *const pMCParticle)
Get the nuance code of an MCParticle.
Definition: LArMCParticleHelper.cc:119
f
TFile f
Definition: plotHisto.C:6
lar_content::LArMonitoringHelper::GetOrderedMCParticleVector
static void GetOrderedMCParticleVector(const LArMCParticleHelper::MCContributionMapVector &selectedMCParticleToGoodHitsMaps, pandora::MCParticleVector &orderedMCParticleVector)
Order input MCParticles by their number of hits.
Definition: LArMonitoringHelper.cc:43
lar_content::LArMCParticleHelper::IsCosmicRay
static bool IsCosmicRay(const pandora::MCParticle *const pMCParticle)
Return true if passed a primary cosmic ray MCParticle.
Definition: LArMCParticleHelper.cc:110
lar_content::LArPfoHelper::GetHierarchyTier
static int GetHierarchyTier(const pandora::ParticleFlowObject *const pPfo)
Determine the position in the hierarchy for the MCParticle.
Definition: LArPfoHelper.cc:219
lar_content::LArPfoHelper::IsTestBeam
static bool IsTestBeam(const pandora::ParticleFlowObject *const pPfo)
Whether a pfo is a test beam particle.
Definition: LArPfoHelper.cc:418
lar_content::LArMCParticleHelper::MCParticleIntMap
std::unordered_map< const pandora::MCParticle *, int > MCParticleIntMap
Definition: LArMCParticleHelper.h:28
lar_content::LArPfoHelper::GetParentPfo
static const pandora::ParticleFlowObject * GetParentPfo(const pandora::ParticleFlowObject *const pPfo)
Get the primary parent pfo.
Definition: LArPfoHelper.cc:445
lar_content::LArInteractionTypeHelper::ToString
static std::string ToString(const InteractionType interactionType)
Get a string representation of an interaction type.
Definition: LArInteractionTypeHelper.cc:701
lar_content::LArMCParticleHelper::IsBeamParticle
static bool IsBeamParticle(const pandora::MCParticle *const pMCParticle)
Returns true if passed a primary beam MCParticle.
Definition: LArMCParticleHelper.cc:93
lar_pandora::MCParticleVector
std::vector< art::Ptr< simb::MCParticle > > MCParticleVector
Definition: LArPandoraHelper.h:69
lar_content::LArMCParticleHelper::GetParentMCParticle
static const pandora::MCParticle * GetParentMCParticle(const pandora::MCParticle *const pMCParticle)
Get the parent mc particle.
Definition: LArMCParticleHelper.cc:232
lar_content::LArMonitoringHelper::GetOrderedPfoVector
static void GetOrderedPfoVector(const LArMCParticleHelper::PfoContributionMap &pfoToReconstructable2DHitsMap, pandora::PfoVector &orderedPfoVector)
Order input Pfos by their number of hits.
Definition: LArMonitoringHelper.cc:92
lar_content::LArInteractionTypeHelper::InteractionType
InteractionType
InteractionType enum.
Definition: LArInteractionTypeHelper.h:247
lar_content::LArMCParticleHelper::PfoCaloHitListPair
std::pair< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoCaloHitListPair
Definition: LArMCParticleHelper.h:43
lar_content::EventValidationBaseAlgorithm::m_treeName
std::string m_treeName
Name of output tree.
Definition: EventValidationBaseAlgorithm.h:196
lar_content::TestBeamHierarchyEventValidationAlgorithm::PfoToIdMap
std::unordered_map< const pandora::ParticleFlowObject *, unsigned int > PfoToIdMap
Definition: TestBeamHierarchyEventValidationAlgorithm.h:54
art::detail::Vertex
boost::graph_traits< ModuleGraph >::vertex_descriptor Vertex
Definition: ModuleGraph.h:25
lar_content::LArInteractionTypeHelper::GetTestBeamHierarchyInteractionType
static InteractionType GetTestBeamHierarchyInteractionType(const pandora::MCParticleList &mcPrimaryList)
Get the test beam hierarchy interaction type of an event.
Definition: LArInteractionTypeHelper.cc:489
lar_content::EventValidationBaseAlgorithm::IsGoodMatch
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.
Definition: EventValidationBaseAlgorithm.cc:203
lar_content::LArMonitoringHelper::CountHitsByType
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.
Definition: LArMonitoringHelper.cc:28
lar_content::LArMCParticleHelper::MCRelationMap
std::unordered_map< const pandora::MCParticle *, const pandora::MCParticle * > MCRelationMap
Definition: LArMCParticleHelper.h:27
lar_content::LArPfoHelper::IsTestBeamFinalState
static bool IsTestBeamFinalState(const pandora::ParticleFlowObject *const pPfo)
Whether a pfo is a final-state particle from a test beam particle interaction.
Definition: LArPfoHelper.cc:411
StatusCode lar_content::TestBeamHierarchyEventValidationAlgorithm::ReadSettings ( const pandora::TiXmlHandle  xmlHandle)
private

Definition at line 622 of file TestBeamHierarchyEventValidationAlgorithm.cc.

623 {
624  return EventValidationBaseAlgorithm::ReadSettings(xmlHandle);
625 }
lar_content::EventValidationBaseAlgorithm::ReadSettings
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Definition: EventValidationBaseAlgorithm.cc:213

Member Data Documentation

int lar_content::EventValidationBaseAlgorithm::m_eventNumber
protectedinherited

The event number.

Definition at line 194 of file EventValidationBaseAlgorithm.h.

Referenced by lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), lar_content::MuonLeadingEventValidationAlgorithm::ProcessOutput(), and lar_content::EventValidationBaseAlgorithm::Run().

int lar_content::EventValidationBaseAlgorithm::m_fileIdentifier
protectedinherited

The input file identifier.

Definition at line 193 of file EventValidationBaseAlgorithm.h.

Referenced by lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), and lar_content::EventValidationBaseAlgorithm::ReadSettings().

LArMCParticleHelper::PrimaryParameters lar_content::EventValidationBaseAlgorithm::m_primaryParameters
protectedinherited

The mc particle primary selection parameters.

Definition at line 192 of file EventValidationBaseAlgorithm.h.

Referenced by lar_content::NeutrinoEventValidationAlgorithm::FillValidationInfo(), and lar_content::EventValidationBaseAlgorithm::ReadSettings().

std::string lar_content::EventValidationBaseAlgorithm::m_treeName
protectedinherited

Name of output tree.

Definition at line 196 of file EventValidationBaseAlgorithm.h.

Referenced by lar_content::NeutrinoEventValidationAlgorithm::ProcessOutput(), lar_content::MuonLeadingEventValidationAlgorithm::ProcessOutput(), lar_content::EventValidationBaseAlgorithm::ReadSettings(), and lar_content::EventValidationBaseAlgorithm::~EventValidationBaseAlgorithm().

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