LArSoft  v10_04_05
Liquid Argon Software toolkit - https://larsoft.org/
TestBeamEventValidationAlgorithm.cc
Go to the documentation of this file.
1 
9 #include "Pandora/AlgorithmHeaders.h"
10 
11 #include "larpandoracontent/LArHelpers/LArInteractionTypeHelper.h"
12 #include "larpandoracontent/LArHelpers/LArMonitoringHelper.h"
13 #include "larpandoracontent/LArHelpers/LArPfoHelper.h"
14 
15 #include "larpandoracontent/LArMonitoring/TestBeamEventValidationAlgorithm.h"
16 
17 #include <sstream>
18 
19 using namespace pandora;
20 
21 namespace lar_content
22 {
23 
24 TestBeamEventValidationAlgorithm::TestBeamEventValidationAlgorithm()
25 {
26 }
27 
28 //------------------------------------------------------------------------------------------------------------------------------------------
29 
30 TestBeamEventValidationAlgorithm::~TestBeamEventValidationAlgorithm()
31 {
32 }
33 
34 //------------------------------------------------------------------------------------------------------------------------------------------
35 
36 void TestBeamEventValidationAlgorithm::FillValidationInfo(const MCParticleList *const pMCParticleList,
37  const CaloHitList *const pCaloHitList, const PfoList *const pPfoList, ValidationInfo &validationInfo) const
38 {
39  if (pMCParticleList && pCaloHitList)
40  {
41  LArMCParticleHelper::MCContributionMap targetMCParticleToHitsMap;
42  LArMCParticleHelper::SelectReconstructableMCParticles(
43  pMCParticleList, pCaloHitList, m_primaryParameters, LArMCParticleHelper::IsBeamParticle, 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::SelectReconstructableMCParticles(
53  pMCParticleList, pCaloHitList, parameters, LArMCParticleHelper::IsBeamParticle, 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  if (pPfo->GetParentPfoList().empty())
70  finalStatePfos.push_back(pPfo);
71  }
72 
73  LArMCParticleHelper::PfoContributionMap pfoToHitsMap;
74  LArMCParticleHelper::GetPfoToReconstructable2DHitsMap(
75  finalStatePfos, validationInfo.GetAllMCParticleToHitsMap(), pfoToHitsMap, m_primaryParameters.m_foldBackHierarchy);
76 
77  validationInfo.SetPfoToHitsMap(pfoToHitsMap);
78  }
79 
80  LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCHitSharingMap;
81  LArMCParticleHelper::MCParticleToPfoHitSharingMap mcToPfoHitSharingMap;
82  LArMCParticleHelper::GetPfoMCParticleHitSharingMaps(
83  validationInfo.GetPfoToHitsMap(), {validationInfo.GetAllMCParticleToHitsMap()}, pfoToMCHitSharingMap, mcToPfoHitSharingMap);
84  validationInfo.SetMCToPfoHitSharingMap(mcToPfoHitSharingMap);
85 
86  LArMCParticleHelper::MCParticleToPfoHitSharingMap interpretedMCToPfoHitSharingMap;
87  this->InterpretMatching(validationInfo, interpretedMCToPfoHitSharingMap);
88  validationInfo.SetInterpretedMCToPfoHitSharingMap(interpretedMCToPfoHitSharingMap);
89 }
90 
91 //------------------------------------------------------------------------------------------------------------------------------------------
92 
93 void TestBeamEventValidationAlgorithm::ProcessOutput(
94  const ValidationInfo &validationInfo, const bool useInterpretedMatching, const bool printToScreen, const bool fillTree) const
95 {
96  static int eventNumber{-1};
97  ++eventNumber;
98  if (printToScreen && useInterpretedMatching)
99  std::cout << "---EVENT-" << eventNumber << "-INTERPRETED-MATCHING-OUTPUT----------------------------------------------------------"
100  << std::endl;
101  else if (printToScreen)
102  std::cout << "---EVENT-" << eventNumber << "-RAW-MATCHING-OUTPUT------------------------------------------------------------------"
103  << std::endl;
104 
105  const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap(
106  useInterpretedMatching ? validationInfo.GetInterpretedMCToPfoHitSharingMap() : validationInfo.GetMCToPfoHitSharingMap());
107 
108  MCParticleVector mcPrimaryVector;
109  LArMonitoringHelper::GetOrderedMCParticleVector({validationInfo.GetTargetMCParticleToHitsMap()}, mcPrimaryVector);
110 
111  // Test Beam Validation Bookkeeping
112  PfoVector primaryPfoVector;
113  LArMonitoringHelper::GetOrderedPfoVector(validationInfo.GetPfoToHitsMap(), primaryPfoVector);
114 
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  LArMCParticleHelper::MCParticleIntMap triggeredToLeading, triggeredToLeadingCounter;
128 
129  MCParticleList associatedMCPrimaries;
130 
131  int nCorrectTB(0), nTotalTB(0), nCorrectCR(0), nTotalCR(0), nFakeTB(0), nFakeCR(0), nSplitTB(0), nSplitCR(0), nLost(0);
132  int mcPrimaryIndex(0), nTargetMatches(0), nTargetTBMatches(0), nTargetCRMatches(0);
133  IntVector mcPrimaryId, mcPrimaryPdg, nMCHitsTotal, nMCHitsU, nMCHitsV, nMCHitsW;
134  FloatVector mcPrimaryE, mcPrimaryPX, mcPrimaryPY, mcPrimaryPZ;
135  FloatVector mcPrimaryVtxX, mcPrimaryVtxY, mcPrimaryVtxZ, mcPrimaryEndX, mcPrimaryEndY, mcPrimaryEndZ;
136  IntVector nPrimaryMatchedPfos, nPrimaryMatchedTBPfos, nPrimaryMatchedCRPfos;
137  IntVector bestMatchPfoId, bestMatchPfoPdg, bestMatchPfoIsTB;
138  IntVector bestMatchPfoNHitsTotal, bestMatchPfoNHitsU, bestMatchPfoNHitsV, bestMatchPfoNHitsW;
139  IntVector bestMatchPfoNSharedHitsTotal, bestMatchPfoNSharedHitsU, bestMatchPfoNSharedHitsV, bestMatchPfoNSharedHitsW;
140  FloatVector bestMatchPfoX0;
141 
142  std::stringstream targetSS;
143 
144  for (const MCParticle *const pMCPrimary : mcPrimaryVector)
145  {
146  const bool hasMatch(mcToPfoHitSharingMap.count(pMCPrimary) && !mcToPfoHitSharingMap.at(pMCPrimary).empty());
147  const bool isTargetPrimary(validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary));
148 
149  if (!isTargetPrimary && !hasMatch)
150  continue;
151 
152  associatedMCPrimaries.push_back(pMCPrimary);
153  ++mcPrimaryIndex;
154  const CaloHitList &mcPrimaryHitList(validationInfo.GetAllMCParticleToHitsMap().at(pMCPrimary));
155 
156  const int mcNuanceCode(LArMCParticleHelper::GetNuanceCode(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)));
157  const int isBeamParticle(LArMCParticleHelper::IsBeamParticle(pMCPrimary));
158  const int isCosmicRay(LArMCParticleHelper::IsCosmicRay(pMCPrimary));
159 #ifdef MONITORING
160  const int nTargetPrimaries(associatedMCPrimaries.size());
161  const CartesianVector &targetVertex(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)->GetVertex());
162  const float targetVertexX(targetVertex.GetX()), targetVertexY(targetVertex.GetY()), targetVertexZ(targetVertex.GetZ());
163 #endif
164 
165  targetSS << (!isTargetPrimary ? "(Non target) " : "") << "PrimaryId " << mcPrimaryIndex << ", TB " << isBeamParticle << ", CR "
166  << isCosmicRay << ", MCPDG " << pMCPrimary->GetParticleId() << ", Energy " << pMCPrimary->GetEnergy() << ", Dist. "
167  << (pMCPrimary->GetEndpoint() - pMCPrimary->GetVertex()).GetMagnitude() << ", nMCHits " << mcPrimaryHitList.size() << " ("
168  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList) << ", "
169  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList) << ", "
170  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList) << ")" << std::endl;
171 
172  mcPrimaryId.push_back(mcPrimaryIndex);
173  mcPrimaryPdg.push_back(pMCPrimary->GetParticleId());
174  mcPrimaryE.push_back(pMCPrimary->GetEnergy());
175  mcPrimaryPX.push_back(pMCPrimary->GetMomentum().GetX());
176  mcPrimaryPY.push_back(pMCPrimary->GetMomentum().GetY());
177  mcPrimaryPZ.push_back(pMCPrimary->GetMomentum().GetZ());
178  mcPrimaryVtxX.push_back(pMCPrimary->GetVertex().GetX());
179  mcPrimaryVtxY.push_back(pMCPrimary->GetVertex().GetY());
180  mcPrimaryVtxZ.push_back(pMCPrimary->GetVertex().GetZ());
181  mcPrimaryEndX.push_back(pMCPrimary->GetEndpoint().GetX());
182  mcPrimaryEndY.push_back(pMCPrimary->GetEndpoint().GetY());
183  mcPrimaryEndZ.push_back(pMCPrimary->GetEndpoint().GetZ());
184  nMCHitsTotal.push_back(mcPrimaryHitList.size());
185  nMCHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList));
186  nMCHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList));
187  nMCHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList));
188 
189  int matchIndex(0), nPrimaryMatches(0), nPrimaryTBMatches(0), nPrimaryCRMatches(0);
190 #ifdef MONITORING
191  float recoVertexX(std::numeric_limits<float>::max()), recoVertexY(std::numeric_limits<float>::max()),
192  recoVertexZ(std::numeric_limits<float>::max());
193 #endif
194  for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : mcToPfoHitSharingMap.at(pMCPrimary))
195  {
196  const CaloHitList &sharedHitList(pfoToSharedHits.second);
197  const CaloHitList &pfoHitList(validationInfo.GetPfoToHitsMap().at(pfoToSharedHits.first));
198 
199  const bool isRecoTestBeam(LArPfoHelper::IsTestBeam(pfoToSharedHits.first));
200  const bool isGoodMatch(this->IsGoodMatch(mcPrimaryHitList, pfoHitList, sharedHitList));
201 
202  const int pfoId(pfoToIdMap.at(pfoToSharedHits.first));
203 
204  if (0 == matchIndex++)
205  {
206  bestMatchPfoId.push_back(pfoId);
207  bestMatchPfoPdg.push_back(pfoToSharedHits.first->GetParticleId());
208  bestMatchPfoIsTB.push_back(isRecoTestBeam ? 1 : 0);
209  bestMatchPfoNHitsTotal.push_back(pfoHitList.size());
210  bestMatchPfoNHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList));
211  bestMatchPfoNHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList));
212  bestMatchPfoNHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList));
213  bestMatchPfoNSharedHitsTotal.push_back(sharedHitList.size());
214  bestMatchPfoNSharedHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList));
215  bestMatchPfoNSharedHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList));
216  bestMatchPfoNSharedHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList));
217  bestMatchPfoX0.push_back(pfoToSharedHits.first->GetPropertiesMap().count("X0") ? pfoToSharedHits.first->GetPropertiesMap().at("X0")
218  : std::numeric_limits<float>::max());
219 #ifdef MONITORING
220  try
221  {
222  const Vertex *const pRecoVertex(isRecoTestBeam ? LArPfoHelper::GetTestBeamInteractionVertex(pfoToSharedHits.first)
223  : LArPfoHelper::GetVertex(pfoToSharedHits.first));
224  recoVertexX = pRecoVertex->GetPosition().GetX();
225  recoVertexY = pRecoVertex->GetPosition().GetY();
226  recoVertexZ = pRecoVertex->GetPosition().GetZ();
227  }
228  catch (const StatusCodeException &)
229  {
230  }
231 #endif
232  }
233 
234  if (isGoodMatch)
235  ++nPrimaryMatches;
236 
237  if (isRecoTestBeam && isGoodMatch)
238  ++nPrimaryTBMatches;
239  if (!isRecoTestBeam && isGoodMatch)
240  ++nPrimaryCRMatches;
241 
242  targetSS << "-" << (!isGoodMatch ? "(Below threshold) " : "") << "MatchedPfoId " << pfoId << ", TB " << isRecoTestBeam
243  << ", CR " << (!isRecoTestBeam) << ", PDG " << pfoToSharedHits.first->GetParticleId() << ", nMatchedHits "
244  << sharedHitList.size() << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList) << ", "
245  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList) << ", "
246  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList) << ")"
247  << ", nPfoHits " << pfoHitList.size() << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList) << ", "
248  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList) << ", "
249  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList) << ")" << std::endl;
250  }
251 
252  if (mcToPfoHitSharingMap.at(pMCPrimary).empty())
253  {
254  targetSS << "-No matched Pfo" << std::endl;
255  bestMatchPfoId.push_back(-1);
256  bestMatchPfoPdg.push_back(0);
257  bestMatchPfoIsTB.push_back(0);
258  bestMatchPfoNHitsTotal.push_back(0);
259  bestMatchPfoNHitsU.push_back(0);
260  bestMatchPfoNHitsV.push_back(0);
261  bestMatchPfoNHitsW.push_back(0);
262  bestMatchPfoNSharedHitsTotal.push_back(0);
263  bestMatchPfoNSharedHitsU.push_back(0);
264  bestMatchPfoNSharedHitsV.push_back(0);
265  bestMatchPfoNSharedHitsW.push_back(0);
266  bestMatchPfoX0.push_back(std::numeric_limits<float>::max());
267  }
268 
269  nPrimaryMatchedPfos.push_back(nPrimaryMatches);
270  nPrimaryMatchedTBPfos.push_back(nPrimaryTBMatches);
271  nPrimaryMatchedCRPfos.push_back(nPrimaryCRMatches);
272  nTargetMatches += nPrimaryMatches;
273  nTargetTBMatches += nPrimaryTBMatches;
274  nTargetCRMatches += nPrimaryCRMatches;
275 
276  if (fillTree)
277  {
278  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "fileIdentifier", m_fileIdentifier));
279  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "eventNumber", eventNumber));
280  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcNuanceCode", mcNuanceCode));
281  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isBeamParticle", isBeamParticle));
282  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCosmicRay", isCosmicRay));
283  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetPrimaries", nTargetPrimaries));
284  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexX", targetVertexX));
285  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexY", targetVertexY));
286  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexZ", targetVertexZ));
287  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexX", recoVertexX));
288  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexY", recoVertexY));
289  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexZ", recoVertexZ));
290  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryId", &mcPrimaryId));
291  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPdg", &mcPrimaryPdg));
292  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryE", &mcPrimaryE));
293  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPX", &mcPrimaryPX));
294  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPY", &mcPrimaryPY));
295  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPZ", &mcPrimaryPZ));
296  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxX", &mcPrimaryVtxX));
297  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxY", &mcPrimaryVtxY));
298  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxZ", &mcPrimaryVtxZ));
299  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndX", &mcPrimaryEndX));
300  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndY", &mcPrimaryEndY));
301  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndZ", &mcPrimaryEndZ));
302  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsTotal", &nMCHitsTotal));
303  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsU", &nMCHitsU));
304  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsV", &nMCHitsV));
305  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsW", &nMCHitsW));
306  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedPfos", &nPrimaryMatchedPfos));
307  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedTBPfos", &nPrimaryMatchedTBPfos));
308  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedCRPfos", &nPrimaryMatchedCRPfos));
309  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoId", &bestMatchPfoId));
310  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoPdg", &bestMatchPfoPdg));
311  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsTotal", &bestMatchPfoNHitsTotal));
312  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsU", &bestMatchPfoNHitsU));
313  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsV", &bestMatchPfoNHitsV));
314  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsW", &bestMatchPfoNHitsW));
315  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsTotal", &bestMatchPfoNSharedHitsTotal));
316  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsU", &bestMatchPfoNSharedHitsU));
317  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsV", &bestMatchPfoNSharedHitsV));
318  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsW", &bestMatchPfoNSharedHitsW));
319  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoX0", &bestMatchPfoX0));
320  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetMatches", nTargetMatches));
321  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetTBMatches", nTargetTBMatches));
322  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetCRMatches", nTargetCRMatches));
323  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoIsTB", &bestMatchPfoIsTB));
324  }
325 
326  if (isBeamParticle || isCosmicRay)
327  {
328  const LArInteractionTypeHelper::InteractionType interactionType(LArInteractionTypeHelper::GetInteractionType(associatedMCPrimaries));
329 #ifdef MONITORING
330  const int interactionTypeInt(static_cast<int>(interactionType));
331 #endif
332  // ATTN Some redundancy introduced to contributing variables
333  const int isCorrectTB(isBeamParticle && (nTargetTBMatches == 1) && (nTargetCRMatches == 0));
334  const int isCorrectCR(isCosmicRay && (nTargetTBMatches == 0) && (nTargetCRMatches == 1));
335  const int isFakeTB(isCosmicRay && (nTargetTBMatches > 0));
336  const int isFakeCR(!isCosmicRay && (nTargetCRMatches > 0));
337  const int isSplitTB(!isCosmicRay && (nTargetTBMatches > 1));
338  const int isSplitCR(isCosmicRay && (nTargetCRMatches > 1));
339  const int isLost(nTargetMatches == 0);
340 
341  std::stringstream outcomeSS;
342  outcomeSS << LArInteractionTypeHelper::ToString(interactionType) << " (Nuance " << mcNuanceCode << ", TB " << isBeamParticle
343  << ", CR " << isCosmicRay << ")" << std::endl;
344 
345  if (isBeamParticle)
346  ++nTotalTB;
347  if (isCosmicRay)
348  ++nTotalCR;
349  if (isCorrectTB)
350  ++nCorrectTB;
351  if (isCorrectCR)
352  ++nCorrectCR;
353  if (isFakeTB)
354  ++nFakeTB;
355  if (isFakeCR)
356  ++nFakeCR;
357  if (isSplitTB)
358  ++nSplitTB;
359  if (isSplitCR)
360  ++nSplitCR;
361  if (isLost)
362  ++nLost;
363 
364  if (isCorrectTB)
365  outcomeSS << "IsCorrectTB ";
366  if (isCorrectCR)
367  outcomeSS << "IsCorrectCR ";
368  if (isFakeTB)
369  outcomeSS << "IsFakeTB ";
370  if (isFakeCR)
371  outcomeSS << "IsFakeCR ";
372  if (isSplitTB)
373  outcomeSS << "isSplitTB ";
374  if (isSplitCR)
375  outcomeSS << "IsSplitCR ";
376  if (isLost)
377  outcomeSS << "IsLost ";
378  if (nTargetTBMatches > 0)
379  outcomeSS << "(NTBMatches: " << nTargetTBMatches << ") ";
380  if (nTargetCRMatches > 0)
381  outcomeSS << "(NCRMatches: " << nTargetCRMatches << ") ";
382  if (printToScreen)
383  std::cout << outcomeSS.str() << std::endl << targetSS.str() << std::endl;
384 
385  if (fillTree)
386  {
387  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "interactionType", interactionTypeInt));
388  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectTB", isCorrectTB));
389  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectCR", isCorrectCR));
390  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeTB", isFakeTB));
391  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeCR", isFakeCR));
392  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitTB", isSplitTB));
393  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitCR", isSplitCR));
394  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isLost", isLost));
395  PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treeName.c_str()));
396  }
397 
398  targetSS.str(std::string());
399  targetSS.clear();
400  associatedMCPrimaries.clear();
401  nTargetMatches = 0;
402  nTargetTBMatches = 0;
403  nTargetCRMatches = 0;
404  mcPrimaryId.clear();
405  mcPrimaryPdg.clear();
406  nMCHitsTotal.clear();
407  nMCHitsU.clear();
408  nMCHitsV.clear();
409  nMCHitsW.clear();
410  mcPrimaryE.clear();
411  mcPrimaryPX.clear();
412  mcPrimaryPY.clear();
413  mcPrimaryPZ.clear();
414  mcPrimaryVtxX.clear();
415  mcPrimaryVtxY.clear();
416  mcPrimaryVtxZ.clear();
417  mcPrimaryEndX.clear();
418  mcPrimaryEndY.clear();
419  mcPrimaryEndZ.clear();
420  nPrimaryMatchedPfos.clear();
421  nPrimaryMatchedTBPfos.clear();
422  nPrimaryMatchedCRPfos.clear();
423  bestMatchPfoId.clear();
424  bestMatchPfoPdg.clear();
425  bestMatchPfoIsTB.clear();
426  bestMatchPfoNHitsTotal.clear();
427  bestMatchPfoNHitsU.clear();
428  bestMatchPfoNHitsV.clear();
429  bestMatchPfoNHitsW.clear();
430  bestMatchPfoNSharedHitsTotal.clear();
431  bestMatchPfoNSharedHitsU.clear();
432  bestMatchPfoNSharedHitsV.clear();
433  bestMatchPfoNSharedHitsW.clear();
434  bestMatchPfoX0.clear();
435  }
436  }
437 
438  if (useInterpretedMatching)
439  {
440  std::stringstream summarySS;
441  summarySS << "---SUMMARY--------------------------------------------------------------------------------------" << std::endl;
442  if (nTotalTB > 0)
443  summarySS << "#CorrectTB: " << nCorrectTB << "/" << nTotalTB
444  << ", Fraction: " << (nTotalTB > 0 ? static_cast<float>(nCorrectTB) / static_cast<float>(nTotalTB) : 0.f) << std::endl;
445  if (nTotalCR > 0)
446  summarySS << "#CorrectCR: " << nCorrectCR << "/" << nTotalCR
447  << ", Fraction: " << (nTotalCR > 0 ? static_cast<float>(nCorrectCR) / static_cast<float>(nTotalCR) : 0.f) << std::endl;
448  if (nFakeTB > 0)
449  summarySS << "#FakeTB: " << nFakeTB << " ";
450  if (nFakeCR > 0)
451  summarySS << "#FakeCR: " << nFakeCR << " ";
452  if (nSplitTB > 0)
453  summarySS << "#SplitTB: " << nSplitTB << " ";
454  if (nSplitCR > 0)
455  summarySS << "#SplitCR: " << nSplitCR << " ";
456  if (nLost > 0)
457  summarySS << "#Lost: " << nLost << " ";
458  if (nFakeTB || nFakeCR || nSplitTB || nSplitCR || nLost)
459  summarySS << std::endl;
460  if (printToScreen)
461  std::cout << summarySS.str();
462  }
463 
464  if (printToScreen)
465  std::cout << "------------------------------------------------------------------------------------------------" << std::endl
466  << std::endl;
467 }
468 
469 //------------------------------------------------------------------------------------------------------------------------------------------
470 
471 StatusCode TestBeamEventValidationAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)
472 {
473  return EventValidationBaseAlgorithm::ReadSettings(xmlHandle);
474 }
475 
476 } // namespace lar_content
lar_content::TestBeamEventValidationAlgorithm::PfoToIdMap
std::unordered_map< const pandora::ParticleFlowObject *, unsigned int > PfoToIdMap
Definition: TestBeamEventValidationAlgorithm.h:54
lar_content
Definition: CheatingBeamParticleIdTool.cc:18
lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetPfoToHitsMap
const LArMCParticleHelper::PfoContributionMap & GetPfoToHitsMap() const
Get the pfo to hits map.
Definition: EventValidationBaseAlgorithm.h:255
LArPfoHelper.h
Header file for the pfo helper class.
lar_content::EventValidationBaseAlgorithm::ValidationInfo
ValidationInfo class.
Definition: EventValidationBaseAlgorithm.h:44
lar_content::LArMCParticleHelper::MCContributionMap
std::unordered_map< const pandora::MCParticle *, pandora::CaloHitList > MCContributionMap
Definition: LArMCParticleHelper.h:35
lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetTargetMCParticleToHitsMap
const LArMCParticleHelper::MCContributionMap & GetTargetMCParticleToHitsMap() const
Get the target mc particle to hits map.
Definition: EventValidationBaseAlgorithm.h:248
LArInteractionTypeHelper.h
Header file for the interaction type helper class.
lar_content::LArMCParticleHelper::PrimaryParameters::m_minPrimaryGoodHits
unsigned int m_minPrimaryGoodHits
the minimum number of primary good Hits
Definition: LArMCParticleHelper.h:63
lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetAllMCParticleToHitsMap
const LArMCParticleHelper::MCContributionMap & GetAllMCParticleToHitsMap() const
Get the all mc particle to hits map.
Definition: EventValidationBaseAlgorithm.h:241
lar_content::LArMCParticleHelper::MCParticleToPfoHitSharingMap
std::map< const pandora::MCParticle *, PfoToSharedHitsVector > MCParticleToPfoHitSharingMap
Definition: LArMCParticleHelper.h:50
lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetMCToPfoHitSharingMap
const LArMCParticleHelper::MCParticleToPfoHitSharingMap & GetMCToPfoHitSharingMap() const
Get the mc to pfo hit sharing map.
Definition: EventValidationBaseAlgorithm.h:262
lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetInterpretedMCToPfoHitSharingMap
void SetInterpretedMCToPfoHitSharingMap(const LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap)
Set the interpreted mc to pfo hit sharing map.
Definition: EventValidationBaseAlgorithm.h:304
pandora::IntVector
std::vector< int > IntVector
Definition: LArPandoraHelper.h:27
LArMonitoringHelper.h
Header file for the lar monitoring helper helper class.
lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetMCToPfoHitSharingMap
void SetMCToPfoHitSharingMap(const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap)
Set the mc to pfo hit sharing map.
Definition: EventValidationBaseAlgorithm.h:297
lar_content::LArMCParticleHelper::PrimaryParameters::m_minHitsForGoodView
unsigned int m_minHitsForGoodView
the minimum number of Hits for a good view
Definition: LArMCParticleHelper.h:64
lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetTargetMCParticleToHitsMap
void SetTargetMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &targetMCParticleToHitsMap)
Set the target mc particle to hits map.
Definition: EventValidationBaseAlgorithm.h:283
lar_content::LArMCParticleHelper::MCParticleIntMap
std::unordered_map< const pandora::MCParticle *, int > MCParticleIntMap
Definition: LArMCParticleHelper.h:28
lar_pandora::MCParticleVector
std::vector< art::Ptr< simb::MCParticle > > MCParticleVector
Definition: LArPandoraHelper.h:69
lar_content::EventValidationBaseAlgorithm::ValidationInfo::GetInterpretedMCToPfoHitSharingMap
const LArMCParticleHelper::MCParticleToPfoHitSharingMap & GetInterpretedMCToPfoHitSharingMap() const
Get the interpreted mc to pfo hit sharing map.
Definition: EventValidationBaseAlgorithm.h:269
lar_content::LArMCParticleHelper::PrimaryParameters::m_minHitSharingFraction
float m_minHitSharingFraction
the minimum Hit sharing fraction
Definition: LArMCParticleHelper.h:68
lar_content::LArInteractionTypeHelper::InteractionType
InteractionType
InteractionType enum.
Definition: LArInteractionTypeHelper.h:247
lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetAllMCParticleToHitsMap
void SetAllMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &allMCParticleToHitsMap)
Set the all mc particle to hits map.
Definition: EventValidationBaseAlgorithm.h:276
lar_content::LArMCParticleHelper::PfoCaloHitListPair
std::pair< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoCaloHitListPair
Definition: LArMCParticleHelper.h:43
lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetPfoToHitsMap
void SetPfoToHitsMap(const LArMCParticleHelper::PfoContributionMap &pfoToHitsMap)
Set the pfo to hits map.
Definition: EventValidationBaseAlgorithm.h:290
TestBeamEventValidationAlgorithm.h
Header file for the test beam event validation algorithm.
art::detail::Vertex
boost::graph_traits< ModuleGraph >::vertex_descriptor Vertex
Definition: ModuleGraph.h:25
lar_content::LArMCParticleHelper::PfoContributionMap
std::unordered_map< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoContributionMap
Definition: LArMCParticleHelper.h:39
lar_content::LArMCParticleHelper::PfoToMCParticleHitSharingMap
std::map< const pandora::ParticleFlowObject *, MCParticleToSharedHitsVector > PfoToMCParticleHitSharingMap
Definition: LArMCParticleHelper.h:49
lar_content::LArMCParticleHelper::PrimaryParameters
PrimaryParameters class.
Definition: LArMCParticleHelper.h:55