LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
MvaPfoCharacterisationAlgorithm.cc
Go to the documentation of this file.
1 
9 #include "Pandora/AlgorithmHeaders.h"
10 
13 
15 
17 
18 using namespace pandora;
19 
20 namespace lar_content
21 {
22 
23 template <typename T>
25  m_persistFeatures(false),
26  m_trainingSetMode(false),
27  m_testBeamMode(false),
28  m_enableProbability(true),
29  m_useThreeDInformation(true),
30  m_minProbabilityCut(0.5f),
31  m_minCaloHitsCut(5),
32  m_applyFiducialCut(false),
33  m_fiducialMinX(-std::numeric_limits<float>::max()),
34  m_fiducialMaxX(std::numeric_limits<float>::max()),
35  m_fiducialMinY(-std::numeric_limits<float>::max()),
36  m_fiducialMaxY(std::numeric_limits<float>::max()),
37  m_fiducialMinZ(-std::numeric_limits<float>::max()),
38  m_fiducialMaxZ(std::numeric_limits<float>::max()),
39  m_applyReconstructabilityChecks(false),
40  m_filePathEnvironmentVariable("FW_SEARCH_PATH")
41 {
42 }
43 
44 //------------------------------------------------------------------------------------------------------------------------------------------
45 
46 template <typename T>
47 bool MvaPfoCharacterisationAlgorithm<T>::IsClearTrack(const Cluster *const pCluster) const
48 {
49  if (pCluster->GetNCaloHits() < m_minCaloHitsCut)
50  return false;
51 
52  StringVector featureOrder;
54 
56  {
57  bool isTrueTrack(false);
58 
59  try
60  {
61  const MCParticle *const pMCParticle(MCParticleHelper::GetMainMCParticle(pCluster));
62  isTrueTrack = ((PHOTON != pMCParticle->GetParticleId()) && (E_MINUS != std::abs(pMCParticle->GetParticleId())));
63  }
64  catch (const StatusCodeException &)
65  {
66  }
67 
68  LArMvaHelper::ProduceTrainingExample(m_trainingOutputFile, isTrueTrack, featureOrder, featureMap);
69  return isTrueTrack;
70  }
71 
73  {
74  return LArMvaHelper::Classify(m_mva, featureOrder, featureMap);
75  }
76  else
77  {
78  return (LArMvaHelper::CalculateProbability(m_mva, featureOrder, featureMap) > m_minProbabilityCut);
79  }
80 }
81 
82 //------------------------------------------------------------------------------------------------------------------------------------------
83 
84 template <typename T>
85 bool MvaPfoCharacterisationAlgorithm<T>::IsClearTrack(const pandora::ParticleFlowObject *const pPfo) const
86 {
87  if (!LArPfoHelper::IsThreeD(pPfo))
88  {
90  {
91  object_creation::ParticleFlowObject::Metadata metadata;
92  metadata.m_propertiesToAdd["TrackScore"] = -1.f;
93  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
94  }
95  return (pPfo->GetParticleId() == MU_MINUS);
96  }
97 
98  // Charge related features are only calculated using hits in W view
99  ClusterList wClusterList;
100  LArPfoHelper::GetClusters(pPfo, TPC_VIEW_W, wClusterList);
101 
102  const PfoCharacterisationFeatureTool::FeatureToolMap &chosenFeatureToolMap(wClusterList.empty() ? m_featureToolMapNoChargeInfo : m_featureToolMapThreeD);
103  const StringVector chosenFeatureToolOrder(wClusterList.empty() ? m_algorithmToolNamesNoChargeInfo : m_algorithmToolNames);
104  StringVector featureOrder;
105  const LArMvaHelper::MvaFeatureMap featureMap(
106  LArMvaHelper::CalculateFeatures(chosenFeatureToolOrder, chosenFeatureToolMap, featureOrder, this, pPfo));
107 
108  for (auto const &[featureKey, featureValue] : featureMap)
109  {
110  (void)featureKey;
111 
112  if (!featureValue.IsInitialized())
113  {
115  {
116  object_creation::ParticleFlowObject::Metadata metadata;
117  metadata.m_propertiesToAdd["TrackScore"] = -1.f;
118  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
119  }
120  return (pPfo->GetParticleId() == MU_MINUS);
121  }
122  }
123 
125  {
126  const MCParticleList *pMCParticleList(nullptr);
127  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));
128 
129  const CaloHitList *pCaloHitList(nullptr);
130  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pCaloHitList));
131 
132  // Mapping target MCParticles -> truth associated Hits
133  LArMCParticleHelper::MCContributionMap targetMCParticleToHitsMap;
134  if (!m_testBeamMode)
136  LArMCParticleHelper::IsBeamNeutrinoFinalState, targetMCParticleToHitsMap);
137  else
139  pMCParticleList, pCaloHitList, m_primaryParameters, LArMCParticleHelper::IsBeamParticle, targetMCParticleToHitsMap);
140 
141  LArMCParticleHelper::MCContributionMapVector mcParticlesToGoodHitsMaps({targetMCParticleToHitsMap});
142 
143  LArMCParticleHelper::PfoContributionMap pfoToReconstructable2DHitsMap;
145  PfoList(1, pPfo), mcParticlesToGoodHitsMaps, pfoToReconstructable2DHitsMap, m_primaryParameters.m_foldBackHierarchy);
146  if (pfoToReconstructable2DHitsMap.empty())
147  return false;
148 
149  LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCParticleHitSharingMap;
150  LArMCParticleHelper::MCParticleToPfoHitSharingMap mcParticleToPfoHitSharingMap;
152  pfoToReconstructable2DHitsMap, mcParticlesToGoodHitsMaps, pfoToMCParticleHitSharingMap, mcParticleToPfoHitSharingMap);
153  if (pfoToMCParticleHitSharingMap.empty())
154  return false;
155 
156  unsigned int nHitsInBestMCParticleTotal(0);
157  unsigned int nHitsSharedWithBestMCParticleTotal(0);
158  int bestMCParticlePdgCode(0);
159  CartesianVector threeDVertexPosition(0.f, 0.f, 0.f);
160  float hitsShower(0), hitsTrack(0);
161  const LArMCParticleHelper::MCParticleToSharedHitsVector &mcParticleToSharedHitsVector(pfoToMCParticleHitSharingMap.at(pPfo));
162 
163  for (const LArMCParticleHelper::MCParticleCaloHitListPair &mcParticleCaloHitListPair : mcParticleToSharedHitsVector)
164  {
165  const pandora::MCParticle *const pAssociatedMCParticle(mcParticleCaloHitListPair.first);
166  const CaloHitList &allMCHits(targetMCParticleToHitsMap.at(pAssociatedMCParticle));
167  const CaloHitList &associatedMCHits(mcParticleCaloHitListPair.second);
168 
169  if ((PHOTON == pAssociatedMCParticle->GetParticleId()) || (E_MINUS == std::abs(pAssociatedMCParticle->GetParticleId())))
170  hitsShower += associatedMCHits.size();
171  else
172  hitsTrack += associatedMCHits.size();
173 
174  if (associatedMCHits.size() > nHitsSharedWithBestMCParticleTotal)
175  {
176  nHitsSharedWithBestMCParticleTotal = associatedMCHits.size();
177  nHitsInBestMCParticleTotal = allMCHits.size();
178  bestMCParticlePdgCode = pAssociatedMCParticle->GetParticleId();
179  threeDVertexPosition = pAssociatedMCParticle->GetVertex();
180  }
181  }
182 
183  const float trackShowerHitsRatio((hitsTrack + hitsShower) > 0 ? hitsTrack / (hitsTrack + hitsShower) : 0.f);
184  const bool isTrueTrack(trackShowerHitsRatio >= 0.5);
185 
186  const int nHitsInPfoTotal(pfoToReconstructable2DHitsMap.at(pPfo).size());
187  const float purity((nHitsInPfoTotal > 0) ? nHitsSharedWithBestMCParticleTotal / static_cast<float>(nHitsInPfoTotal) : 0.f);
188  const float completeness(
189  (nHitsInBestMCParticleTotal > 0) ? nHitsSharedWithBestMCParticleTotal / static_cast<float>(nHitsInBestMCParticleTotal) : 0.f);
190 
191  CaloHitList checkHitListW;
192  LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_W, checkHitListW);
193  CaloHitList checkHitListU;
194  LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_U, checkHitListU);
195  CaloHitList checkHitListV;
196  LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_V, checkHitListV);
197  CaloHitList checkHitListAll;
198  checkHitListAll.splice(checkHitListAll.end(), checkHitListW);
199  checkHitListAll.splice(checkHitListAll.end(), checkHitListU);
200  checkHitListAll.splice(checkHitListAll.end(), checkHitListV);
201 
203  LArMCParticleHelper::GetMCPrimaryMap(pMCParticleList, mcPrimaryMap);
204 
205  LArMCParticleHelper::MCContributionMap mcToTrueHitListMap;
207  LArMCParticleHelper::GetMCParticleToCaloHitMatches(&checkHitListAll, mcPrimaryMap, hitToMCMap, mcToTrueHitListMap);
208 
209  unsigned int showerCount(0), allCount(0);
210  for (const CaloHit *pHit : checkHitListAll)
211  {
212  if (hitToMCMap.find(pHit) != hitToMCMap.end())
213  {
214  const MCParticle *pHitMCParticle(hitToMCMap.at(pHit));
215  if ((PHOTON == pHitMCParticle->GetParticleId()) || (E_MINUS == std::abs(pHitMCParticle->GetParticleId())))
216  ++showerCount;
217  ++allCount;
218  }
219  }
220 
221  if (allCount == 0)
222  return false;
223  const float showerProbability(showerCount / static_cast<float>(allCount));
224  const bool mischaracterisedPfo((showerProbability < 0.5f && !isTrueTrack) || (showerProbability > 0.5 && isTrueTrack) ? true : false);
225  const bool isMainMCParticleSet(bestMCParticlePdgCode != 0);
226 
227  if (isMainMCParticleSet)
228  {
229  if (completeness >= 0.f && purity >= 0.f && !mischaracterisedPfo && (!m_applyFiducialCut || this->PassesFiducialCut(threeDVertexPosition)))
230  {
231  std::string outputFile(m_trainingOutputFile);
232  const std::string end = ((wClusterList.empty()) ? "noChargeInfo.txt" : ".txt");
233  outputFile.append(end);
234  LArMvaHelper::ProduceTrainingExample(outputFile, isTrueTrack, featureOrder, featureMap);
235  }
236  }
237 
238  return isTrueTrack;
239  }
240  else if (m_trainingSetMode)
241  {
242  bool isTrueTrack(false);
243  bool isMainMCParticleSet(false);
244 
245  try
246  {
247  const MCParticle *const pMCParticle(LArMCParticleHelper::GetMainMCParticle(pPfo));
248  isTrueTrack = ((PHOTON != pMCParticle->GetParticleId()) && (E_MINUS != std::abs(pMCParticle->GetParticleId())));
249  isMainMCParticleSet = (pMCParticle->GetParticleId() != 0);
250  }
251  catch (const StatusCodeException &)
252  {
253  }
254 
255  if (isMainMCParticleSet)
256  {
257  std::string outputFile(m_trainingOutputFile);
258  outputFile.append(wClusterList.empty() ? "noChargeInfo.txt" : ".txt");
259  LArMvaHelper::ProduceTrainingExample(outputFile, isTrueTrack, featureOrder, featureMap);
260  }
261 
262  return isTrueTrack;
263  }
264 
265  // If no failures, proceed with MvaPfoCharacterisationAlgorithm classification
266  if (!m_enableProbability)
267  {
268  return LArMvaHelper::Classify((wClusterList.empty() ? m_mvaNoChargeInfo : m_mva), featureOrder, featureMap);
269  }
270  else
271  {
272  const double score(LArMvaHelper::CalculateProbability((wClusterList.empty() ? m_mvaNoChargeInfo : m_mva), featureOrder, featureMap));
273  object_creation::ParticleFlowObject::Metadata metadata;
274  metadata.m_propertiesToAdd["TrackScore"] = score;
275  if (m_persistFeatures)
276  {
277  for (auto const &[name, value] : featureMap)
278  {
279  metadata.m_propertiesToAdd[name] = value.Get();
280  }
281  }
282  PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
283  return (m_minProbabilityCut <= score);
284  }
285 }
286 
287 //------------------------------------------------------------------------------------------------------------------------------------------
288 
289 template <typename T>
290 StatusCode MvaPfoCharacterisationAlgorithm<T>::ReadSettings(const TiXmlHandle xmlHandle)
291 {
292  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
293  XmlHelper::ReadValue(xmlHandle, "MinPrimaryGoodHits", m_primaryParameters.m_minPrimaryGoodHits));
294 
295  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
296  XmlHelper::ReadValue(xmlHandle, "MinHitsForGoodView", m_primaryParameters.m_minHitsForGoodView));
297 
298  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
299  XmlHelper::ReadValue(xmlHandle, "MinPrimaryGoodViews", m_primaryParameters.m_minPrimaryGoodViews));
300 
301  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
302  XmlHelper::ReadValue(xmlHandle, "SelectInputHits", m_primaryParameters.m_selectInputHits));
303 
304  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
305  XmlHelper::ReadValue(xmlHandle, "MinHitSharingFraction", m_primaryParameters.m_minHitSharingFraction));
306 
307  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
308  XmlHelper::ReadValue(xmlHandle, "MaxPhotonPropagation", m_primaryParameters.m_maxPhotonPropagation));
309 
310  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
311  XmlHelper::ReadValue(xmlHandle, "FoldToPrimaries", m_primaryParameters.m_foldBackHierarchy));
312 
313  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PersistFeatures", m_persistFeatures));
314 
315  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingSetMode", m_trainingSetMode));
316 
317  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCaloHitsCut", m_minCaloHitsCut));
318 
319  PANDORA_RETURN_RESULT_IF_AND_IF(
320  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UseThreeDInformation", m_useThreeDInformation));
321 
322  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
323  XmlHelper::ReadValue(xmlHandle, "FilePathEnvironmentVariable", m_filePathEnvironmentVariable));
324 
325  // ATTN Support legacy XML configurations (note an order of precedence of XML keys exists)
326  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BdtFileName", m_mvaFileName));
327  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SvmFileName", m_mvaFileName));
328  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MvaFileName", m_mvaFileName));
329 
330  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BdtName", m_mvaName));
331  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SvmName", m_mvaName));
332  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MvaName", m_mvaName));
333 
335  {
336  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
337  XmlHelper::ReadValue(xmlHandle, "BdtFileNameNoChargeInfo", m_mvaFileNameNoChargeInfo));
338  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
339  XmlHelper::ReadValue(xmlHandle, "SvmFileNameNoChargeInfo", m_mvaFileNameNoChargeInfo));
340  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
341  XmlHelper::ReadValue(xmlHandle, "MvaFileNameNoChargeInfo", m_mvaFileNameNoChargeInfo));
342 
343  PANDORA_RETURN_RESULT_IF_AND_IF(
344  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BdtNameNoChargeInfo", m_mvaNameNoChargeInfo));
345  PANDORA_RETURN_RESULT_IF_AND_IF(
346  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SvmNameNoChargeInfo", m_mvaNameNoChargeInfo));
347  PANDORA_RETURN_RESULT_IF_AND_IF(
348  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MvaNameNoChargeInfo", m_mvaNameNoChargeInfo));
349  }
350 
351  PANDORA_RETURN_RESULT_IF_AND_IF(
352  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EnableProbability", m_enableProbability));
353 
354  PANDORA_RETURN_RESULT_IF_AND_IF(
355  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinProbabilityCut", m_minProbabilityCut));
356 
357  if (m_trainingSetMode)
358  {
359  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListName", m_caloHitListName));
360  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MCParticleListName", m_mcParticleListName));
361  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrainingOutputFileName", m_trainingOutputFile));
362  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TestBeamMode", m_testBeamMode));
363  PANDORA_RETURN_RESULT_IF_AND_IF(
364  STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ApplyFiducialCut", m_applyFiducialCut));
365  if (m_applyFiducialCut)
366  {
367  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMinX", m_fiducialMinX));
368  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMaxX", m_fiducialMaxX));
369  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMinY", m_fiducialMinY));
370  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMaxY", m_fiducialMaxY));
371  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMinZ", m_fiducialMinZ));
372  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FiducialCutMaxZ", m_fiducialMaxZ));
373  }
374  PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
375  XmlHelper::ReadValue(xmlHandle, "ApplyReconstructabilityChecks", m_applyReconstructabilityChecks));
376  }
377  else
378  {
379  if (m_mvaFileName.empty() || m_mvaName.empty())
380  {
381  std::cout << "MvaPfoCharacterisationAlgorithm: MvaFileName and MvaName must be set if in classification mode " << std::endl;
382  return STATUS_CODE_INVALID_PARAMETER;
383  }
384 
386  m_mva.Initialize(fullMvaFileName, m_mvaName);
387 
389  {
390  if (m_mvaFileNameNoChargeInfo.empty() || m_mvaNameNoChargeInfo.empty())
391  {
392  std::cout << "MvaPfoCharacterisationAlgorithm: MvaFileNameNoChargeInfo and MvaNameNoChargeInfo must be set if in classification mode for no charge info in 3D mode "
393  << std::endl;
394  return STATUS_CODE_INVALID_PARAMETER;
395  }
396  const std::string fullMvaFileNameNoChargeInfo(LArFileHelper::FindFileInPath(m_mvaFileNameNoChargeInfo, m_filePathEnvironmentVariable));
397  m_mvaNoChargeInfo.Initialize(fullMvaFileNameNoChargeInfo, m_mvaNameNoChargeInfo);
398  }
399  }
400 
401  LArMvaHelper::AlgorithmToolMap algorithmToolMap;
402  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
403  LArMvaHelper::ProcessAlgorithmToolListToMap(*this, xmlHandle, "FeatureTools", m_algorithmToolNames, algorithmToolMap));
404 
406  {
407  // and the map for NoChargeInfo
408  LArMvaHelper::AlgorithmToolMap algorithmToolMapNoChargeInfo;
409  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
411  *this, xmlHandle, "FeatureToolsNoChargeInfo", m_algorithmToolNamesNoChargeInfo, algorithmToolMapNoChargeInfo));
412 
413  for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMap)
414  PANDORA_RETURN_RESULT_IF(
415  STATUS_CODE_SUCCESS, !=, LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMapThreeD));
416 
417  for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMapNoChargeInfo)
418  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
419  LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMapNoChargeInfo));
420  }
421  else
422  {
423  for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMap)
424  PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMap));
425  }
426 
428 }
429 
430 //------------------------------------------------------------------------------------------------------------------------------------------
431 
432 template <typename T>
434 {
435  const float vx(vertex.GetX()), vy(vertex.GetY()), vz(vertex.GetZ());
436  return m_fiducialMinX <= vx && vx <= m_fiducialMaxX && m_fiducialMinY <= vy && vy <= m_fiducialMaxY && m_fiducialMinZ <= vz && vz <= m_fiducialMaxZ;
437 }
438 
439 //------------------------------------------------------------------------------------------------------------------------------------------
440 
443 
444 } // namespace lar_content
Header file for the mva pfo characterisation algorithm class.
bool m_enableProbability
Whether to use probabilities instead of binary classification.
std::string m_trainingOutputFile
The training output file.
static bool Classify(const MvaInterface &classifier, TCONTAINER &&featureContainer)
Use the trained classifier to predict the boolean class of an example.
Definition: LArMvaHelper.h:331
pandora::StringVector m_algorithmToolNamesNoChargeInfo
Vector of strings saving feature tool order for use in feature calculation (missing W view) ...
unsigned int m_minPrimaryGoodViews
the minimum number of primary good views
static bool IsThreeD(const pandora::ParticleFlowObject *const pPfo)
Does Pfo contain 3D clusters.
Header file for the pfo helper class.
std::unordered_map< const pandora::MCParticle *, pandora::CaloHitList > MCContributionMap
std::string m_caloHitListName
Name of input calo hit list.
std::map< std::string, pandora::AlgorithmTool * > AlgorithmToolMap
Definition: LArMvaHelper.h:79
bool m_selectInputHits
whether to select input hits
std::pair< const pandora::MCParticle *, pandora::CaloHitList > MCParticleCaloHitListPair
LArMCParticleHelper::PrimaryParameters m_primaryParameters
The mc particle primary selection parameters.
static void GetClusters(const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::ClusterList &clusterList)
Get a list of clusters of a particular hit type from a list of pfos.
static pandora::StatusCode ProduceTrainingExample(const std::string &trainingOutputFile, const bool result, TCONTAINER &&featureContainer)
Produce a training example with the given features and result.
Definition: LArMvaHelper.h:285
std::string m_mcParticleListName
Name of input MC particle list.
unsigned int m_minCaloHitsCut
The minimum number of calo hits to qualify as a track.
bool m_testBeamMode
Whether the training set is from a test beam experiment.
unsigned int m_minPrimaryGoodHits
the minimum number of primary good Hits
ClusterCharacterisationFeatureTool::FeatureToolMap m_featureToolMap
The feature tool map.
static void GetPfoToReconstructable2DHitsMap(const pandora::PfoList &pfoList, const MCContributionMap &selectedMCParticleToHitsMap, PfoContributionMap &pfoToReconstructable2DHitsMap, const bool foldBackHierarchy)
Get mapping from Pfo to reconstructable 2D hits (=good hits belonging to a selected reconstructable M...
PfoCharacterisationFeatureTool::FeatureToolMap m_featureToolMapNoChargeInfo
FeatureToolMap as a map for missing W view.
std::unordered_map< const pandora::CaloHit *, const pandora::MCParticle * > CaloHitToMCMap
constexpr auto abs(T v)
Returns the absolute value of the argument.
bool m_applyReconstructabilityChecks
Whether to apply reconstructability checks during training.
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...
STL namespace.
std::map< const pandora::MCParticle *, PfoToSharedHitsVector > MCParticleToPfoHitSharingMap
bool m_applyFiducialCut
Whether to apply a fiducial volume cut during training.
bool m_foldBackHierarchy
whether to fold the hierarchy back to the primary (neutrino) or leading particles (test beam) ...
static void GetMCPrimaryMap(const pandora::MCParticleList *const pMCParticleList, MCRelationMap &mcPrimaryMap)
Get mapping from individual mc particles (in a provided list) and their primary parent mc particles...
MvaTypes::MvaFeatureMap MvaFeatureMap
Definition: LArMvaHelper.h:78
static const pandora::MCParticle * GetMainMCParticle(const pandora::ParticleFlowObject *const pPfo)
Find the mc particle making the largest contribution to 2D clusters in a specified pfo...
unsigned int m_minHitsForGoodView
the minimum number of Hits for a good view
float m_maxPhotonPropagation
the maximum photon propagation length
std::map< std::string, MvaFeatureTool< Ts... > * > FeatureToolMap
Definition: LArMvaHelper.h:37
TFile f
Definition: plotHisto.C:6
decltype(auto) constexpr end(T &&obj)
ADL-aware version of std::end.
Definition: StdUtils.h:77
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.
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
static void GetMCParticleToCaloHitMatches(const pandora::CaloHitList *const pCaloHitList, const MCRelationMap &mcToTargetMCMap, CaloHitToMCMap &hitToMCMap, MCContributionMap &mcToTrueHitListMap)
Match calo hits to their parent particles.
static bool IsBeamParticle(const pandora::MCParticle *const pMCParticle)
Returns true if passed a primary beam MCParticle.
std::string m_mvaNameNoChargeInfo
The name of the mva to find for PFOs missing the W view, and thus charge info.
Header file for the lar two dimensional sliding fit result class.
bool PassesFiducialCut(const pandora::CartesianVector &vertex) const
Checks if the interaction vertex is within the fiducial volume.
std::string m_mvaName
The name of the mva to find.
static std::string FindFileInPath(const std::string &unqualifiedFileName, const std::string &environmentVariable, const std::string &delimiter=":")
Find the fully-qualified file name by searching through a list of delimiter-separated paths in a name...
Header file for the file helper class.
float m_minHitSharingFraction
the minimum Hit sharing fraction
double value
Definition: spectrum.C:18
std::vector< MCContributionMap > MCContributionMapVector
static pandora::StatusCode ProcessAlgorithmToolListToMap(const pandora::Algorithm &algorithm, const pandora::TiXmlHandle &xmlHandle, const std::string &listName, pandora::StringVector &algorithToolNameVector, AlgorithmToolMap &algorithmToolMap)
Process a list of algorithms tools in an xml file, using a map. Idea is for this to go to XmlHelper i...
Definition: LArMvaHelper.cc:16
float m_minProbabilityCut
The minimum probability to label a cluster as track-like.
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
std::string m_mvaFileNameNoChargeInfo
The mva input file for PFOs missing the W view, and thus charge info.
virtual bool IsClearTrack(const pandora::ParticleFlowObject *const pPfo) const
Whether pfo is identified as a clear track.
PfoCharacterisationFeatureTool::FeatureToolMap m_featureToolMapThreeD
FeatureToolMap as a map for 3D info.
static MvaFeatureVector CalculateFeatures(const MvaFeatureToolVector< Ts... > &featureToolVector, TARGS &&...args)
Calculate the features in a given feature tool vector.
Definition: LArMvaHelper.h:399
std::vector< MCParticleCaloHitListPair > MCParticleToSharedHitsVector
std::string m_filePathEnvironmentVariable
The environment variable providing a list of paths to mva files.
static double CalculateProbability(const MvaInterface &classifier, TCONTAINER &&featureContainer)
Use the trained mva to calculate a classification probability for an example.
Definition: LArMvaHelper.h:369
pandora::StringVector m_algorithmToolNames
Vector of strings saving feature tool order for use in feature calculation.
std::unordered_map< const pandora::ParticleFlowObject *, pandora::CaloHitList > PfoContributionMap
static void GetCaloHits(const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::CaloHitList &caloHitList)
Get a list of calo hits of a particular hit type from a list of pfos.
static bool IsBeamNeutrinoFinalState(const pandora::MCParticle *const pMCParticle)
Returns true if passed a primary neutrino final state MCParticle.
std::unordered_map< const pandora::MCParticle *, const pandora::MCParticle * > MCRelationMap
bool m_persistFeatures
Whether to write the features to the properties map.
std::map< const pandora::ParticleFlowObject *, MCParticleToSharedHitsVector > PfoToMCParticleHitSharingMap
bool m_useThreeDInformation
Whether to use 3D information.
static pandora::StatusCode AddFeatureToolToMap(pandora::AlgorithmTool *const pFeatureTool, std::string pFeatureToolName, MvaFeatureToolMap< Ts... > &featureToolMap)
Add a feature tool to a map of feature tools.
Definition: LArMvaHelper.h:465
vertex reconstruction