9 #include "Api/PandoraApi.h" 11 #include "Pandora/AlgorithmHeaders.h" 35 MasterAlgorithm::MasterAlgorithm() :
36 m_workerInstancesInitialized(false),
37 m_larCaloHitVersion(1),
38 m_shouldRunAllHitsCosmicReco(true),
39 m_shouldRunStitching(true),
40 m_shouldRunCosmicHitRemoval(true),
41 m_shouldRunSlicing(true),
42 m_shouldRunNeutrinoRecoOption(true),
43 m_shouldRunCosmicRecoOption(true),
44 m_shouldPerformSliceId(true),
45 m_printOverallRecoStatus(false),
46 m_visualizeOverallRecoStatus(false),
47 m_shouldRemoveOutOfTimeHits(true),
48 m_pSlicingWorkerInstance(nullptr),
49 m_pSliceNuWorkerInstance(nullptr),
50 m_pSliceCRWorkerInstance(nullptr),
51 m_fullWidthCRWorkerWireGaps(true),
52 m_passMCParticlesToWorkerInstances(false),
53 m_filePathEnvironmentVariable(
"FW_SEARCH_PATH"),
62 if (!pParentPfo->GetParentPfoList().empty())
63 throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
67 if (pfoToLArTPCMap.end() == larTPCIter)
68 throw StatusCodeException(STATUS_CODE_NOT_FOUND);
75 std::cout <<
"ShiftPfoHierarchy: x0 " << x0 << std::endl;
76 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &pfoList,
"BeforeShiftCRPfos", GREEN));
79 for (
const ParticleFlowObject *
const pDaughterPfo : pfoList)
81 CaloHitList caloHitList;
82 for (
const Cluster *
const pCluster : pDaughterPfo->GetClusterList())
84 pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
85 caloHitList.insert(caloHitList.end(), pCluster->GetIsolatedCaloHitList().begin(), pCluster->GetIsolatedCaloHitList().end());
88 for (
const CaloHit *
const pCaloHit : caloHitList)
90 PandoraContentApi::CaloHit::Metadata metadata;
92 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::AlterMetadata(*
this, pCaloHit, metadata));
95 for (
const Vertex *
const pVertex : pDaughterPfo->GetVertexList())
97 PandoraContentApi::Vertex::Metadata metadata;
99 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::AlterMetadata(*
this, pVertex, metadata));
105 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &pfoList,
"AfterShiftCRPfos", RED));
106 PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
113 const ParticleFlowObject *
const pPfoToEnlarge,
const ParticleFlowObject *
const pPfoToDelete,
PfoToLArTPCMap &pfoToLArTPCMap)
const 115 if (pPfoToEnlarge == pPfoToDelete)
116 throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
119 pfoToLArTPCMap.erase(pPfoToEnlarge);
120 pfoToLArTPCMap.erase(pPfoToDelete);
122 const PfoList daughterPfos(pPfoToDelete->GetDaughterPfoList());
123 const ClusterVector daughterClusters(pPfoToDelete->GetClusterList().begin(), pPfoToDelete->GetClusterList().end());
124 const VertexVector daughterVertices(pPfoToDelete->GetVertexList().begin(), pPfoToDelete->GetVertexList().end());
126 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*
this, pPfoToDelete,
m_recreatedPfoListName));
128 for (
const ParticleFlowObject *
const pDaughterPfo : daughterPfos)
129 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*
this, pPfoToEnlarge, pDaughterPfo));
131 for (
const Vertex *
const pDaughterVertex : daughterVertices)
132 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*
this, pDaughterVertex,
m_recreatedVertexListName));
134 for (
const Cluster *
const pDaughterCluster : daughterClusters)
141 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
146 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*
this, pPfoToEnlarge, pDaughterCluster));
155 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
Reset());
161 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
CopyMCParticles());
175 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
StitchCosmicRayPfos(pfoToLArTPCMap, stitchedPfosToX0Map));
180 PfoList clearCosmicRayPfos, ambiguousPfos;
181 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
TagCosmicRayPfos(stitchedPfosToX0Map, clearCosmicRayPfos, ambiguousPfos));
186 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
RunSlicing(volumeIdToHitListMap, sliceVector));
191 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
RunSliceReconstruction(sliceVector, nuSliceHypotheses, crSliceHypotheses));
192 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
SelectBestSliceHypotheses(nuSliceHypotheses, crSliceHypotheses));
195 return STATUS_CODE_SUCCESS;
204 return STATUS_CODE_ALREADY_INITIALIZED;
208 const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
209 const DetectorGapList &gapList(this->GetPandora().GetGeometry()->GetDetectorGapList());
211 for (
const LArTPCMap::value_type &mapEntry : larTPCMap)
213 const unsigned int volumeId(mapEntry.second->GetLArTPCVolumeId());
227 catch (
const StatusCodeException &statusCodeException)
229 std::cout <<
"MasterAlgorithm: Exception during initialization of worker instances " << statusCodeException.ToString() << std::endl;
230 return statusCodeException.GetStatusCode();
234 return STATUS_CODE_SUCCESS;
241 const MCParticleList *pMCParticleList(
nullptr);
242 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*
this,
m_inputMCParticleListName, pMCParticleList));
254 for (
const Pandora *
const pPandoraWorker : pandoraWorkerInstances)
256 for (
const MCParticle *
const pMCParticle : *pMCParticleList)
257 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
Copy(pPandoraWorker, pMCParticle, &mcParticleFactory));
260 return STATUS_CODE_SUCCESS;
267 const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
268 const unsigned int nLArTPCs(larTPCMap.size());
270 const CaloHitList *pCaloHitList(
nullptr);
271 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*
this,
m_inputHitListName, pCaloHitList));
273 for (
const CaloHit *
const pCaloHit : *pCaloHitList)
275 const LArCaloHit *
const pLArCaloHit(dynamic_cast<const LArCaloHit *>(pCaloHit));
277 if (!pLArCaloHit && (1 != nLArTPCs))
278 return STATUS_CODE_INVALID_PARAMETER;
281 const LArTPC *
const pLArTPC(larTPCMap.at(volumeId));
283 LArTPCHitList &larTPCHitList(volumeIdToHitListMap[volumeId]);
284 larTPCHitList.m_allHitList.push_back(pCaloHit);
286 if (((pCaloHit->GetPositionVector().GetX() >= (pLArTPC->GetCenterX() - 0.5f * pLArTPC->GetWidthX())) &&
287 (pCaloHit->GetPositionVector().GetX() <= (pLArTPC->GetCenterX() + 0.5f * pLArTPC->GetWidthX()))))
289 larTPCHitList.m_truncatedHitList.push_back(pCaloHit);
293 return STATUS_CODE_SUCCESS;
300 unsigned int workerCounter(0);
304 const LArTPC &larTPC(pCRWorker->GetGeometry()->GetLArTPC());
307 if (volumeIdToHitListMap.end() == iter)
310 for (
const CaloHit *
const pCaloHit : iter->second.m_allHitList)
311 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
Copy(pCRWorker, pCaloHit));
314 std::cout <<
"Running cosmic-ray reconstruction worker instance " << ++workerCounter <<
" of " << m_crWorkerInstances.size() << std::endl;
319 return STATUS_CODE_SUCCESS;
328 const PfoList *pCRPfos(
nullptr);
329 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*pCRWorker, pCRPfos));
332 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
Recreate(*pCRPfos, newPfoList));
334 const LArTPC &larTPC(pCRWorker->GetGeometry()->GetLArTPC());
336 for (
const Pfo *
const pNewPfo : newPfoList)
337 pfoToLArTPCMap[pNewPfo] = &larTPC;
340 return STATUS_CODE_SUCCESS;
347 const PfoList *pRecreatedCRPfos(
nullptr);
348 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(this->GetPandora(), pRecreatedCRPfos));
352 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), pRecreatedCRPfos,
"RecreatedCRPfos", GREEN));
353 PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
357 pStitchingTool->Run(
this, pRecreatedCRPfos, pfoToLArTPCMap, stitchedPfosToX0Map);
361 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), pRecreatedCRPfos,
"AfterStitchingCRPfos", RED));
362 PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
365 return STATUS_CODE_SUCCESS;
372 const PfoList *pRecreatedCRPfos(
nullptr);
373 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(this->GetPandora(), pRecreatedCRPfos));
375 PfoList nonStitchedParentCosmicRayPfos;
376 for (
const Pfo *
const pPfo : *pRecreatedCRPfos)
378 if (!pPfo->GetParentPfoList().empty())
382 const float x0Shift((pfoToX0Iter != stitchedPfosToX0Map.end()) ? pfoToX0Iter->second : 0.f);
383 PfoList &targetList((std::fabs(x0Shift) >
m_inTimeMaxX0) ? clearCosmicRayPfos : nonStitchedParentCosmicRayPfos);
384 targetList.push_back(pPfo);
388 pCosmicRayTaggingTool->FindAmbiguousPfos(nonStitchedParentCosmicRayPfos, ambiguousPfos,
this);
390 for (
const Pfo *
const pPfo : nonStitchedParentCosmicRayPfos)
392 const bool isClearCosmic(ambiguousPfos.end() == std::find(ambiguousPfos.begin(), ambiguousPfos.end(), pPfo));
395 clearCosmicRayPfos.push_back(pPfo);
398 for (
const Pfo *
const pPfo : *pRecreatedCRPfos)
400 const bool isClearCosmic(ambiguousPfos.end() == std::find(ambiguousPfos.begin(), ambiguousPfos.end(), pPfo));
401 PandoraContentApi::ParticleFlowObject::Metadata metadata;
402 metadata.m_propertiesToAdd[
"IsClearCosmic"] = (isClearCosmic ? 1.f : 0.f);
403 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*
this, pPfo, metadata));
408 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &clearCosmicRayPfos,
"ClearCRPfos", RED));
409 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &ambiguousPfos,
"AmbiguousCRPfos", BLUE));
410 PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
413 return STATUS_CODE_SUCCESS;
420 PfoList allPfosToDelete;
423 for (
const Pfo *
const pPfoToDelete : allPfosToDelete)
425 const ClusterList clusterList(pPfoToDelete->GetClusterList());
426 const VertexList vertexList(pPfoToDelete->GetVertexList());
431 CaloHitList caloHitList2D;
439 for (
const CaloHit *
const pCaloHit : caloHitList2D)
441 PandoraContentApi::CaloHit::Metadata metadata;
443 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::AlterMetadata(*
this, pCaloHit, metadata));
447 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*
this, pPfoToDelete));
448 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*
this, &clusterList));
449 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*
this, &vertexList));
452 return STATUS_CODE_SUCCESS;
459 for (
const VolumeIdToHitListMap::value_type &mapEntry : volumeIdToHitListMap)
461 for (
const CaloHit *
const pCaloHit : (
m_shouldRemoveOutOfTimeHits ? mapEntry.second.m_truncatedHitList : mapEntry.second.m_allHitList))
463 if (!PandoraContentApi::IsAvailable(*
this, pCaloHit))
466 const HitType hitType(pCaloHit->GetHitType());
467 if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
476 if (sliceVector.empty())
477 sliceVector.push_back(CaloHitList());
478 sliceVector.back().push_back(pCaloHit);
486 std::cout <<
"Running slicing worker instance" << std::endl;
488 const PfoList *pSlicePfos(
nullptr);
490 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*
m_pSlicingWorkerInstance, pSlicePfos));
494 PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), pSlicePfos,
"OnePfoPerSlice", BLUE));
495 PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
498 for (
const Pfo *
const pSlicePfo : *pSlicePfos)
500 sliceVector.push_back(CaloHitList());
508 std::cout <<
"Identified " << sliceVector.size() <<
" slice(s)" << std::endl;
510 return STATUS_CODE_SUCCESS;
523 pSliceSelectionTool->SelectSlices(
this, inputSliceVector, selectedSliceVector);
524 inputSliceVector = selectedSliceVector;
529 selectedSliceVector = std::move(sliceVector);
532 unsigned int sliceCounter(0);
534 for (
const CaloHitList &sliceHits : selectedSliceVector)
536 for (
const CaloHit *
const pSliceCaloHit : sliceHits)
539 const CaloHit *
const pCaloHitInMaster(
m_shouldRunSlicing ? static_cast<const CaloHit *>(pSliceCaloHit->GetParentAddress()) : pSliceCaloHit);
551 std::cout <<
"Running nu worker instance for slice " << (sliceCounter + 1) <<
" of " << selectedSliceVector.size() << std::endl;
553 const PfoList *pSliceNuPfos(
nullptr);
555 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*
m_pSliceNuWorkerInstance, pSliceNuPfos));
556 nuSliceHypotheses.push_back(*pSliceNuPfos);
558 for (
const ParticleFlowObject *
const pPfo : *pSliceNuPfos)
560 PandoraContentApi::ParticleFlowObject::Metadata metadata;
561 metadata.m_propertiesToAdd[
"SliceIndex"] = sliceCounter;
562 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*
this, pPfo, metadata));
569 std::cout <<
"Running cr worker instance for slice " << (sliceCounter + 1) <<
" of " << selectedSliceVector.size() << std::endl;
571 const PfoList *pSliceCRPfos(
nullptr);
573 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*
m_pSliceCRWorkerInstance, pSliceCRPfos));
574 crSliceHypotheses.push_back(*pSliceCRPfos);
576 for (
const ParticleFlowObject *
const pPfo : *pSliceCRPfos)
578 PandoraContentApi::ParticleFlowObject::Metadata metadata;
579 metadata.m_propertiesToAdd[
"SliceIndex"] = sliceCounter;
580 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*
this, pPfo, metadata));
590 sliceVector = std::move(selectedSliceVector);
593 throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
595 return STATUS_CODE_SUCCESS;
603 std::cout <<
"Select best slice hypotheses" << std::endl;
605 PfoList selectedSlicePfos;
610 pSliceIdTool->SelectOutputPfos(
this, nuSliceHypotheses, crSliceHypotheses, selectedSlicePfos);
616 for (
const PfoList &slice : sliceHypotheses)
617 selectedSlicePfos.insert(selectedSlicePfos.end(), slice.begin(), slice.end());
620 PfoList newSlicePfoList;
621 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->
Recreate(selectedSlicePfos, newSlicePfoList));
623 return STATUS_CODE_SUCCESS;
631 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
PandoraApi::Reset(*pCRWorker));
642 return STATUS_CODE_SUCCESS;
650 if (pLArCaloHit ==
nullptr)
652 std::cout <<
"MasterAlgorithm: Could not cast CaloHit to LArCaloHit" << std::endl;
653 return STATUS_CODE_INVALID_PARAMETER;
656 pLArCaloHit->FillParameters(parameters);
657 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(*pPandora, parameters,
m_larCaloHitFactory));
662 for (
const auto &weightMapEntry : pLArCaloHit->GetMCParticleWeightMap())
663 mcParticleVector.push_back(weightMapEntry.first);
666 for (
const MCParticle *
const pMCParticle : mcParticleVector)
668 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
669 PandoraApi::SetCaloHitToMCParticleRelationship(*pPandora, pLArCaloHit, pMCParticle, pLArCaloHit->GetMCParticleWeightMap().at(pMCParticle)));
673 return STATUS_CODE_SUCCESS;
684 std::cout <<
"MasterAlgorithm::Copy - Expect to pass only LArMCParticles to Pandora worker instances." << std::endl;
685 return STATUS_CODE_INVALID_PARAMETER;
690 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::MCParticle::Create(*pPandora, parameters, *pMCParticleFactory));
692 for (
const MCParticle *
const pDaughterMCParticle : pMCParticle->GetDaughterList())
693 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::SetMCParentDaughterRelationship(*pPandora, pMCParticle, pDaughterMCParticle));
695 for (
const MCParticle *
const pParentMCParticle : pMCParticle->GetParentList())
696 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::SetMCParentDaughterRelationship(*pPandora, pParentMCParticle, pMCParticle));
698 return STATUS_CODE_SUCCESS;
705 if (inputPfoList.empty())
706 return STATUS_CODE_SUCCESS;
710 std::string clusterListName;
711 const ClusterList *pClusterList(
nullptr);
712 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*
this, pClusterList, clusterListName));
714 std::string vertexListName;
716 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*
this, pVertexList, vertexListName));
718 std::string pfoListName;
719 const PfoList *pPfoList(
nullptr);
720 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*
this, pPfoList, pfoListName));
722 for (
const Pfo *
const pPfo : inputPfoList)
724 if (pPfo->GetParentPfoList().empty())
725 this->
Recreate(pPfo,
nullptr, newPfoList);
728 if (!pClusterList->empty())
731 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*
this,
m_recreatedClusterListName));
734 if (!pVertexList->empty())
736 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*
this,
m_recreatedVertexListName));
737 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Vertex>(*
this,
m_recreatedVertexListName));
740 if (!pPfoList->empty())
742 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<ParticleFlowObject>(*
this,
m_recreatedPfoListName));
743 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<ParticleFlowObject>(*
this,
m_recreatedPfoListName));
746 return STATUS_CODE_SUCCESS;
751 StatusCode
MasterAlgorithm::Recreate(
const ParticleFlowObject *
const pInputPfo,
const ParticleFlowObject *
const pNewParentPfo, PfoList &newPfoList)
const 753 ClusterList inputClusterList2D, inputClusterList3D, newClusterList;
757 for (
const Cluster *
const pInputCluster : inputClusterList2D)
759 CaloHitList inputCaloHitList, newCaloHitList, newIsolatedCaloHitList;
760 pInputCluster->GetOrderedCaloHitList().FillCaloHitList(inputCaloHitList);
762 for (
const CaloHit *
const pInputCaloHit : inputCaloHitList)
763 newCaloHitList.push_back(static_cast<const CaloHit *>(pInputCaloHit->GetParentAddress()));
765 for (
const CaloHit *
const pInputCaloHit : pInputCluster->GetIsolatedCaloHitList())
766 newIsolatedCaloHitList.push_back(static_cast<const CaloHit *>(pInputCaloHit->GetParentAddress()));
768 if (!newCaloHitList.empty())
769 newClusterList.push_back(this->CreateCluster(pInputCluster, newCaloHitList, newIsolatedCaloHitList));
772 for (
const Cluster *
const pInputCluster : inputClusterList3D)
774 CaloHitList inputCaloHitList, newCaloHitList, newIsolatedCaloHitList;
775 pInputCluster->GetOrderedCaloHitList().FillCaloHitList(inputCaloHitList);
777 for (
const CaloHit *
const pInputCaloHit : inputCaloHitList)
779 const CaloHit *
const pWorkerParentCaloHit(static_cast<const CaloHit *>(pInputCaloHit->GetParentAddress()));
780 const CaloHit *
const pMasterParentCaloHit(static_cast<const CaloHit *>(pWorkerParentCaloHit->GetParentAddress()));
781 newCaloHitList.push_back(this->
CreateCaloHit(pInputCaloHit, pMasterParentCaloHit));
784 for (
const CaloHit *
const pInputCaloHit : pInputCluster->GetIsolatedCaloHitList())
786 const CaloHit *
const pWorkerParentCaloHit(static_cast<const CaloHit *>(pInputCaloHit->GetParentAddress()));
787 const CaloHit *
const pMasterParentCaloHit(static_cast<const CaloHit *>(pWorkerParentCaloHit->GetParentAddress()));
788 newIsolatedCaloHitList.push_back(this->
CreateCaloHit(pInputCaloHit, pMasterParentCaloHit));
791 if (!newCaloHitList.empty())
792 newClusterList.push_back(this->CreateCluster(pInputCluster, newCaloHitList, newIsolatedCaloHitList));
797 for (
const Vertex *
const pInputVertex : pInputPfo->GetVertexList())
798 newVertexList.push_back(this->CreateVertex(pInputVertex));
800 const ParticleFlowObject *
const pNewPfo(this->
CreatePfo(pInputPfo, newClusterList, newVertexList));
801 newPfoList.push_back(pNewPfo);
804 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*
this, pNewParentPfo, pNewPfo))
806 for (
const ParticleFlowObject *
const pInputDaughterPfo : pInputPfo->GetDaughterPfoList())
807 this->
Recreate(pInputDaughterPfo, pNewPfo, newPfoList);
809 return STATUS_CODE_SUCCESS;
816 PandoraContentApi::CaloHit::Parameters parameters;
817 parameters.m_positionVector = pInputCaloHit->GetPositionVector();
818 parameters.m_expectedDirection = pInputCaloHit->GetExpectedDirection();
819 parameters.m_cellNormalVector = pInputCaloHit->GetCellNormalVector();
820 parameters.m_cellGeometry = pInputCaloHit->GetCellGeometry();
821 parameters.m_cellSize0 = pInputCaloHit->GetCellSize0();
822 parameters.m_cellSize1 = pInputCaloHit->GetCellSize1();
823 parameters.m_cellThickness = pInputCaloHit->GetCellThickness();
824 parameters.m_nCellRadiationLengths = pInputCaloHit->GetNCellRadiationLengths();
825 parameters.m_nCellInteractionLengths = pInputCaloHit->GetNCellInteractionLengths();
826 parameters.m_time = pInputCaloHit->GetTime();
827 parameters.m_inputEnergy = pInputCaloHit->GetInputEnergy();
828 parameters.m_mipEquivalentEnergy = pInputCaloHit->GetMipEquivalentEnergy();
829 parameters.m_electromagneticEnergy = pInputCaloHit->GetElectromagneticEnergy();
830 parameters.m_hadronicEnergy = pInputCaloHit->GetHadronicEnergy();
831 parameters.m_isDigital = pInputCaloHit->IsDigital();
832 parameters.m_hitType = pInputCaloHit->GetHitType();
833 parameters.m_hitRegion = pInputCaloHit->GetHitRegion();
834 parameters.m_layer = pInputCaloHit->GetLayer();
835 parameters.m_isInOuterSamplingLayer = pInputCaloHit->IsInOuterSamplingLayer();
836 parameters.m_pParentAddress =
static_cast<const void *
>(pParentCaloHit);
838 const CaloHit *pNewCaloHit(
nullptr);
839 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::Create(*
this, parameters, pNewCaloHit));
841 PandoraContentApi::CaloHit::Metadata metadata;
842 metadata.m_isIsolated = pInputCaloHit->IsIsolated();
843 metadata.m_isPossibleMip = pInputCaloHit->IsPossibleMip();
844 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::AlterMetadata(*
this, pNewCaloHit, metadata));
852 const Cluster *
const pInputCluster,
const CaloHitList &newCaloHitList,
const CaloHitList &newIsolatedCaloHitList)
const 854 PandoraContentApi::Cluster::Parameters parameters;
855 parameters.m_caloHitList = newCaloHitList;
856 parameters.m_isolatedCaloHitList = newIsolatedCaloHitList;
858 const Cluster *pNewCluster(
nullptr);
859 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*
this, parameters, pNewCluster));
861 PandoraContentApi::Cluster::Metadata metadata;
862 metadata.m_particleId = pInputCluster->GetParticleId();
863 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::AlterMetadata(*
this, pNewCluster, metadata));
872 PandoraContentApi::Vertex::Parameters parameters;
873 parameters.m_position = pInputVertex->GetPosition();
874 parameters.m_vertexLabel = pInputVertex->GetVertexLabel();
875 parameters.m_vertexType = pInputVertex->GetVertexType();
877 const Vertex *pNewVertex(
nullptr);
878 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*
this, parameters, pNewVertex));
886 const ParticleFlowObject *
const pInputPfo,
const ClusterList &newClusterList,
const VertexList &newVertexList)
const 888 PandoraContentApi::ParticleFlowObject::Parameters parameters;
889 parameters.m_particleId = pInputPfo->GetParticleId();
890 parameters.m_charge = pInputPfo->GetCharge();
891 parameters.m_mass = pInputPfo->GetMass();
892 parameters.m_energy = pInputPfo->GetEnergy();
893 parameters.m_momentum = pInputPfo->GetMomentum();
894 parameters.m_clusterList = newClusterList;
895 parameters.m_trackList.clear();
896 parameters.m_vertexList = newVertexList;
897 parameters.m_propertiesToAdd = pInputPfo->GetPropertiesMap();
899 const ParticleFlowObject *pNewPfo(
nullptr);
900 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*
this, parameters, pNewPfo));
908 const LArTPC &larTPC,
const DetectorGapList &gapList,
const std::string &settingsFile,
const std::string &name)
const 911 const Pandora *
const pPandora(
new Pandora(name));
915 PANDORA_THROW_RESULT_IF(
921 PandoraApi::Geometry::LArTPC::Parameters larTPCParameters;
922 larTPCParameters.m_larTPCVolumeId = larTPC.GetLArTPCVolumeId();
923 larTPCParameters.m_centerX = larTPC.GetCenterX();
924 larTPCParameters.m_centerY = larTPC.GetCenterY();
925 larTPCParameters.m_centerZ = larTPC.GetCenterZ();
926 larTPCParameters.m_widthX = larTPC.GetWidthX();
927 larTPCParameters.m_widthY = larTPC.GetWidthY();
928 larTPCParameters.m_widthZ = larTPC.GetWidthZ();
929 larTPCParameters.m_wirePitchU = larTPC.GetWirePitchU();
930 larTPCParameters.m_wirePitchV = larTPC.GetWirePitchV();
931 larTPCParameters.m_wirePitchW = larTPC.GetWirePitchW();
932 larTPCParameters.m_wireAngleU = larTPC.GetWireAngleU();
933 larTPCParameters.m_wireAngleV = larTPC.GetWireAngleV();
934 larTPCParameters.m_wireAngleW = larTPC.GetWireAngleW();
935 larTPCParameters.m_sigmaUVW = larTPC.GetSigmaUVW();
936 larTPCParameters.m_isDriftInPositiveX = larTPC.IsDriftInPositiveX();
937 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::LArTPC::Create(*pPandora, larTPCParameters));
939 const float tpcMinX(larTPC.GetCenterX() - 0.5f * larTPC.GetWidthX()), tpcMaxX(larTPC.GetCenterX() + 0.5f * larTPC.GetWidthX());
942 for (
const DetectorGap *
const pGap : gapList)
944 const LineGap *
const pLineGap(dynamic_cast<const LineGap *>(pGap));
947 (((pLineGap->GetLineEndX() >= tpcMinX) && (pLineGap->GetLineEndX() <= tpcMaxX)) ||
948 ((pLineGap->GetLineStartX() >= tpcMinX) && (pLineGap->GetLineStartX() <= tpcMaxX))))
950 PandoraApi::Geometry::LineGap::Parameters lineGapParameters;
951 const LineGapType lineGapType(pLineGap->GetLineGapType());
952 lineGapParameters.m_lineGapType = lineGapType;
953 lineGapParameters.m_lineStartX = pLineGap->GetLineStartX();
954 lineGapParameters.m_lineEndX = pLineGap->GetLineEndX();
957 ((lineGapType == TPC_WIRE_GAP_VIEW_U) || (lineGapType == TPC_WIRE_GAP_VIEW_V) || (lineGapType == TPC_WIRE_GAP_VIEW_W)))
959 lineGapParameters.m_lineStartX = -std::numeric_limits<float>::max();
960 lineGapParameters.m_lineEndX = std::numeric_limits<float>::max();
963 lineGapParameters.m_lineStartZ = pLineGap->GetLineStartZ();
964 lineGapParameters.m_lineEndZ = pLineGap->GetLineEndZ();
965 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::LineGap::Create(*pPandora, lineGapParameters));
970 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::ReadSettings(*pPandora, settingsFile));
977 const LArTPCMap &larTPCMap,
const DetectorGapList &gapList,
const std::string &settingsFile,
const std::string &name)
const 979 if (larTPCMap.empty())
981 std::cout <<
"MasterAlgorithm::CreateWorkerInstance - no LArTPC details provided" << std::endl;
982 throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
986 const Pandora *
const pPandora(
new Pandora(name));
990 PANDORA_THROW_RESULT_IF(
996 const LArTPC *
const pFirstLArTPC(larTPCMap.begin()->second);
997 float parentMinX(pFirstLArTPC->GetCenterX() - 0.5f * pFirstLArTPC->GetWidthX());
998 float parentMaxX(pFirstLArTPC->GetCenterX() + 0.5f * pFirstLArTPC->GetWidthX());
999 float parentMinY(pFirstLArTPC->GetCenterY() - 0.5f * pFirstLArTPC->GetWidthY());
1000 float parentMaxY(pFirstLArTPC->GetCenterY() + 0.5f * pFirstLArTPC->GetWidthY());
1001 float parentMinZ(pFirstLArTPC->GetCenterZ() - 0.5f * pFirstLArTPC->GetWidthZ());
1002 float parentMaxZ(pFirstLArTPC->GetCenterZ() + 0.5f * pFirstLArTPC->GetWidthZ());
1004 for (
const LArTPCMap::value_type &mapEntry : larTPCMap)
1006 const LArTPC *
const pLArTPC(mapEntry.second);
1007 parentMinX = std::min(parentMinX, pLArTPC->GetCenterX() - 0.5f * pLArTPC->GetWidthX());
1008 parentMaxX = std::max(parentMaxX, pLArTPC->GetCenterX() + 0.5f * pLArTPC->GetWidthX());
1009 parentMinY = std::min(parentMinY, pLArTPC->GetCenterY() - 0.5f * pLArTPC->GetWidthY());
1010 parentMaxY = std::max(parentMaxY, pLArTPC->GetCenterY() + 0.5f * pLArTPC->GetWidthY());
1011 parentMinZ = std::min(parentMinZ, pLArTPC->GetCenterZ() - 0.5f * pLArTPC->GetWidthZ());
1012 parentMaxZ = std::max(parentMaxZ, pLArTPC->GetCenterZ() + 0.5f * pLArTPC->GetWidthZ());
1015 PandoraApi::Geometry::LArTPC::Parameters larTPCParameters;
1016 larTPCParameters.m_larTPCVolumeId = 0;
1017 larTPCParameters.m_centerX = 0.5f * (parentMaxX + parentMinX);
1018 larTPCParameters.m_centerY = 0.5f * (parentMaxY + parentMinY);
1019 larTPCParameters.m_centerZ = 0.5f * (parentMaxZ + parentMinZ);
1020 larTPCParameters.m_widthX = parentMaxX - parentMinX;
1021 larTPCParameters.m_widthY = parentMaxY - parentMinY;
1022 larTPCParameters.m_widthZ = parentMaxZ - parentMinZ;
1023 larTPCParameters.m_wirePitchU = std::max(pFirstLArTPC->GetWirePitchU(), pFirstLArTPC->GetWirePitchV());
1024 larTPCParameters.m_wirePitchV = std::max(pFirstLArTPC->GetWirePitchU(), pFirstLArTPC->GetWirePitchV());
1025 larTPCParameters.m_wirePitchW = pFirstLArTPC->GetWirePitchW();
1026 larTPCParameters.m_wireAngleU = pFirstLArTPC->GetWireAngleU();
1027 larTPCParameters.m_wireAngleV = pFirstLArTPC->GetWireAngleV();
1028 larTPCParameters.m_wireAngleW = pFirstLArTPC->GetWireAngleW();
1029 larTPCParameters.m_sigmaUVW = pFirstLArTPC->GetSigmaUVW();
1030 larTPCParameters.m_isDriftInPositiveX = pFirstLArTPC->IsDriftInPositiveX();
1031 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::LArTPC::Create(*pPandora, larTPCParameters));
1034 for (
const DetectorGap *
const pGap : gapList)
1036 const LineGap *
const pLineGap(dynamic_cast<const LineGap *>(pGap));
1040 PandoraApi::Geometry::LineGap::Parameters lineGapParameters;
1041 lineGapParameters.m_lineGapType = pLineGap->GetLineGapType();
1042 lineGapParameters.m_lineStartX = pLineGap->GetLineStartX();
1043 lineGapParameters.m_lineEndX = pLineGap->GetLineEndX();
1044 lineGapParameters.m_lineStartZ = pLineGap->GetLineStartZ();
1045 lineGapParameters.m_lineEndZ = pLineGap->GetLineEndZ();
1046 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::LineGap::Create(*pPandora, lineGapParameters));
1051 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::ReadSettings(*pPandora, settingsFile));
1059 return STATUS_CODE_SUCCESS;
1068 if (this->ExternalParametersPresent())
1071 if (!pExternalParameters)
1072 return STATUS_CODE_FAILURE;
1076 AlgorithmToolVector algorithmToolVector;
1077 PANDORA_RETURN_RESULT_IF(
1078 STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*
this, xmlHandle,
"SliceSelectionTools", algorithmToolVector));
1080 for (AlgorithmTool *
const pAlgorithmTool : algorithmToolVector)
1082 SliceSelectionBaseTool *
const pSliceSelectionTool(dynamic_cast<SliceSelectionBaseTool *>(pAlgorithmTool));
1083 if (!pSliceSelectionTool)
1084 return STATUS_CODE_INVALID_PARAMETER;
1089 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1093 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1099 std::cout <<
"MasterAlgorithm::ReadSettings - ShouldRunStitching requires ShouldRunAllHitsCosmicReco to be true" << std::endl;
1100 return STATUS_CODE_INVALID_PARAMETER;
1105 AlgorithmToolVector algorithmToolVector;
1106 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*
this, xmlHandle,
"StitchingTools", algorithmToolVector));
1108 for (AlgorithmTool *
const pAlgorithmTool : algorithmToolVector)
1110 StitchingBaseTool *
const pStitchingTool(dynamic_cast<StitchingBaseTool *>(pAlgorithmTool));
1111 if (!pStitchingTool)
1112 return STATUS_CODE_INVALID_PARAMETER;
1117 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1123 std::cout <<
"MasterAlgorithm::ReadSettings - ShouldRunCosmicHitRemoval requires ShouldRunAllHitsCosmicReco to be true" << std::endl;
1124 return STATUS_CODE_INVALID_PARAMETER;
1129 AlgorithmToolVector algorithmToolVector;
1130 PANDORA_RETURN_RESULT_IF(
1131 STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*
this, xmlHandle,
"CosmicRayTaggingTools", algorithmToolVector));
1133 for (AlgorithmTool *
const pAlgorithmTool : algorithmToolVector)
1136 if (!pCosmicRayTaggingTool)
1137 return STATUS_CODE_INVALID_PARAMETER;
1142 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1146 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1150 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1154 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1160 std::cout <<
"MasterAlgorithm::ReadSettings - ShouldPerformSliceId requires ShouldRunSlicing and both neutrino and cosmic reconstruction options" 1162 return STATUS_CODE_INVALID_PARAMETER;
1167 AlgorithmToolVector algorithmToolVector;
1168 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*
this, xmlHandle,
"SliceIdTools", algorithmToolVector));
1170 for (AlgorithmTool *
const pAlgorithmTool : algorithmToolVector)
1172 SliceIdBaseTool *
const pSliceIdIdTool(dynamic_cast<SliceIdBaseTool *>(pAlgorithmTool));
1173 if (!pSliceIdIdTool)
1174 return STATUS_CODE_INVALID_PARAMETER;
1179 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
1183 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
1186 PANDORA_RETURN_RESULT_IF_AND_IF(
1187 STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
"LArCaloHitVersion",
m_larCaloHitVersion));
1189 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
1192 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
1195 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
1198 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
1201 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"CRSettingsFile",
m_crSettingsFile));
1202 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"NuSettingsFile",
m_nuSettingsFile));
1203 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"SlicingSettingsFile",
m_slicingSettingsFile));
1210 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"InputMCParticleListName",
m_inputMCParticleListName));
1213 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"InputHitListName",
m_inputHitListName));
1214 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"RecreatedPfoListName",
m_recreatedPfoListName));
1215 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"RecreatedClusterListName",
m_recreatedClusterListName));
1216 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle,
"RecreatedVertexListName",
m_recreatedVertexListName));
1217 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
"InTimeMaxX0",
m_inTimeMaxX0));
1219 return STATUS_CODE_SUCCESS;
1225 const TiXmlHandle xmlHandle,
const std::string &xmlTag,
bool &outputBool)
1227 if (pExternalParameters && inputBool.IsInitialized())
1229 outputBool = inputBool.Get();
1233 PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, xmlTag, outputBool));
1236 return STATUS_CODE_SUCCESS;
static void AddDaughterPandoraInstance(const pandora::Pandora *const pPrimaryPandora, const pandora::Pandora *const pDaughterPandora)
Add a pandora daughter instance, associated to a primary pandora instance.
std::string m_inputMCParticleListName
The input mc particle list name.
pandora::InputBool m_shouldRunCosmicHitRemoval
Whether to remove hits from tagged cosmic-rays.
const pandora::ParticleFlowObject * CreatePfo(const pandora::ParticleFlowObject *const pInputPfo, const pandora::ClusterList &newClusterList, const pandora::VertexList &newVertexList) const
Create a new pfo in the current pandora instance, based upon the provided input pfo.
LArCaloHitFactory m_larCaloHitFactory
Factory for creating LArCaloHits during hit copying.
std::vector< pandora::PfoList > SliceHypotheses
CosmicRayTaggingToolVector m_cosmicRayTaggingToolVector
The cosmic-ray tagging tool vector.
Header file for the pfo helper class.
pandora::StatusCode Copy(const pandora::Pandora *const pPandora, const pandora::CaloHit *const pCaloHit) const
Copy a specified calo hit to the provided pandora instance.
pandora::InputBool m_shouldRunStitching
Whether to stitch cosmic-ray muons crossing between volumes.
CosmicRayTaggingBaseTool class.
pandora::StatusCode Recreate(const pandora::PfoList &inputPfoList, pandora::PfoList &newPfoList) const
Recreate a specified list of pfos in the current pandora instance.
pandora::StatusCode ReadExternalSettings(const ExternalSteeringParameters *const pExternalParameters, const pandora::InputBool inputBool, const pandora::TiXmlHandle xmlHandle, const std::string &xmlTag, bool &outputBool)
Read settings from external steering parameters block, if present, otherwise from xml as standard...
const pandora::Pandora * m_pSlicingWorkerInstance
The slicing worker instance.
Header file for the lar calo hit class.
static void GetTwoDClusterList(const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
Get the list of 2D clusters from an input pfo.
pandora::StatusCode CopyMCParticles() const
Copy mc particles in the named input list to all pandora worker instances.
const pandora::CaloHit * CreateCaloHit(const pandora::CaloHit *const pInputCaloHit, const pandora::CaloHit *const pParentCaloHit) const
Create a new calo hit in the current pandora instance, based upon the provided input calo hit...
bool m_shouldRunNeutrinoRecoOption
Whether to run neutrino reconstruction for each slice.
bool m_shouldRunAllHitsCosmicReco
Whether to run all hits cosmic-ray reconstruction.
void ProcessEvent(G4int iProp, size_t nEv)
bool m_shouldRemoveOutOfTimeHits
Whether to remove out of time hits.
unsigned int GetLArTPCVolumeId() const
Get the lar tpc volume id.
pandora::InputBool m_shouldRunSlicing
Whether to slice events into separate regions for processing.
bool m_shouldPerformSliceId
Whether to identify slices and select most appropriate pfos.
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
std::string m_slicingSettingsFile
The slicing settings file.
void FillParameters(LArMCParticleParameters ¶meters) const
Fill the parameters associated with this MC particle.
pandora::StatusCode RunCosmicRayHitRemoval(const pandora::PfoList &ambiguousPfos) const
Run cosmic-ray hit removal, freeing hits in ambiguous pfos for further processing.
std::string m_recreatedVertexListName
The output recreated vertex list name.
std::vector< const pandora::Pandora * > PandoraInstanceList
const pandora::Vertex * CreateVertex(const pandora::Vertex *const pInputVertex) const
Create a new vertex in the current pandora instance, based upon the provided input vertex...
const pandora::Pandora * m_pSliceCRWorkerInstance
The per-slice cosmic-ray reconstruction worker instance.
static bool SortByMomentum(const pandora::MCParticle *const pLhs, const pandora::MCParticle *const pRhs)
Sort mc particles by their momentum.
SliceSelectionToolVector m_sliceSelectionToolVector
The slice selection tool vector.
pandora::InputBool m_shouldRunAllHitsCosmicReco
Whether to run all hits cosmic-ray reconstruction.
const pandora::Cluster * CreateCluster(const pandora::Cluster *const pInputCluster, const pandora::CaloHitList &newCaloHitList, const pandora::CaloHitList &newIsolatedCaloHitList) const
Create a new cluster in the current pandora instance, based upon the provided input cluster...
bool m_printOverallRecoStatus
Whether to print current operation status messages.
Header file for the master algorithm class.
Header file for the lar monte carlo particle helper helper class.
const pandora::Pandora * CreateWorkerInstance(const pandora::LArTPC &larTPC, const pandora::DetectorGapList &gapList, const std::string &settingsFile, const std::string &name) const
Create a pandora worker instance to handle a single LArTPC.
decltype(auto) constexpr to_string(T &&obj)
ADL-aware version of std::to_string.
Header file for the cluster helper class.
pandora::StatusCode RunSliceReconstruction(SliceVector &sliceVector, SliceHypotheses &nuSliceHypotheses, SliceHypotheses &crSliceHypotheses) const
Process each slice under different reconstruction hypotheses.
std::map< unsigned int, LArTPCHitList > VolumeIdToHitListMap
ntupleExperimental Reset()
std::unordered_map< const pandora::ParticleFlowObject *, float > PfoToFloatMap
const pandora::Pandora * m_pSliceNuWorkerInstance
The per-slice neutrino reconstruction worker instance.
static pandora::StatusCode RegisterBasicPlugins(const pandora::Pandora &pandora)
Register the basic lar content plugins with pandora.
std::string m_nuSettingsFile
The neutrino reconstruction settings file.
pandora::InputBool m_shouldRunNeutrinoRecoOption
Whether to run neutrino reconstruction for each slice.
pandora::StatusCode InitializeWorkerInstances()
Initialize pandora worker instances.
static bool HasPfoBeenStitched(const pandora::ParticleFlowObject *const pPfo)
Whether a pfo has been stitched.
bool m_workerInstancesInitialized
Whether all worker instances have been initialized.
std::vector< art::Ptr< simb::MCParticle > > MCParticleVector
void ShiftPfoHierarchy(const pandora::ParticleFlowObject *const pParentPfo, const PfoToLArTPCMap &pfoToLArTPCMap, const float x0) const
Shift a Pfo hierarchy by a specified x0 value.
StitchingToolVector m_stitchingToolVector
The stitching tool vector.
pandora::StatusCode Reset()
Reset all worker instances.
unsigned int m_larCaloHitVersion
The LArCaloHit version for LArCaloHitFactory.
pandora::InputBool m_printOverallRecoStatus
Whether to print current operation status messages.
std::string m_recreatedClusterListName
The output recreated cluster list name.
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.
bool m_visualizeOverallRecoStatus
Whether to display results of current operations.
pandora::StatusCode TagCosmicRayPfos(const PfoToFloatMap &stitchedPfosToX0Map, pandora::PfoList &clearCosmicRayPfos, pandora::PfoList &ambiguousPfos) const
Tag clear, unambiguous cosmic-ray pfos.
std::string m_crSettingsFile
The cosmic-ray reconstruction settings file.
static const pandora::Cluster * GetParentCluster(const pandora::ClusterList &clusterList, const pandora::HitType hitType)
Select the parent cluster (same hit type and most hits) using a provided cluster list and hit type...
void StitchPfos(const pandora::ParticleFlowObject *const pPfoToEnlarge, const pandora::ParticleFlowObject *const pPfoToDelete, PfoToLArTPCMap &pfoToLArTPCMap) const
Stitch together a pair of pfos.
Header file for the lar mc particle class.
static void GetThreeDClusterList(const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
Get the list of 3D clusters from an input pfo.
External steering parameters class.
std::string m_recreatedPfoListName
The output recreated pfo list name.
bool m_fullWidthCRWorkerWireGaps
Whether wire-type line gaps in cosmic-ray worker instances should cover all drift time...
LArMCParticleFactory responsible for object creation.
pandora::StatusCode StitchCosmicRayPfos(PfoToLArTPCMap &pfoToLArTPCMap, PfoToFloatMap &stitchedPfosToX0Map) const
Stitch together cosmic-ray pfos crossing between adjacent lar tpcs.
std::unordered_map< const pandora::ParticleFlowObject *, const pandora::LArTPC * > PfoToLArTPCMap
static pandora::StatusCode RegisterAlgorithms(const pandora::Pandora &pandora)
Register all the lar content algorithms and tools with pandora.
std::string m_filePathEnvironmentVariable
The environment variable providing a list of paths to xml files.
SliceSelectionBaseTool class.
LAr mc particle parameters.
Header file for the helper class for multiple drift volumes.
pandora::StatusCode GetVolumeIdToHitListMap(VolumeIdToHitListMap &volumeIdToHitListMap) const
Get the mapping from lar tpc volume id to lists of all hits, and truncated hits.
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
pandora::StatusCode RecreateCosmicRayPfos(PfoToLArTPCMap &pfoToLArTPCMap) const
Recreate cosmic-ray pfos (created by worker instances) in the master instance.
bool m_shouldRunSlicing
Whether to slice events into separate regions for processing.
static void GetIsolatedCaloHits(const pandora::PfoList &pfoList, const pandora::HitType &hitType, pandora::CaloHitList &caloHitList)
Get a list of isolated calo hits of a particular hit type from a list of pfos.
Header file for the pfo mop up algorithm base class.
bool m_shouldRunCosmicRecoOption
Whether to run cosmic-ray reconstruction for each slice.
pandora::InputBool m_shouldPerformSliceId
Whether to identify slices and select most appropriate pfos.
static void GetAllDownstreamPfos(const pandora::PfoList &inputPfoList, pandora::PfoList &outputPfoList)
Get a flat list of all pfos, recursively, of all daughters associated with those pfos in an input lis...
virtual pandora::StatusCode RegisterCustomContent(const pandora::Pandora *const pPandora) const
Register custom content, such as algorithms or algorithm tools, with a specified pandora instance...
pandora::StatusCode Run()
LArRotationalTransformationPlugin class.
Header file detailing content for use with particle flow reconstruction at liquid argon time projecti...
std::vector< art::Ptr< recob::Vertex > > VertexVector
pandora::InputBool m_shouldRunCosmicRecoOption
Whether to run cosmic-ray reconstruction for each slice.
pandora::StatusCode SelectBestSliceHypotheses(const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses) const
Examine slice hypotheses to identify the most appropriate to provide in final event output...
boost::graph_traits< ModuleGraph >::vertex_descriptor Vertex
PandoraInstanceList m_crWorkerInstances
The list of cosmic-ray reconstruction worker instances.
std::vector< art::Ptr< recob::Cluster > > ClusterVector
SliceIdToolVector m_sliceIdToolVector
The slice id tool vector.
std::vector< pandora::CaloHitList > SliceVector
bool m_shouldRunCosmicHitRemoval
Whether to remove hits from tagged cosmic-rays.
Header file for the lar pseudo layer plugin class.
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...
pandora::StatusCode RunSlicing(const VolumeIdToHitListMap &volumeIdToHitListMap, SliceVector &sliceVector) const
Run the event slicing procedures, dividing available hits up into distinct 3D regions.
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.
bool m_shouldRunStitching
Whether to stitch cosmic-ray muons crossing between volumes.
std::list< Vertex > VertexList
LarPandoraPseudoLayerPlugin class.
float m_inTimeMaxX0
Cut on X0 to determine whether particle is clear cosmic ray.
std::string m_inputHitListName
The input hit list name.
bool m_passMCParticlesToWorkerInstances
Whether to pass mc particle details (and links to calo hits) to worker instances. ...
pandora::StatusCode RunCosmicRayReconstruction(const VolumeIdToHitListMap &volumeIdToHitListMap) const
Run the cosmic-ray reconstruction worker instances.