All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TestBeamEventValidationAlgorithm.cc
Go to the documentation of this file.
1 /**
2  * @file larpandoracontent/LArMonitoring/TestBeamEventValidationAlgorithm.cc
3  *
4  * @brief Implementation of the test beam event validation algorithm.
5  *
6  * $Log: $
7  */
8 
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  if (printToScreen && useInterpretedMatching)
97  std::cout << "---INTERPRETED-MATCHING-OUTPUT------------------------------------------------------------------" << std::endl;
98  else if (printToScreen)
99  std::cout << "---RAW-MATCHING-OUTPUT--------------------------------------------------------------------------" << std::endl;
100 
101  const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap(
102  useInterpretedMatching ? validationInfo.GetInterpretedMCToPfoHitSharingMap() : validationInfo.GetMCToPfoHitSharingMap());
103 
104  MCParticleVector mcPrimaryVector;
105  LArMonitoringHelper::GetOrderedMCParticleVector({validationInfo.GetTargetMCParticleToHitsMap()}, mcPrimaryVector);
106 
107  // Test Beam Validation Bookkeeping
108  PfoVector primaryPfoVector;
109  LArMonitoringHelper::GetOrderedPfoVector(validationInfo.GetPfoToHitsMap(), primaryPfoVector);
110 
111  int pfoIndex(0), testBeamPfoIndex(0);
112  PfoToIdMap pfoToIdMap, testBeamPfoToIdMap;
113 
114  for (const Pfo *const pPrimaryPfo : primaryPfoVector)
115  {
116  pfoToIdMap.insert(PfoToIdMap::value_type(pPrimaryPfo, ++pfoIndex));
117  const Pfo *const pRecoTestBeam(LArPfoHelper::IsTestBeamFinalState(pPrimaryPfo) ? LArPfoHelper::GetParentPfo(pPrimaryPfo) : nullptr);
118 
119  if (pRecoTestBeam && !testBeamPfoToIdMap.count(pRecoTestBeam))
120  testBeamPfoToIdMap.insert(PfoToIdMap::value_type(pRecoTestBeam, ++testBeamPfoIndex));
121  }
122 
123  LArMCParticleHelper::MCParticleIntMap triggeredToLeading, triggeredToLeadingCounter;
124 
125  MCParticleList associatedMCPrimaries;
126 
127  int nCorrectTB(0), nTotalTB(0), nCorrectCR(0), nTotalCR(0), nFakeTB(0), nFakeCR(0), nSplitTB(0), nSplitCR(0), nLost(0);
128  int mcPrimaryIndex(0), nTargetMatches(0), nTargetTBMatches(0), nTargetCRMatches(0), nTargetGoodTBMatches(0);
129  IntVector mcPrimaryId, mcPrimaryPdg, nMCHitsTotal, nMCHitsU, nMCHitsV, nMCHitsW;
130  FloatVector mcPrimaryE, mcPrimaryPX, mcPrimaryPY, mcPrimaryPZ;
131  FloatVector mcPrimaryVtxX, mcPrimaryVtxY, mcPrimaryVtxZ, mcPrimaryEndX, mcPrimaryEndY, mcPrimaryEndZ;
132  IntVector nPrimaryMatchedPfos, nPrimaryMatchedTBPfos, nPrimaryMatchedCRPfos;
133  IntVector bestMatchPfoId, bestMatchPfoPdg, bestMatchPfoIsTB;
134  IntVector bestMatchPfoNHitsTotal, bestMatchPfoNHitsU, bestMatchPfoNHitsV, bestMatchPfoNHitsW;
135  IntVector bestMatchPfoNSharedHitsTotal, bestMatchPfoNSharedHitsU, bestMatchPfoNSharedHitsV, bestMatchPfoNSharedHitsW;
136  FloatVector bestMatchPfoX0;
137 
138  std::stringstream targetSS;
139 
140  for (const MCParticle *const pMCPrimary : mcPrimaryVector)
141  {
142  const bool hasMatch(mcToPfoHitSharingMap.count(pMCPrimary) && !mcToPfoHitSharingMap.at(pMCPrimary).empty());
143  const bool isTargetPrimary(validationInfo.GetTargetMCParticleToHitsMap().count(pMCPrimary));
144 
145  if (!isTargetPrimary && !hasMatch)
146  continue;
147 
148  associatedMCPrimaries.push_back(pMCPrimary);
149  ++mcPrimaryIndex;
150  const CaloHitList &mcPrimaryHitList(validationInfo.GetAllMCParticleToHitsMap().at(pMCPrimary));
151 
152  const int mcNuanceCode(LArMCParticleHelper::GetNuanceCode(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)));
153  const int isBeamParticle(LArMCParticleHelper::IsBeamParticle(pMCPrimary));
154  const int isCosmicRay(LArMCParticleHelper::IsCosmicRay(pMCPrimary));
155 #ifdef MONITORING
156  const int nTargetPrimaries(associatedMCPrimaries.size());
157  const CartesianVector &targetVertex(LArMCParticleHelper::GetParentMCParticle(pMCPrimary)->GetVertex());
158  const float targetVertexX(targetVertex.GetX()), targetVertexY(targetVertex.GetY()), targetVertexZ(targetVertex.GetZ());
159 #endif
160 
161  targetSS << (!isTargetPrimary ? "(Non target) " : "") << "PrimaryId " << mcPrimaryIndex << ", TB " << isBeamParticle << ", CR "
162  << isCosmicRay << ", MCPDG " << pMCPrimary->GetParticleId() << ", Energy " << pMCPrimary->GetEnergy() << ", Dist. "
163  << (pMCPrimary->GetEndpoint() - pMCPrimary->GetVertex()).GetMagnitude() << ", nMCHits " << mcPrimaryHitList.size() << " ("
164  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList) << ", "
165  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList) << ", "
166  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList) << ")" << std::endl;
167 
168  mcPrimaryId.push_back(mcPrimaryIndex);
169  mcPrimaryPdg.push_back(pMCPrimary->GetParticleId());
170  mcPrimaryE.push_back(pMCPrimary->GetEnergy());
171  mcPrimaryPX.push_back(pMCPrimary->GetMomentum().GetX());
172  mcPrimaryPY.push_back(pMCPrimary->GetMomentum().GetY());
173  mcPrimaryPZ.push_back(pMCPrimary->GetMomentum().GetZ());
174  mcPrimaryVtxX.push_back(pMCPrimary->GetVertex().GetX());
175  mcPrimaryVtxY.push_back(pMCPrimary->GetVertex().GetY());
176  mcPrimaryVtxZ.push_back(pMCPrimary->GetVertex().GetZ());
177  mcPrimaryEndX.push_back(pMCPrimary->GetEndpoint().GetX());
178  mcPrimaryEndY.push_back(pMCPrimary->GetEndpoint().GetY());
179  mcPrimaryEndZ.push_back(pMCPrimary->GetEndpoint().GetZ());
180  nMCHitsTotal.push_back(mcPrimaryHitList.size());
181  nMCHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, mcPrimaryHitList));
182  nMCHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, mcPrimaryHitList));
183  nMCHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, mcPrimaryHitList));
184 
185  int matchIndex(0), nPrimaryMatches(0), nPrimaryTBMatches(0), nPrimaryCRMatches(0), nPrimaryGoodNuMatches(0);
186 #ifdef MONITORING
187  float recoVertexX(std::numeric_limits<float>::max()), recoVertexY(std::numeric_limits<float>::max()),
188  recoVertexZ(std::numeric_limits<float>::max());
189 #endif
190  for (const LArMCParticleHelper::PfoCaloHitListPair &pfoToSharedHits : mcToPfoHitSharingMap.at(pMCPrimary))
191  {
192  const CaloHitList &sharedHitList(pfoToSharedHits.second);
193  const CaloHitList &pfoHitList(validationInfo.GetPfoToHitsMap().at(pfoToSharedHits.first));
194 
195  const bool isRecoTestBeam(LArPfoHelper::IsTestBeam(pfoToSharedHits.first));
196  const bool isGoodMatch(this->IsGoodMatch(mcPrimaryHitList, pfoHitList, sharedHitList));
197 
198  const int pfoId(pfoToIdMap.at(pfoToSharedHits.first));
199 
200  if (0 == matchIndex++)
201  {
202  bestMatchPfoId.push_back(pfoId);
203  bestMatchPfoPdg.push_back(pfoToSharedHits.first->GetParticleId());
204  bestMatchPfoIsTB.push_back(isRecoTestBeam ? 1 : 0);
205  bestMatchPfoNHitsTotal.push_back(pfoHitList.size());
206  bestMatchPfoNHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList));
207  bestMatchPfoNHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList));
208  bestMatchPfoNHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList));
209  bestMatchPfoNSharedHitsTotal.push_back(sharedHitList.size());
210  bestMatchPfoNSharedHitsU.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList));
211  bestMatchPfoNSharedHitsV.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList));
212  bestMatchPfoNSharedHitsW.push_back(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList));
213  bestMatchPfoX0.push_back(pfoToSharedHits.first->GetPropertiesMap().count("X0") ? pfoToSharedHits.first->GetPropertiesMap().at("X0")
214  : std::numeric_limits<float>::max());
215 #ifdef MONITORING
216  try
217  {
218  const Vertex *const pRecoVertex(isRecoTestBeam ? LArPfoHelper::GetTestBeamInteractionVertex(pfoToSharedHits.first)
219  : LArPfoHelper::GetVertex(pfoToSharedHits.first));
220  recoVertexX = pRecoVertex->GetPosition().GetX();
221  recoVertexY = pRecoVertex->GetPosition().GetY();
222  recoVertexZ = pRecoVertex->GetPosition().GetZ();
223  }
224  catch (const StatusCodeException &)
225  {
226  }
227 #endif
228  }
229 
230  if (isGoodMatch)
231  ++nPrimaryMatches;
232 
233  if (isRecoTestBeam && isGoodMatch)
234  ++nPrimaryTBMatches;
235  if (!isRecoTestBeam && isGoodMatch)
236  ++nPrimaryCRMatches;
237 
238  targetSS << "-" << (!isGoodMatch ? "(Below threshold) " : "") << "MatchedPfoId " << pfoId << ", TB " << isRecoTestBeam
239  << ", CR " << (!isRecoTestBeam) << ", PDG " << pfoToSharedHits.first->GetParticleId() << ", nMatchedHits "
240  << sharedHitList.size() << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, sharedHitList) << ", "
241  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, sharedHitList) << ", "
242  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, sharedHitList) << ")"
243  << ", nPfoHits " << pfoHitList.size() << " (" << LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, pfoHitList) << ", "
244  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, pfoHitList) << ", "
245  << LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, pfoHitList) << ")" << std::endl;
246  }
247 
248  if (mcToPfoHitSharingMap.at(pMCPrimary).empty())
249  {
250  targetSS << "-No matched Pfo" << std::endl;
251  bestMatchPfoId.push_back(-1);
252  bestMatchPfoPdg.push_back(0);
253  bestMatchPfoIsTB.push_back(0);
254  bestMatchPfoNHitsTotal.push_back(0);
255  bestMatchPfoNHitsU.push_back(0);
256  bestMatchPfoNHitsV.push_back(0);
257  bestMatchPfoNHitsW.push_back(0);
258  bestMatchPfoNSharedHitsTotal.push_back(0);
259  bestMatchPfoNSharedHitsU.push_back(0);
260  bestMatchPfoNSharedHitsV.push_back(0);
261  bestMatchPfoNSharedHitsW.push_back(0);
262  bestMatchPfoX0.push_back(std::numeric_limits<float>::max());
263  }
264 
265  nPrimaryMatchedPfos.push_back(nPrimaryMatches);
266  nPrimaryMatchedTBPfos.push_back(nPrimaryTBMatches);
267  nPrimaryMatchedCRPfos.push_back(nPrimaryCRMatches);
268  nTargetMatches += nPrimaryMatches;
269  nTargetTBMatches += nPrimaryTBMatches;
270  nTargetCRMatches += nPrimaryCRMatches;
271  nTargetGoodTBMatches += nPrimaryGoodNuMatches;
272 
273  if (fillTree)
274  {
275  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "fileIdentifier", m_fileIdentifier));
276  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "eventNumber", m_eventNumber - 1));
277  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcNuanceCode", mcNuanceCode));
278  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isBeamParticle", isBeamParticle));
279  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCosmicRay", isCosmicRay));
280  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetPrimaries", nTargetPrimaries));
281  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexX", targetVertexX));
282  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexY", targetVertexY));
283  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "targetVertexZ", targetVertexZ));
284  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexX", recoVertexX));
285  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexY", recoVertexY));
286  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "recoVertexZ", recoVertexZ));
287  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryId", &mcPrimaryId));
288  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPdg", &mcPrimaryPdg));
289  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryE", &mcPrimaryE));
290  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPX", &mcPrimaryPX));
291  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPY", &mcPrimaryPY));
292  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryPZ", &mcPrimaryPZ));
293  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxX", &mcPrimaryVtxX));
294  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxY", &mcPrimaryVtxY));
295  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryVtxZ", &mcPrimaryVtxZ));
296  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndX", &mcPrimaryEndX));
297  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndY", &mcPrimaryEndY));
298  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryEndZ", &mcPrimaryEndZ));
299  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsTotal", &nMCHitsTotal));
300  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsU", &nMCHitsU));
301  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsV", &nMCHitsV));
302  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "mcPrimaryNHitsW", &nMCHitsW));
303  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedPfos", &nPrimaryMatchedPfos));
304  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedTBPfos", &nPrimaryMatchedTBPfos));
305  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nPrimaryMatchedCRPfos", &nPrimaryMatchedCRPfos));
306  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoId", &bestMatchPfoId));
307  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoPdg", &bestMatchPfoPdg));
308  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsTotal", &bestMatchPfoNHitsTotal));
309  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsU", &bestMatchPfoNHitsU));
310  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsV", &bestMatchPfoNHitsV));
311  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNHitsW", &bestMatchPfoNHitsW));
312  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsTotal", &bestMatchPfoNSharedHitsTotal));
313  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsU", &bestMatchPfoNSharedHitsU));
314  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsV", &bestMatchPfoNSharedHitsV));
315  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoNSharedHitsW", &bestMatchPfoNSharedHitsW));
316  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoX0", &bestMatchPfoX0));
317  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetMatches", nTargetMatches));
318  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetTBMatches", nTargetTBMatches));
319  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "nTargetCRMatches", nTargetCRMatches));
320  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "bestMatchPfoIsTB", &bestMatchPfoIsTB));
321  }
322 
323  if (isBeamParticle || isCosmicRay)
324  {
325  const LArInteractionTypeHelper::InteractionType interactionType(LArInteractionTypeHelper::GetInteractionType(associatedMCPrimaries));
326 #ifdef MONITORING
327  const int interactionTypeInt(static_cast<int>(interactionType));
328 #endif
329  // ATTN Some redundancy introduced to contributing variables
330  const int isCorrectTB(isBeamParticle && (nTargetTBMatches == 1) && (nTargetCRMatches == 0));
331  const int isCorrectCR(isCosmicRay && (nTargetTBMatches == 0) && (nTargetCRMatches == 1));
332  const int isFakeTB(isCosmicRay && (nTargetTBMatches > 0));
333  const int isFakeCR(!isCosmicRay && (nTargetCRMatches > 0));
334  const int isSplitTB(!isCosmicRay && (nTargetTBMatches > 1));
335  const int isSplitCR(isCosmicRay && (nTargetCRMatches > 1));
336  const int isLost(nTargetMatches == 0);
337 
338  std::stringstream outcomeSS;
339  outcomeSS << LArInteractionTypeHelper::ToString(interactionType) << " (Nuance " << mcNuanceCode << ", TB " << isBeamParticle
340  << ", CR " << isCosmicRay << ")" << std::endl;
341 
342  if (isBeamParticle)
343  ++nTotalTB;
344  if (isCosmicRay)
345  ++nTotalCR;
346  if (isCorrectTB)
347  ++nCorrectTB;
348  if (isCorrectCR)
349  ++nCorrectCR;
350  if (isFakeTB)
351  ++nFakeTB;
352  if (isFakeCR)
353  ++nFakeCR;
354  if (isSplitTB)
355  ++nSplitTB;
356  if (isSplitCR)
357  ++nSplitCR;
358  if (isLost)
359  ++nLost;
360 
361  if (isCorrectTB)
362  outcomeSS << "IsCorrectTB ";
363  if (isCorrectCR)
364  outcomeSS << "IsCorrectCR ";
365  if (isFakeTB)
366  outcomeSS << "IsFakeTB ";
367  if (isFakeCR)
368  outcomeSS << "IsFakeCR ";
369  if (isSplitTB)
370  outcomeSS << "isSplitTB ";
371  if (isSplitCR)
372  outcomeSS << "IsSplitCR ";
373  if (isLost)
374  outcomeSS << "IsLost ";
375  if (nTargetTBMatches > 0)
376  outcomeSS << "(NTBMatches: " << nTargetTBMatches << ") ";
377  if (nTargetCRMatches > 0)
378  outcomeSS << "(NCRMatches: " << nTargetCRMatches << ") ";
379  if (printToScreen)
380  std::cout << outcomeSS.str() << std::endl << targetSS.str() << std::endl;
381 
382  if (fillTree)
383  {
384  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "interactionType", interactionTypeInt));
385  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectTB", isCorrectTB));
386  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isCorrectCR", isCorrectCR));
387  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeTB", isFakeTB));
388  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isFakeCR", isFakeCR));
389  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitTB", isSplitTB));
390  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isSplitCR", isSplitCR));
391  PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treeName.c_str(), "isLost", isLost));
392  PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treeName.c_str()));
393  }
394 
395  targetSS.str(std::string());
396  targetSS.clear();
397  associatedMCPrimaries.clear();
398  nTargetMatches = 0;
399  nTargetTBMatches = 0;
400  nTargetCRMatches = 0;
401  nTargetGoodTBMatches = 0;
402  mcPrimaryId.clear();
403  mcPrimaryPdg.clear();
404  nMCHitsTotal.clear();
405  nMCHitsU.clear();
406  nMCHitsV.clear();
407  nMCHitsW.clear();
408  mcPrimaryE.clear();
409  mcPrimaryPX.clear();
410  mcPrimaryPY.clear();
411  mcPrimaryPZ.clear();
412  mcPrimaryVtxX.clear();
413  mcPrimaryVtxY.clear();
414  mcPrimaryVtxZ.clear();
415  mcPrimaryEndX.clear();
416  mcPrimaryEndY.clear();
417  mcPrimaryEndZ.clear();
418  nPrimaryMatchedPfos.clear();
419  nPrimaryMatchedTBPfos.clear();
420  nPrimaryMatchedCRPfos.clear();
421  bestMatchPfoId.clear();
422  bestMatchPfoPdg.clear();
423  bestMatchPfoIsTB.clear();
424  bestMatchPfoNHitsTotal.clear();
425  bestMatchPfoNHitsU.clear();
426  bestMatchPfoNHitsV.clear();
427  bestMatchPfoNHitsW.clear();
428  bestMatchPfoNSharedHitsTotal.clear();
429  bestMatchPfoNSharedHitsU.clear();
430  bestMatchPfoNSharedHitsV.clear();
431  bestMatchPfoNSharedHitsW.clear();
432  bestMatchPfoX0.clear();
433  }
434  }
435 
436  if (useInterpretedMatching)
437  {
438  std::stringstream summarySS;
439  summarySS << "---SUMMARY--------------------------------------------------------------------------------------" << std::endl;
440  if (nTotalTB > 0)
441  summarySS << "#CorrectTB: " << nCorrectTB << "/" << nTotalTB
442  << ", Fraction: " << (nTotalTB > 0 ? static_cast<float>(nCorrectTB) / static_cast<float>(nTotalTB) : 0.f) << std::endl;
443  if (nTotalCR > 0)
444  summarySS << "#CorrectCR: " << nCorrectCR << "/" << nTotalCR
445  << ", Fraction: " << (nTotalCR > 0 ? static_cast<float>(nCorrectCR) / static_cast<float>(nTotalCR) : 0.f) << std::endl;
446  if (nFakeTB > 0)
447  summarySS << "#FakeTB: " << nFakeTB << " ";
448  if (nFakeCR > 0)
449  summarySS << "#FakeCR: " << nFakeCR << " ";
450  if (nSplitTB > 0)
451  summarySS << "#SplitTB: " << nSplitTB << " ";
452  if (nSplitCR > 0)
453  summarySS << "#SplitCR: " << nSplitCR << " ";
454  if (nLost > 0)
455  summarySS << "#Lost: " << nLost << " ";
456  if (nFakeTB || nFakeCR || nSplitTB || nSplitCR || nLost)
457  summarySS << std::endl;
458  if (printToScreen)
459  std::cout << summarySS.str();
460  }
461 
462  if (printToScreen)
463  std::cout << "------------------------------------------------------------------------------------------------" << std::endl
464  << std::endl;
465 }
466 
467 //------------------------------------------------------------------------------------------------------------------------------------------
468 
469 StatusCode TestBeamEventValidationAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)
470 {
471  return EventValidationBaseAlgorithm::ReadSettings(xmlHandle);
472 }
473 
474 } // namespace lar_content
lar_content::TestBeamEventValidationAlgorithm::PfoToIdMap
std::unordered_map< const pandora::ParticleFlowObject *, unsigned int > PfoToIdMap
Definition: TestBeamEventValidationAlgorithm.h:54
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:25
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:67
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:245
lar_content::EventValidationBaseAlgorithm::ValidationInfo::SetAllMCParticleToHitsMap
void SetAllMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &allMCParticleToHitsMap)
Set the all mc particle to hits map.
Definition: EventValidationBaseAlgorithm.h:276
pandora
required by fuzzyCluster table::sbnd_g4_services gaushitTruthMatch pandora
Definition: reco_sbnd.fcl:182
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.
flashmatch::parser::ToString
std::string ToString(const T &value)
Parse flashmatch::PSet configuration file content.
Definition: Parser.h:66
lar_content::LArMCParticleHelper::PfoContributionMap
std::unordered_map< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoContributionMap
Definition: LArMCParticleHelper.h:39
cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10
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
Generated by   doxygen 1.8.5