MasterAlgorithm class. More...

#include "DLMasterAlgorithm.h"

Inheritance diagram for lar_dl_content::DLMasterAlgorithm:

Public Types
typedef std::unordered_map< const pandora::ParticleFlowObject , const pandora::LArTPC >	PfoToLArTPCMap

Public Member Functions
	DLMasterAlgorithm ()=default
	Default constructor. More...

void	ShiftPfoHierarchy (const pandora::ParticleFlowObject *const pParentPfo, const PfoToLArTPCMap &pfoToLArTPCMap, const float x0) const
	Shift a Pfo hierarchy by a specified x0 value. More...

void	StitchPfos (const pandora::ParticleFlowObject const pPfoToEnlarge, const pandora::ParticleFlowObject const pPfoToDelete, PfoToLArTPCMap &pfoToLArTPCMap) const
	Stitch together a pair of pfos. More...

Protected Types
typedef std::map< unsigned int, LArTPCHitList >	VolumeIdToHitListMap

typedef std::vector< StitchingBaseTool * >	StitchingToolVector

typedef std::vector< CosmicRayTaggingBaseTool * >	CosmicRayTaggingToolVector

typedef std::vector< SliceIdBaseTool * >	SliceIdToolVector

typedef std::vector< SliceSelectionBaseTool * >	SliceSelectionToolVector

Protected Member Functions
pandora::StatusCode	InitializeWorkerInstances ()
	Initialize pandora worker instances. More...

pandora::StatusCode	CopyMCParticles () const
	Copy mc particles in the named input list to all pandora worker instances. More...

pandora::StatusCode	GetVolumeIdToHitListMap (VolumeIdToHitListMap &volumeIdToHitListMap) const
	Get the mapping from lar tpc volume id to lists of all hits, and truncated hits. More...

pandora::StatusCode	RunCosmicRayReconstruction (const VolumeIdToHitListMap &volumeIdToHitListMap) const
	Run the cosmic-ray reconstruction worker instances. More...

pandora::StatusCode	RecreateCosmicRayPfos (PfoToLArTPCMap &pfoToLArTPCMap) const
	Recreate cosmic-ray pfos (created by worker instances) in the master instance. More...

pandora::StatusCode	StitchCosmicRayPfos (PfoToLArTPCMap &pfoToLArTPCMap, PfoToFloatMap &stitchedPfosToX0Map) const
	Stitch together cosmic-ray pfos crossing between adjacent lar tpcs. More...

pandora::StatusCode	TagCosmicRayPfos (const PfoToFloatMap &stitchedPfosToX0Map, pandora::PfoList &clearCosmicRayPfos, pandora::PfoList &ambiguousPfos) const
	Tag clear, unambiguous cosmic-ray pfos. More...

pandora::StatusCode	RunCosmicRayHitRemoval (const pandora::PfoList &ambiguousPfos) const
	Run cosmic-ray hit removal, freeing hits in ambiguous pfos for further processing. More...

pandora::StatusCode	RunSlicing (const VolumeIdToHitListMap &volumeIdToHitListMap, SliceVector &sliceVector) const
	Run the event slicing procedures, dividing available hits up into distinct 3D regions. More...

pandora::StatusCode	RunSliceReconstruction (SliceVector &sliceVector, SliceHypotheses &nuSliceHypotheses, SliceHypotheses &crSliceHypotheses) const
	Process each slice under different reconstruction hypotheses. More...

pandora::StatusCode	SelectBestSliceHypotheses (const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses) const
	Examine slice hypotheses to identify the most appropriate to provide in final event output. More...

pandora::StatusCode	Reset ()
	Reset all worker instances. More...

pandora::StatusCode	Copy (const pandora::Pandora const pPandora, const pandora::CaloHit const pCaloHit) const
	Copy a specified calo hit to the provided pandora instance. More...

pandora::StatusCode	Copy (const pandora::Pandora const pPandora, const pandora::MCParticle const pMCParticle, const LArMCParticleFactory *const pMCParticleFactory) const
	Copy a specified mc particle to the provided pandora instance. More...

pandora::StatusCode	Recreate (const pandora::PfoList &inputPfoList, pandora::PfoList &newPfoList) const
	Recreate a specified list of pfos in the current pandora instance. More...

pandora::StatusCode	Recreate (const pandora::ParticleFlowObject const pInputPfo, const pandora::ParticleFlowObject const pNewParentPfo, pandora::PfoList &newPfoList) const
	Recreate a specified pfo in the current pandora instance. More...

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

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

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

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

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

const pandora::Pandora *	CreateWorkerInstance (const pandora::LArTPCMap &larTPCMap, const pandora::DetectorGapList &gapList, const std::string &settingsFile, const std::string &name) const
	Create a pandora worker instance to handle a number of LArTPCs. More...

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

Protected Attributes
bool	m_workerInstancesInitialized
	Whether all worker instances have been initialized. More...

unsigned int	m_larCaloHitVersion
	The LArCaloHit version for LArCaloHitFactory. More...

bool	m_shouldRunAllHitsCosmicReco
	Whether to run all hits cosmic-ray reconstruction. More...

bool	m_shouldRunStitching
	Whether to stitch cosmic-ray muons crossing between volumes. More...

bool	m_shouldRunCosmicHitRemoval
	Whether to remove hits from tagged cosmic-rays. More...

bool	m_shouldRunSlicing
	Whether to slice events into separate regions for processing. More...

bool	m_shouldRunNeutrinoRecoOption
	Whether to run neutrino reconstruction for each slice. More...

bool	m_shouldRunCosmicRecoOption
	Whether to run cosmic-ray reconstruction for each slice. More...

bool	m_shouldPerformSliceId
	Whether to identify slices and select most appropriate pfos. More...

bool	m_printOverallRecoStatus
	Whether to print current operation status messages. More...

bool	m_visualizeOverallRecoStatus
	Whether to display results of current operations. More...

bool	m_shouldRemoveOutOfTimeHits
	Whether to remove out of time hits. More...

PandoraInstanceList	m_crWorkerInstances
	The list of cosmic-ray reconstruction worker instances. More...

const pandora::Pandora *	m_pSlicingWorkerInstance
	The slicing worker instance. More...

const pandora::Pandora *	m_pSliceNuWorkerInstance
	The per-slice neutrino reconstruction worker instance. More...

const pandora::Pandora *	m_pSliceCRWorkerInstance
	The per-slice cosmic-ray reconstruction worker instance. More...

bool	m_fullWidthCRWorkerWireGaps
	Whether wire-type line gaps in cosmic-ray worker instances should cover all drift time. More...

bool	m_passMCParticlesToWorkerInstances
	Whether to pass mc particle details (and links to calo hits) to worker instances. More...

StitchingToolVector	m_stitchingToolVector
	The stitching tool vector. More...

CosmicRayTaggingToolVector	m_cosmicRayTaggingToolVector
	The cosmic-ray tagging tool vector. More...

SliceIdToolVector	m_sliceIdToolVector
	The slice id tool vector. More...

SliceSelectionToolVector	m_sliceSelectionToolVector
	The slice selection tool vector. More...

std::string	m_filePathEnvironmentVariable
	The environment variable providing a list of paths to xml files. More...

std::string	m_crSettingsFile
	The cosmic-ray reconstruction settings file. More...

std::string	m_nuSettingsFile
	The neutrino reconstruction settings file. More...

std::string	m_slicingSettingsFile
	The slicing settings file. More...

std::string	m_inputMCParticleListName
	The input mc particle list name. More...

std::string	m_inputHitListName
	The input hit list name. More...

std::string	m_recreatedPfoListName
	The output recreated pfo list name. More...

std::string	m_recreatedClusterListName
	The output recreated cluster list name. More...

std::string	m_recreatedVertexListName
	The output recreated vertex list name. More...

float	m_inTimeMaxX0
	Cut on X0 to determine whether particle is clear cosmic ray. More...

LArCaloHitFactory	m_larCaloHitFactory
	Factory for creating LArCaloHits during hit copying. More...

Private Member Functions
pandora::StatusCode	Run ()

pandora::StatusCode	RegisterCustomContent (const pandora::Pandora *const pPandora) const
	Register custom content, such as algorithms or algorithm tools, with a specified pandora instance. More...

pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Detailed Description

MasterAlgorithm class.

Definition at line 19 of file DLMasterAlgorithm.h.

Member Typedef Documentation

typedef std::vector<CosmicRayTaggingBaseTool *> lar_content::MasterAlgorithm::CosmicRayTaggingToolVector

protectedinherited

Definition at line 335 of file MasterAlgorithm.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, const pandora::LArTPC *> lar_content::MasterAlgorithm::PfoToLArTPCMap

inherited

Definition at line 63 of file MasterAlgorithm.h.

typedef std::vector<SliceIdBaseTool *> lar_content::MasterAlgorithm::SliceIdToolVector

protectedinherited

Definition at line 336 of file MasterAlgorithm.h.

typedef std::vector<SliceSelectionBaseTool *> lar_content::MasterAlgorithm::SliceSelectionToolVector

protectedinherited

Definition at line 337 of file MasterAlgorithm.h.

typedef std::vector<StitchingBaseTool *> lar_content::MasterAlgorithm::StitchingToolVector

protectedinherited

Definition at line 334 of file MasterAlgorithm.h.

typedef std::map<unsigned int, LArTPCHitList> lar_content::MasterAlgorithm::VolumeIdToHitListMap

protectedinherited

Definition at line 95 of file MasterAlgorithm.h.

Constructor & Destructor Documentation

lar_dl_content::DLMasterAlgorithm::DLMasterAlgorithm ( )

default

Default constructor.

Member Function Documentation

pandora::StatusCode lar_content::MasterAlgorithm::Copy	(	const pandora::Pandora *const	pPandora,
		const pandora::CaloHit *const	pCaloHit
	)		const

protectedinherited

Copy a specified calo hit to the provided pandora instance.

Parameters

pPandora	the address of the target pandora instance
pCaloHit	the address of the calo hit

Referenced by lar_content::MasterAlgorithm::CopyMCParticles(), lar_content::MasterAlgorithm::Reset(), lar_content::MasterAlgorithm::RunCosmicRayReconstruction(), lar_content::MasterAlgorithm::RunSliceReconstruction(), and lar_content::MasterAlgorithm::RunSlicing().

pandora::StatusCode lar_content::MasterAlgorithm::Copy	(	const pandora::Pandora *const	pPandora,
		const pandora::MCParticle *const	pMCParticle,
		const LArMCParticleFactory *const	pMCParticleFactory
	)		const

protectedinherited

Copy a specified mc particle to the provided pandora instance.

Parameters

pPandora	the address of the target pandora instance
pMCParticle	the address of the mc particle
pMCParticleFactory	the address of the mc particle factory, allowing decoration of instances with information beyond that expected by sdk

StatusCode lar_content::MasterAlgorithm::CopyMCParticles ( ) const

protectedinherited

Copy mc particles in the named input list to all pandora worker instances.

Definition at line 239 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::Copy(), lar_content::MasterAlgorithm::m_crWorkerInstances, lar_content::MasterAlgorithm::m_inputMCParticleListName, lar_content::MasterAlgorithm::m_pSliceCRWorkerInstance, lar_content::MasterAlgorithm::m_pSliceNuWorkerInstance, and lar_content::MasterAlgorithm::m_pSlicingWorkerInstance.

Referenced by lar_content::MasterAlgorithm::Run().

 {
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_inputMCParticleListName, pMCParticleList));
 
     PandoraInstanceList pandoraWorkerInstances(m_crWorkerInstances);
     if (m_pSlicingWorkerInstance)
         pandoraWorkerInstances.push_back(m_pSlicingWorkerInstance);
     if (m_pSliceNuWorkerInstance)
         pandoraWorkerInstances.push_back(m_pSliceNuWorkerInstance);
     if (m_pSliceCRWorkerInstance)
         pandoraWorkerInstances.push_back(m_pSliceCRWorkerInstance);
 
     LArMCParticleFactory mcParticleFactory;
 
     for (const Pandora *const pPandoraWorker : pandoraWorkerInstances)
     {
         for (const MCParticle *const pMCParticle : *pMCParticleList)
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Copy(pPandoraWorker, pMCParticle, &mcParticleFactory));
     }
 
     return STATUS_CODE_SUCCESS;
 }

const CaloHit * lar_content::MasterAlgorithm::CreateCaloHit	(	const pandora::CaloHit *const	pInputCaloHit,
		const pandora::CaloHit *const	pParentCaloHit
	)		const

protectedinherited

Create a new calo hit in the current pandora instance, based upon the provided input calo hit.

Parameters

pInputCaloHit	the address of the input calo hit
pParentCaloHit	the address of the parent calo hit

Returns: the address of the new calo hit

Definition at line 814 of file MasterAlgorithm.cc.

Referenced by lar_content::MasterAlgorithm::Reset().

 {
     PandoraContentApi::CaloHit::Parameters parameters;
     parameters.m_positionVector = pInputCaloHit->GetPositionVector();
     parameters.m_expectedDirection = pInputCaloHit->GetExpectedDirection();
     parameters.m_cellNormalVector = pInputCaloHit->GetCellNormalVector();
     parameters.m_cellGeometry = pInputCaloHit->GetCellGeometry();
     parameters.m_cellSize0 = pInputCaloHit->GetCellSize0();
     parameters.m_cellSize1 = pInputCaloHit->GetCellSize1();
     parameters.m_cellThickness = pInputCaloHit->GetCellThickness();
     parameters.m_nCellRadiationLengths = pInputCaloHit->GetNCellRadiationLengths();
     parameters.m_nCellInteractionLengths = pInputCaloHit->GetNCellInteractionLengths();
     parameters.m_time = pInputCaloHit->GetTime();
     parameters.m_inputEnergy = pInputCaloHit->GetInputEnergy();
     parameters.m_mipEquivalentEnergy = pInputCaloHit->GetMipEquivalentEnergy();
     parameters.m_electromagneticEnergy = pInputCaloHit->GetElectromagneticEnergy();
     parameters.m_hadronicEnergy = pInputCaloHit->GetHadronicEnergy();
     parameters.m_isDigital = pInputCaloHit->IsDigital();
     parameters.m_hitType = pInputCaloHit->GetHitType();
     parameters.m_hitRegion = pInputCaloHit->GetHitRegion();
     parameters.m_layer = pInputCaloHit->GetLayer();
     parameters.m_isInOuterSamplingLayer = pInputCaloHit->IsInOuterSamplingLayer();
     parameters.m_pParentAddress = static_cast<const void *>(pParentCaloHit);
 
     const CaloHit *pNewCaloHit(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::Create(*this, parameters, pNewCaloHit));
 
     PandoraContentApi::CaloHit::Metadata metadata;
     metadata.m_isIsolated = pInputCaloHit->IsIsolated();
     metadata.m_isPossibleMip = pInputCaloHit->IsPossibleMip();
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::AlterMetadata(*this, pNewCaloHit, metadata));
 
     return pNewCaloHit;
 }

const Cluster * lar_content::MasterAlgorithm::CreateCluster	(	const pandora::Cluster *const	pInputCluster,
		const pandora::CaloHitList &	newCaloHitList,
		const pandora::CaloHitList &	newIsolatedCaloHitList
	)		const

protectedinherited

Create a new cluster in the current pandora instance, based upon the provided input cluster.

Parameters

pInputCluster	the address of the input cluster
newCaloHitList	the list of calo hits for the new cluster
newIsolatedCaloHitList	the list of isolated calo hits for the new cluster

Returns: the address of the new cluster

Definition at line 851 of file MasterAlgorithm.cc.

 {
     PandoraContentApi::Cluster::Parameters parameters;
     parameters.m_caloHitList = newCaloHitList;
     parameters.m_isolatedCaloHitList = newIsolatedCaloHitList;
 
     const Cluster *pNewCluster(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pNewCluster));
 
     PandoraContentApi::Cluster::Metadata metadata;
     metadata.m_particleId = pInputCluster->GetParticleId();
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::AlterMetadata(*this, pNewCluster, metadata));
 
     return pNewCluster;
 }

const ParticleFlowObject * lar_content::MasterAlgorithm::CreatePfo	(	const pandora::ParticleFlowObject *const	pInputPfo,
		const pandora::ClusterList &	newClusterList,
		const pandora::VertexList &	newVertexList
	)		const

protectedinherited

Create a new pfo in the current pandora instance, based upon the provided input pfo.

Parameters

pInputPfo	the address of the input pfo
newClusterList	the list of clusters for the new pfo
newVertexList	the list of vertices for the new pfo

Returns: the address of the new pfo

Definition at line 885 of file MasterAlgorithm.cc.

References MultiPandoraApi::AddDaughterPandoraInstance(), lar_content::MasterAlgorithm::CreateWorkerInstance(), lar_content::MasterAlgorithm::m_fullWidthCRWorkerWireGaps, LArContent::RegisterAlgorithms(), LArContent::RegisterBasicPlugins(), and lar_content::MasterAlgorithm::RegisterCustomContent().

Referenced by lar_content::MasterAlgorithm::Reset().

 {
     PandoraContentApi::ParticleFlowObject::Parameters parameters;
     parameters.m_particleId = pInputPfo->GetParticleId();
     parameters.m_charge = pInputPfo->GetCharge();
     parameters.m_mass = pInputPfo->GetMass();
     parameters.m_energy = pInputPfo->GetEnergy();
     parameters.m_momentum = pInputPfo->GetMomentum();
     parameters.m_clusterList = newClusterList;
     parameters.m_trackList.clear();
     parameters.m_vertexList = newVertexList;
     parameters.m_propertiesToAdd = pInputPfo->GetPropertiesMap();
 
     const ParticleFlowObject *pNewPfo(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, parameters, pNewPfo));
 
     return pNewPfo;
 }

const Vertex * lar_content::MasterAlgorithm::CreateVertex ( const pandora::Vertex *const pInputVertex ) const

protectedinherited

Create a new vertex in the current pandora instance, based upon the provided input vertex.

Parameters

pInputVertex the address of the input vertex

Returns: the address of the new vertex

Definition at line 870 of file MasterAlgorithm.cc.

 {
     PandoraContentApi::Vertex::Parameters parameters;
     parameters.m_position = pInputVertex->GetPosition();
     parameters.m_vertexLabel = pInputVertex->GetVertexLabel();
     parameters.m_vertexType = pInputVertex->GetVertexType();
 
     const Vertex *pNewVertex(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pNewVertex));
 
     return pNewVertex;
 }

const pandora::Pandora* lar_content::MasterAlgorithm::CreateWorkerInstance	(	const pandora::LArTPC &	larTPC,
		const pandora::DetectorGapList &	gapList,
		const std::string &	settingsFile,
		const std::string &	name
	)		const

protectedinherited

Create a pandora worker instance to handle a single LArTPC.

Parameters

larTPC	the lar tpc
gapList	the gap list
settingsFile	the pandora settings file
name	the pandora instance name

Returns: the address of the pandora instance

Referenced by lar_content::MasterAlgorithm::CreatePfo(), and lar_content::MasterAlgorithm::InitializeWorkerInstances().

const pandora::Pandora* lar_content::MasterAlgorithm::CreateWorkerInstance	(	const pandora::LArTPCMap &	larTPCMap,
		const pandora::DetectorGapList &	gapList,
		const std::string &	settingsFile,
		const std::string &	name
	)		const

protectedinherited

Create a pandora worker instance to handle a number of LArTPCs.

Parameters

larTPCMap	the lar tpc map
gapList	the gap list
settingsFile	the pandora settings file
name	the pandora instance name

Returns: the address of the pandora instance

StatusCode lar_content::MasterAlgorithm::GetVolumeIdToHitListMap ( VolumeIdToHitListMap & volumeIdToHitListMap ) const

protectedinherited

Get the mapping from lar tpc volume id to lists of all hits, and truncated hits.

Parameters

volumeIdToHitListMap to receive the populated volume id to hit list map

Definition at line 265 of file MasterAlgorithm.cc.

References lar_content::LArCaloHit::GetLArTPCVolumeId(), and lar_content::MasterAlgorithm::m_inputHitListName.

Referenced by lar_content::MasterAlgorithm::Run().

 {
     const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
     const unsigned int nLArTPCs(larTPCMap.size());
 
     const CaloHitList *pCaloHitList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_inputHitListName, pCaloHitList));
 
     for (const CaloHit *const pCaloHit : *pCaloHitList)
     {
         const LArCaloHit *const pLArCaloHit(dynamic_cast<const LArCaloHit *>(pCaloHit));
 
         if (!pLArCaloHit && (1 != nLArTPCs))
             return STATUS_CODE_INVALID_PARAMETER;
 
         const unsigned int volumeId(pLArCaloHit ? pLArCaloHit->GetLArTPCVolumeId() : 0);
         const LArTPC *const pLArTPC(larTPCMap.at(volumeId));
 
         LArTPCHitList &larTPCHitList(volumeIdToHitListMap[volumeId]);
         larTPCHitList.m_allHitList.push_back(pCaloHit);
 
         if (((pCaloHit->GetPositionVector().GetX() >= (pLArTPC->GetCenterX() - 0.5f * pLArTPC->GetWidthX())) &&
                 (pCaloHit->GetPositionVector().GetX() <= (pLArTPC->GetCenterX() + 0.5f * pLArTPC->GetWidthX()))))
         {
             larTPCHitList.m_truncatedHitList.push_back(pCaloHit);
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::InitializeWorkerInstances ( )

protectedinherited

Initialize pandora worker instances.

Definition at line 200 of file MasterAlgorithm.cc.

Referenced by lar_content::MasterAlgorithm::Run().

 {
     // ATTN Used to be in the regular Initialize callback, but detector gap list cannot be extracted in client app before the first event
     if (m_workerInstancesInitialized)
         return STATUS_CODE_ALREADY_INITIALIZED;
 
     try
     {
         const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
         const DetectorGapList &gapList(this->GetPandora().GetGeometry()->GetDetectorGapList());
 
         for (const LArTPCMap::value_type &mapEntry : larTPCMap)
         {
             const unsigned int volumeId(mapEntry.second->GetLArTPCVolumeId());
             m_crWorkerInstances.push_back(
                 this->CreateWorkerInstance(*(mapEntry.second), gapList, m_crSettingsFile, "CRWorkerInstance" + std::to_string(volumeId)));
         }
 
         if (m_shouldRunSlicing)
             m_pSlicingWorkerInstance = this->CreateWorkerInstance(larTPCMap, gapList, m_slicingSettingsFile, "SlicingWorker");
 
         if (m_shouldRunNeutrinoRecoOption)
             m_pSliceNuWorkerInstance = this->CreateWorkerInstance(larTPCMap, gapList, m_nuSettingsFile, "SliceNuWorker");
 
         if (m_shouldRunCosmicRecoOption)
             m_pSliceCRWorkerInstance = this->CreateWorkerInstance(larTPCMap, gapList, m_crSettingsFile, "SliceCRWorker");
     }
     catch (const StatusCodeException &statusCodeException)
     {
         std::cout << "MasterAlgorithm: Exception during initialization of worker instances " << statusCodeException.ToString() << std::endl;
         return statusCodeException.GetStatusCode();
     }
 
     m_workerInstancesInitialized = true;
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::ReadExternalSettings	(	const ExternalSteeringParameters *const	pExternalParameters,
		const pandora::InputBool	inputBool,
		const pandora::TiXmlHandle	xmlHandle,
		const std::string &	xmlTag,
		bool &	outputBool
	)

protectedinherited

Read settings from external steering parameters block, if present, otherwise from xml as standard.

Parameters

pExternalParameters	the address of the external parameters (if present)
inputBool	the input boolean value, from the external parameters (if present)
xmlHandle	the xml handle
xmlTag	the xml tag
outputBool	to receive the output boolean value

Definition at line 1224 of file MasterAlgorithm.cc.

Referenced by lar_content::MasterAlgorithm::ReadSettings().

 {
     if (pExternalParameters && inputBool.IsInitialized())
     {
         outputBool = inputBool.Get();
     }
     else
     {
         PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, xmlTag, outputBool));
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DLMasterAlgorithm::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 37 of file DLMasterAlgorithm.cc.

 {
     return MasterAlgorithm::ReadSettings(xmlHandle);
 }

pandora::StatusCode lar_content::MasterAlgorithm::Recreate	(	const pandora::PfoList &	inputPfoList,
		pandora::PfoList &	newPfoList
	)		const

protectedinherited

Recreate a specified list of pfos in the current pandora instance.

Parameters

inputPfoList	the input pfo list
newPfoList	to receive the list of new pfos

Referenced by lar_content::MasterAlgorithm::RecreateCosmicRayPfos(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::SelectBestSliceHypotheses().

pandora::StatusCode lar_content::MasterAlgorithm::Recreate	(	const pandora::ParticleFlowObject *const	pInputPfo,
		const pandora::ParticleFlowObject *const	pNewParentPfo,
		pandora::PfoList &	newPfoList
	)		const

protectedinherited

Recreate a specified pfo in the current pandora instance.

Parameters

pInputPfo	the input pfo
pNewParentPfo	the new parent of the new output pfo (nullptr if none)
newPfoList	to receive the list of new pfos

StatusCode lar_content::MasterAlgorithm::RecreateCosmicRayPfos ( PfoToLArTPCMap & pfoToLArTPCMap ) const

protectedinherited

Recreate cosmic-ray pfos (created by worker instances) in the master instance.

Parameters

pfoToLArTPCMap to receive the populated pfo to lar tpc map

Definition at line 324 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::m_crWorkerInstances, and lar_content::MasterAlgorithm::Recreate().

Referenced by lar_content::MasterAlgorithm::Run().

 {
     for (const Pandora *const pCRWorker : m_crWorkerInstances)
     {
         const PfoList *pCRPfos(nullptr);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*pCRWorker, pCRPfos));
 
         PfoList newPfoList;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Recreate(*pCRPfos, newPfoList));
 
         const LArTPC &larTPC(pCRWorker->GetGeometry()->GetLArTPC());
 
         for (const Pfo *const pNewPfo : newPfoList)
             pfoToLArTPCMap[pNewPfo] = &larTPC;
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DLMasterAlgorithm::RegisterCustomContent ( const pandora::Pandora *const pPandora ) const

privatevirtual

Register custom content, such as algorithms or algorithm tools, with a specified pandora instance.

Parameters

pPandora the address of the pandora instance

Reimplemented from lar_content::MasterAlgorithm.

Definition at line 28 of file DLMasterAlgorithm.cc.

References LArDLContent::RegisterAlgorithms().

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArDLContent::RegisterAlgorithms(*pPandora));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::Reset ( )

protectedinherited

Reset all worker instances.

Definition at line 628 of file MasterAlgorithm.cc.

Referenced by lar_content::MasterAlgorithm::Run().

 {
     for (const Pandora *const pCRWorker : m_crWorkerInstances)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Reset(*pCRWorker));
 
     if (m_pSlicingWorkerInstance)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Reset(*m_pSlicingWorkerInstance));
 
     if (m_pSliceNuWorkerInstance)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Reset(*m_pSliceNuWorkerInstance));
 
     if (m_pSliceCRWorkerInstance)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Reset(*m_pSliceCRWorkerInstance));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_dl_content::DLMasterAlgorithm::Run ( )

private

Definition at line 21 of file DLMasterAlgorithm.cc.

 {
     return MasterAlgorithm::Run();
 }

StatusCode lar_content::MasterAlgorithm::RunCosmicRayHitRemoval ( const pandora::PfoList & ambiguousPfos ) const

protectedinherited

Run cosmic-ray hit removal, freeing hits in ambiguous pfos for further processing.

Parameters

ambiguousPfos the list of ambiguous cosmic-ray pfos

Definition at line 418 of file MasterAlgorithm.cc.

References lar_content::LArPfoHelper::GetAllConnectedPfos(), lar_content::LArPfoHelper::GetCaloHits(), lar_content::LArPfoHelper::GetIsolatedCaloHits(), and lar_content::LArStitchingHelper::HasPfoBeenStitched().

Referenced by lar_content::MasterAlgorithm::Run().

 {
     PfoList allPfosToDelete;
     LArPfoHelper::GetAllConnectedPfos(ambiguousPfos, allPfosToDelete);
 
     for (const Pfo *const pPfoToDelete : allPfosToDelete)
     {
         const ClusterList clusterList(pPfoToDelete->GetClusterList());
         const VertexList vertexList(pPfoToDelete->GetVertexList());
 
         // ATTN: If an ambiguous pfo has been stitched, reset the calo hit positions in preparation for subsequent algorithm chains
         if (LArStitchingHelper::HasPfoBeenStitched(pPfoToDelete))
         {
             CaloHitList caloHitList2D;
             LArPfoHelper::GetCaloHits(pPfoToDelete, TPC_VIEW_U, caloHitList2D);
             LArPfoHelper::GetCaloHits(pPfoToDelete, TPC_VIEW_V, caloHitList2D);
             LArPfoHelper::GetCaloHits(pPfoToDelete, TPC_VIEW_W, caloHitList2D);
             LArPfoHelper::GetIsolatedCaloHits(pPfoToDelete, TPC_VIEW_U, caloHitList2D);
             LArPfoHelper::GetIsolatedCaloHits(pPfoToDelete, TPC_VIEW_V, caloHitList2D);
             LArPfoHelper::GetIsolatedCaloHits(pPfoToDelete, TPC_VIEW_W, caloHitList2D);
 
             for (const CaloHit *const pCaloHit : caloHitList2D)
             {
                 PandoraContentApi::CaloHit::Metadata metadata;
                 metadata.m_x0 = 0.f;
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::AlterMetadata(*this, pCaloHit, metadata));
             }
         }
 
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*this, pPfoToDelete));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*this, &clusterList));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*this, &vertexList));
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::RunCosmicRayReconstruction ( const VolumeIdToHitListMap & volumeIdToHitListMap ) const

protectedinherited

Run the cosmic-ray reconstruction worker instances.

Parameters

volumeIdToHitListMap the volume id to hit list map

Definition at line 298 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::Copy(), lar_content::MasterAlgorithm::m_crWorkerInstances, lar_content::MasterAlgorithm::m_printOverallRecoStatus, and ProcessEvent().

Referenced by lar_content::MasterAlgorithm::Run().

 {
     unsigned int workerCounter(0);
 
     for (const Pandora *const pCRWorker : m_crWorkerInstances)
     {
         const LArTPC &larTPC(pCRWorker->GetGeometry()->GetLArTPC());
         VolumeIdToHitListMap::const_iterator iter(volumeIdToHitListMap.find(larTPC.GetLArTPCVolumeId()));
 
         if (volumeIdToHitListMap.end() == iter)
             continue;
 
         for (const CaloHit *const pCaloHit : iter->second.m_allHitList)
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Copy(pCRWorker, pCaloHit));
 
         if (m_printOverallRecoStatus)
             std::cout << "Running cosmic-ray reconstruction worker instance " << ++workerCounter << " of " << m_crWorkerInstances.size() << std::endl;
 
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::ProcessEvent(*pCRWorker));
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::RunSliceReconstruction	(	SliceVector &	sliceVector,
		SliceHypotheses &	nuSliceHypotheses,
		SliceHypotheses &	crSliceHypotheses
	)		const

protectedinherited

Process each slice under different reconstruction hypotheses.

Parameters

sliceVector	the slice vector
nuSliceHypotheses	to receive the vector of slice neutrino hypotheses
crSliceHypotheses	to receive the vector of slice cosmic-ray hypotheses

Definition at line 515 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::Copy(), lar_content::MasterAlgorithm::m_printOverallRecoStatus, lar_content::MasterAlgorithm::m_pSliceCRWorkerInstance, lar_content::MasterAlgorithm::m_pSliceNuWorkerInstance, lar_content::MasterAlgorithm::m_shouldRunCosmicRecoOption, lar_content::MasterAlgorithm::m_shouldRunNeutrinoRecoOption, lar_content::MasterAlgorithm::m_shouldRunSlicing, lar_content::MasterAlgorithm::m_sliceSelectionToolVector, and ProcessEvent().

Referenced by lar_content::MasterAlgorithm::Run().

 {
     SliceVector selectedSliceVector;
     if (m_shouldRunSlicing && !m_sliceSelectionToolVector.empty())
     {
         SliceVector inputSliceVector(sliceVector);
         for (SliceSelectionBaseTool *const pSliceSelectionTool : m_sliceSelectionToolVector)
         {
             pSliceSelectionTool->SelectSlices(this, inputSliceVector, selectedSliceVector);
             inputSliceVector = selectedSliceVector;
         }
     }
     else
     {
         selectedSliceVector = std::move(sliceVector);
     }
 
     unsigned int sliceCounter(0);
 
     for (const CaloHitList &sliceHits : selectedSliceVector)
     {
         for (const CaloHit *const pSliceCaloHit : sliceHits)
         {
             // ATTN Must ensure we copy the hit actually owned by master instance; access differs with/without slicing enabled
             const CaloHit *const pCaloHitInMaster(m_shouldRunSlicing ? static_cast<const CaloHit *>(pSliceCaloHit->GetParentAddress()) : pSliceCaloHit);
 
             if (m_shouldRunNeutrinoRecoOption)
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Copy(m_pSliceNuWorkerInstance, pCaloHitInMaster));
 
             if (m_shouldRunCosmicRecoOption)
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Copy(m_pSliceCRWorkerInstance, pCaloHitInMaster));
         }
 
         if (m_shouldRunNeutrinoRecoOption)
         {
             if (m_printOverallRecoStatus)
                 std::cout << "Running nu worker instance for slice " << (sliceCounter + 1) << " of " << selectedSliceVector.size() << std::endl;
 
             const PfoList *pSliceNuPfos(nullptr);
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::ProcessEvent(*m_pSliceNuWorkerInstance));
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*m_pSliceNuWorkerInstance, pSliceNuPfos));
             nuSliceHypotheses.push_back(*pSliceNuPfos);
 
             for (const ParticleFlowObject *const pPfo : *pSliceNuPfos)
             {
                 PandoraContentApi::ParticleFlowObject::Metadata metadata;
                 metadata.m_propertiesToAdd["SliceIndex"] = sliceCounter;
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
             }
         }
 
         if (m_shouldRunCosmicRecoOption)
         {
             if (m_printOverallRecoStatus)
                 std::cout << "Running cr worker instance for slice " << (sliceCounter + 1) << " of " << selectedSliceVector.size() << std::endl;
 
             const PfoList *pSliceCRPfos(nullptr);
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::ProcessEvent(*m_pSliceCRWorkerInstance));
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*m_pSliceCRWorkerInstance, pSliceCRPfos));
             crSliceHypotheses.push_back(*pSliceCRPfos);
 
             for (const ParticleFlowObject *const pPfo : *pSliceCRPfos)
             {
                 PandoraContentApi::ParticleFlowObject::Metadata metadata;
                 metadata.m_propertiesToAdd["SliceIndex"] = sliceCounter;
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
             }
         }
 
         ++sliceCounter;
     }
 
     // ATTN: If we swapped these objects at the start, be sure to swap them back in case we ever want to use sliceVector
     // after this function
     if (!(m_shouldRunSlicing && !m_sliceSelectionToolVector.empty()))
         sliceVector = std::move(selectedSliceVector);
 
     if (m_shouldRunNeutrinoRecoOption && m_shouldRunCosmicRecoOption && (nuSliceHypotheses.size() != crSliceHypotheses.size()))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::RunSlicing	(	const VolumeIdToHitListMap &	volumeIdToHitListMap,
		SliceVector &	sliceVector
	)		const

protectedinherited

Run the event slicing procedures, dividing available hits up into distinct 3D regions.

Parameters

volumeIdToHitListMap	the volume id to hit list map
sliceVector	to receive the populated slice vector

Definition at line 457 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::Copy(), lar_content::LArPfoHelper::GetCaloHits(), lar_content::MasterAlgorithm::m_printOverallRecoStatus, lar_content::MasterAlgorithm::m_pSlicingWorkerInstance, lar_content::MasterAlgorithm::m_shouldRemoveOutOfTimeHits, lar_content::MasterAlgorithm::m_shouldRunSlicing, lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus, and ProcessEvent().

Referenced by lar_content::MasterAlgorithm::Run().

 {
     for (const VolumeIdToHitListMap::value_type &mapEntry : volumeIdToHitListMap)
     {
         for (const CaloHit *const pCaloHit : (m_shouldRemoveOutOfTimeHits ? mapEntry.second.m_truncatedHitList : mapEntry.second.m_allHitList))
         {
             if (!PandoraContentApi::IsAvailable(*this, pCaloHit))
                 continue;
 
             const HitType hitType(pCaloHit->GetHitType());
             if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
                 continue;
 
             if (m_shouldRunSlicing)
             {
                 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Copy(m_pSlicingWorkerInstance, pCaloHit));
             }
             else
             {
                 if (sliceVector.empty())
                     sliceVector.push_back(CaloHitList());
                 sliceVector.back().push_back(pCaloHit);
             }
         }
     }
 
     if (m_shouldRunSlicing)
     {
         if (m_printOverallRecoStatus)
             std::cout << "Running slicing worker instance" << std::endl;
 
         const PfoList *pSlicePfos(nullptr);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::ProcessEvent(*m_pSlicingWorkerInstance));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(*m_pSlicingWorkerInstance, pSlicePfos));
 
         if (m_visualizeOverallRecoStatus)
         {
             PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), pSlicePfos, "OnePfoPerSlice", BLUE));
             PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
         }
 
         for (const Pfo *const pSlicePfo : *pSlicePfos)
         {
             sliceVector.push_back(CaloHitList());
             LArPfoHelper::GetCaloHits(pSlicePfo, TPC_VIEW_U, sliceVector.back());
             LArPfoHelper::GetCaloHits(pSlicePfo, TPC_VIEW_V, sliceVector.back());
             LArPfoHelper::GetCaloHits(pSlicePfo, TPC_VIEW_W, sliceVector.back());
         }
     }
 
     if (m_printOverallRecoStatus)
         std::cout << "Identified " << sliceVector.size() << " slice(s)" << std::endl;
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::SelectBestSliceHypotheses	(	const SliceHypotheses &	nuSliceHypotheses,
		const SliceHypotheses &	crSliceHypotheses
	)		const

protectedinherited

Examine slice hypotheses to identify the most appropriate to provide in final event output.

Parameters

nuSliceHypotheses	the vector of slice neutrino hypotheses
crSliceHypotheses	the vector of slice cosmic-ray hypotheses

Definition at line 600 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::m_printOverallRecoStatus, lar_content::MasterAlgorithm::m_shouldPerformSliceId, lar_content::MasterAlgorithm::m_shouldRunCosmicRecoOption, lar_content::MasterAlgorithm::m_shouldRunNeutrinoRecoOption, lar_content::MasterAlgorithm::m_sliceIdToolVector, and lar_content::MasterAlgorithm::Recreate().

Referenced by lar_content::MasterAlgorithm::Run().

 {
     if (m_printOverallRecoStatus)
         std::cout << "Select best slice hypotheses" << std::endl;
 
     PfoList selectedSlicePfos;
 
     if (m_shouldPerformSliceId)
     {
         for (SliceIdBaseTool *const pSliceIdTool : m_sliceIdToolVector)
             pSliceIdTool->SelectOutputPfos(this, nuSliceHypotheses, crSliceHypotheses, selectedSlicePfos);
     }
     else if (m_shouldRunNeutrinoRecoOption != m_shouldRunCosmicRecoOption)
     {
         const SliceHypotheses &sliceHypotheses(m_shouldRunNeutrinoRecoOption ? nuSliceHypotheses : crSliceHypotheses);
 
         for (const PfoList &slice : sliceHypotheses)
             selectedSlicePfos.insert(selectedSlicePfos.end(), slice.begin(), slice.end());
     }
 
     PfoList newSlicePfoList;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Recreate(selectedSlicePfos, newSlicePfoList));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::MasterAlgorithm::ShiftPfoHierarchy	(	const pandora::ParticleFlowObject *const	pParentPfo,
		const PfoToLArTPCMap &	pfoToLArTPCMap,
		const float	x0
	)		const

inherited

Shift a Pfo hierarchy by a specified x0 value.

Parameters

pPfo	the address of the parent pfo
stitchingInfo	the source for additional, local, stitching information
x0	the x0 correction relative to the input pfo

Definition at line 60 of file MasterAlgorithm.cc.

References lar_content::LArPfoHelper::GetAllDownstreamPfos(), and lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus.

Referenced by lar_content::StitchingCosmicRayMergingTool::ShiftPfo().

 {
     if (!pParentPfo->GetParentPfoList().empty())
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     PfoToLArTPCMap::const_iterator larTPCIter(pfoToLArTPCMap.find(pParentPfo));
 
     if (pfoToLArTPCMap.end() == larTPCIter)
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
     PfoList pfoList;
     LArPfoHelper::GetAllDownstreamPfos(pParentPfo, pfoList);
 
     if (m_visualizeOverallRecoStatus)
     {
         std::cout << "ShiftPfoHierarchy: x0 " << x0 << std::endl;
         PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &pfoList, "BeforeShiftCRPfos", GREEN));
     }
 
     for (const ParticleFlowObject *const pDaughterPfo : pfoList)
     {
         CaloHitList caloHitList;
         for (const Cluster *const pCluster : pDaughterPfo->GetClusterList())
         {
             pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
             caloHitList.insert(caloHitList.end(), pCluster->GetIsolatedCaloHitList().begin(), pCluster->GetIsolatedCaloHitList().end());
         }
 
         for (const CaloHit *const pCaloHit : caloHitList)
         {
             PandoraContentApi::CaloHit::Metadata metadata;
             metadata.m_x0 = x0;
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::AlterMetadata(*this, pCaloHit, metadata));
         }
 
         for (const Vertex *const pVertex : pDaughterPfo->GetVertexList())
         {
             PandoraContentApi::Vertex::Metadata metadata;
             metadata.m_x0 = x0;
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::AlterMetadata(*this, pVertex, metadata));
         }
     }
 
     if (m_visualizeOverallRecoStatus)
     {
         PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &pfoList, "AfterShiftCRPfos", RED));
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 }

StatusCode lar_content::MasterAlgorithm::StitchCosmicRayPfos	(	PfoToLArTPCMap &	pfoToLArTPCMap,
		PfoToFloatMap &	stitchedPfosToX0Map
	)		const

protectedinherited

Stitch together cosmic-ray pfos crossing between adjacent lar tpcs.

Parameters

pfoToLArTPCMap	the pfo to lar tpc map
stitchedPfosToX0Map	to receive the map of cosmic-ray pfos that have been stitched between lar tpcs to the X0 shift

Definition at line 345 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::m_stitchingToolVector, and lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus.

Referenced by lar_content::MasterAlgorithm::Run().

 {
     const PfoList *pRecreatedCRPfos(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(this->GetPandora(), pRecreatedCRPfos));
 
     if (m_visualizeOverallRecoStatus)
     {
         PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), pRecreatedCRPfos, "RecreatedCRPfos", GREEN));
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 
     for (StitchingBaseTool *const pStitchingTool : m_stitchingToolVector)
         pStitchingTool->Run(this, pRecreatedCRPfos, pfoToLArTPCMap, stitchedPfosToX0Map);
 
     if (m_visualizeOverallRecoStatus)
     {
         PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), pRecreatedCRPfos, "AfterStitchingCRPfos", RED));
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::MasterAlgorithm::StitchPfos	(	const pandora::ParticleFlowObject *const	pPfoToEnlarge,
		const pandora::ParticleFlowObject *const	pPfoToDelete,
		PfoToLArTPCMap &	pfoToLArTPCMap
	)		const

inherited

Stitch together a pair of pfos.

Parameters

pPfoToEnlarge	the address of the pfo to enlarge
pPfoToDelete	the address of the pfo to delete (will become a dangling pointer)
stitchingInfo	the source for additional, local, stitching information

Definition at line 112 of file MasterAlgorithm.cc.

References lar_content::LArClusterHelper::GetClusterHitType(), lar_content::PfoMopUpBaseAlgorithm::GetParentCluster(), lar_content::MasterAlgorithm::m_recreatedClusterListName, lar_content::MasterAlgorithm::m_recreatedPfoListName, and lar_content::MasterAlgorithm::m_recreatedVertexListName.

Referenced by lar_content::StitchingCosmicRayMergingTool::StitchPfos().

 {
     if (pPfoToEnlarge == pPfoToDelete)
         throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
 
     // ATTN Remove pfos from pfo to lar tpc map here, avoiding problems if stitching across multiple tpcs.
     pfoToLArTPCMap.erase(pPfoToEnlarge);
     pfoToLArTPCMap.erase(pPfoToDelete);
 
     const PfoList daughterPfos(pPfoToDelete->GetDaughterPfoList());
     const ClusterVector daughterClusters(pPfoToDelete->GetClusterList().begin(), pPfoToDelete->GetClusterList().end());
     const VertexVector daughterVertices(pPfoToDelete->GetVertexList().begin(), pPfoToDelete->GetVertexList().end());
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*this, pPfoToDelete, m_recreatedPfoListName));
 
     for (const ParticleFlowObject *const pDaughterPfo : daughterPfos)
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pPfoToEnlarge, pDaughterPfo));
 
     for (const Vertex *const pDaughterVertex : daughterVertices)
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Delete(*this, pDaughterVertex, m_recreatedVertexListName));
 
     for (const Cluster *const pDaughterCluster : daughterClusters)
     {
         const HitType daughterHitType(LArClusterHelper::GetClusterHitType(pDaughterCluster));
         const Cluster *pParentCluster(PfoMopUpBaseAlgorithm::GetParentCluster(pPfoToEnlarge->GetClusterList(), daughterHitType));
 
         if (pParentCluster)
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
                 PandoraContentApi::MergeAndDeleteClusters(*this, pParentCluster, pDaughterCluster, m_recreatedClusterListName, m_recreatedClusterListName));
         }
         else
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*this, pPfoToEnlarge, pDaughterCluster));
         }
     }
 }

StatusCode lar_content::MasterAlgorithm::TagCosmicRayPfos	(	const PfoToFloatMap &	stitchedPfosToX0Map,
		pandora::PfoList &	clearCosmicRayPfos,
		pandora::PfoList &	ambiguousPfos
	)		const

protectedinherited

Tag clear, unambiguous cosmic-ray pfos.

Parameters

stitchedPfosToX0Map	a map of cosmic-ray pfos that have been stitched between lar tpcs to the X0 shift
clearCosmicRayPfos	to receive the list of clear cosmic-ray pfos
ambiguousPfos	to receive the list of ambiguous cosmic-ray pfos for further analysis

Definition at line 370 of file MasterAlgorithm.cc.

References lar_content::MasterAlgorithm::m_cosmicRayTaggingToolVector, lar_content::MasterAlgorithm::m_inTimeMaxX0, and lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus.

Referenced by lar_content::MasterAlgorithm::Run().

 {
     const PfoList *pRecreatedCRPfos(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::GetCurrentPfoList(this->GetPandora(), pRecreatedCRPfos));
 
     PfoList nonStitchedParentCosmicRayPfos;
     for (const Pfo *const pPfo : *pRecreatedCRPfos)
     {
         if (!pPfo->GetParentPfoList().empty())
             continue;
 
         PfoToFloatMap::const_iterator pfoToX0Iter = stitchedPfosToX0Map.find(pPfo);
         const float x0Shift((pfoToX0Iter != stitchedPfosToX0Map.end()) ? pfoToX0Iter->second : 0.f);
         PfoList &targetList((std::fabs(x0Shift) > m_inTimeMaxX0) ? clearCosmicRayPfos : nonStitchedParentCosmicRayPfos);
         targetList.push_back(pPfo);
     }
 
     for (CosmicRayTaggingBaseTool *const pCosmicRayTaggingTool : m_cosmicRayTaggingToolVector)
         pCosmicRayTaggingTool->FindAmbiguousPfos(nonStitchedParentCosmicRayPfos, ambiguousPfos, this);
 
     for (const Pfo *const pPfo : nonStitchedParentCosmicRayPfos)
     {
         const bool isClearCosmic(ambiguousPfos.end() == std::find(ambiguousPfos.begin(), ambiguousPfos.end(), pPfo));
 
         if (isClearCosmic)
             clearCosmicRayPfos.push_back(pPfo);
     }
 
     for (const Pfo *const pPfo : *pRecreatedCRPfos)
     {
         const bool isClearCosmic(ambiguousPfos.end() == std::find(ambiguousPfos.begin(), ambiguousPfos.end(), pPfo));
         PandoraContentApi::ParticleFlowObject::Metadata metadata;
         metadata.m_propertiesToAdd["IsClearCosmic"] = (isClearCosmic ? 1.f : 0.f);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
     }
 
     if (m_visualizeOverallRecoStatus)
     {
         PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &clearCosmicRayPfos, "ClearCRPfos", RED));
         PANDORA_MONITORING_API(VisualizeParticleFlowObjects(this->GetPandora(), &ambiguousPfos, "AmbiguousCRPfos", BLUE));
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

CosmicRayTaggingToolVector lar_content::MasterAlgorithm::m_cosmicRayTaggingToolVector

protectedinherited

The cosmic-ray tagging tool vector.

Definition at line 340 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::TagCosmicRayPfos().

std::string lar_content::MasterAlgorithm::m_crSettingsFile

protectedinherited

The cosmic-ray reconstruction settings file.

Definition at line 345 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), and lar_content::MasterAlgorithm::ReadSettings().

PandoraInstanceList lar_content::MasterAlgorithm::m_crWorkerInstances

protectedinherited

The list of cosmic-ray reconstruction worker instances.

Definition at line 326 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::CopyMCParticles(), lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::RecreateCosmicRayPfos(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::RunCosmicRayReconstruction().

std::string lar_content::MasterAlgorithm::m_filePathEnvironmentVariable

protectedinherited

The environment variable providing a list of paths to xml files.

Definition at line 344 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings().

bool lar_content::MasterAlgorithm::m_fullWidthCRWorkerWireGaps

protectedinherited

Whether wire-type line gaps in cosmic-ray worker instances should cover all drift time.

Definition at line 331 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::CreatePfo(), and lar_content::MasterAlgorithm::ReadSettings().

std::string lar_content::MasterAlgorithm::m_inputHitListName

protectedinherited

The input hit list name.

Definition at line 350 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::GetVolumeIdToHitListMap(), and lar_content::MasterAlgorithm::ReadSettings().

std::string lar_content::MasterAlgorithm::m_inputMCParticleListName

protectedinherited

The input mc particle list name.

Definition at line 349 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::CopyMCParticles(), and lar_content::MasterAlgorithm::ReadSettings().

float lar_content::MasterAlgorithm::m_inTimeMaxX0

protectedinherited

Cut on X0 to determine whether particle is clear cosmic ray.

Definition at line 355 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::TagCosmicRayPfos().

LArCaloHitFactory lar_content::MasterAlgorithm::m_larCaloHitFactory

protectedinherited

Factory for creating LArCaloHits during hit copying.

Definition at line 356 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::Reset().

unsigned int lar_content::MasterAlgorithm::m_larCaloHitVersion

protectedinherited

The LArCaloHit version for LArCaloHitFactory.

Definition at line 313 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings().

std::string lar_content::MasterAlgorithm::m_nuSettingsFile

protectedinherited

The neutrino reconstruction settings file.

Definition at line 346 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), and lar_content::MasterAlgorithm::ReadSettings().

bool lar_content::MasterAlgorithm::m_passMCParticlesToWorkerInstances

protectedinherited

Whether to pass mc particle details (and links to calo hits) to worker instances.

Definition at line 332 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::Run().

bool lar_content::MasterAlgorithm::m_printOverallRecoStatus

protectedinherited

Whether to print current operation status messages.

Definition at line 322 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::RunCosmicRayReconstruction(), lar_content::MasterAlgorithm::RunSliceReconstruction(), lar_content::MasterAlgorithm::RunSlicing(), and lar_content::MasterAlgorithm::SelectBestSliceHypotheses().

const pandora::Pandora* lar_content::MasterAlgorithm::m_pSliceCRWorkerInstance

protectedinherited

The per-slice cosmic-ray reconstruction worker instance.

Definition at line 329 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::CopyMCParticles(), lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::RunSliceReconstruction().

const pandora::Pandora* lar_content::MasterAlgorithm::m_pSliceNuWorkerInstance

protectedinherited

The per-slice neutrino reconstruction worker instance.

Definition at line 328 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::CopyMCParticles(), lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::RunSliceReconstruction().

const pandora::Pandora* lar_content::MasterAlgorithm::m_pSlicingWorkerInstance

protectedinherited

The slicing worker instance.

Definition at line 327 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::CopyMCParticles(), lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::RunSlicing().

std::string lar_content::MasterAlgorithm::m_recreatedClusterListName

protectedinherited

The output recreated cluster list name.

Definition at line 352 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::StitchPfos().

std::string lar_content::MasterAlgorithm::m_recreatedPfoListName

protectedinherited

The output recreated pfo list name.

Definition at line 351 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::StitchPfos().

std::string lar_content::MasterAlgorithm::m_recreatedVertexListName

protectedinherited

The output recreated vertex list name.

Definition at line 353 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::Reset(), and lar_content::MasterAlgorithm::StitchPfos().

bool lar_content::MasterAlgorithm::m_shouldPerformSliceId

protectedinherited

Whether to identify slices and select most appropriate pfos.

Definition at line 321 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::SelectBestSliceHypotheses().

bool lar_content::MasterAlgorithm::m_shouldRemoveOutOfTimeHits

protectedinherited

Whether to remove out of time hits.

Definition at line 324 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::RunSlicing().

bool lar_content::MasterAlgorithm::m_shouldRunAllHitsCosmicReco

protectedinherited

Whether to run all hits cosmic-ray reconstruction.

Definition at line 315 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::Run().

bool lar_content::MasterAlgorithm::m_shouldRunCosmicHitRemoval

protectedinherited

Whether to remove hits from tagged cosmic-rays.

Definition at line 317 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::Run().

bool lar_content::MasterAlgorithm::m_shouldRunCosmicRecoOption

protectedinherited

Whether to run cosmic-ray reconstruction for each slice.

Definition at line 320 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::Run(), lar_content::MasterAlgorithm::RunSliceReconstruction(), and lar_content::MasterAlgorithm::SelectBestSliceHypotheses().

bool lar_content::MasterAlgorithm::m_shouldRunNeutrinoRecoOption

protectedinherited

Whether to run neutrino reconstruction for each slice.

Definition at line 319 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::Run(), lar_content::MasterAlgorithm::RunSliceReconstruction(), and lar_content::MasterAlgorithm::SelectBestSliceHypotheses().

bool lar_content::MasterAlgorithm::m_shouldRunSlicing

protectedinherited

Whether to slice events into separate regions for processing.

Definition at line 318 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::RunSliceReconstruction(), and lar_content::MasterAlgorithm::RunSlicing().

bool lar_content::MasterAlgorithm::m_shouldRunStitching

protectedinherited

Whether to stitch cosmic-ray muons crossing between volumes.

Definition at line 316 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::Run().

SliceIdToolVector lar_content::MasterAlgorithm::m_sliceIdToolVector

protectedinherited

The slice id tool vector.

Definition at line 341 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::SelectBestSliceHypotheses().

SliceSelectionToolVector lar_content::MasterAlgorithm::m_sliceSelectionToolVector

protectedinherited

The slice selection tool vector.

Definition at line 342 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::RunSliceReconstruction().

std::string lar_content::MasterAlgorithm::m_slicingSettingsFile

protectedinherited

The slicing settings file.

Definition at line 347 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), and lar_content::MasterAlgorithm::ReadSettings().

StitchingToolVector lar_content::MasterAlgorithm::m_stitchingToolVector

protectedinherited

The stitching tool vector.

Definition at line 339 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), and lar_content::MasterAlgorithm::StitchCosmicRayPfos().

bool lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus

protectedinherited

Whether to display results of current operations.

Definition at line 323 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::ReadSettings(), lar_content::MasterAlgorithm::RunSlicing(), lar_content::MasterAlgorithm::ShiftPfoHierarchy(), lar_content::MasterAlgorithm::StitchCosmicRayPfos(), and lar_content::MasterAlgorithm::TagCosmicRayPfos().

bool lar_content::MasterAlgorithm::m_workerInstancesInitialized

protectedinherited

Whether all worker instances have been initialized.

Definition at line 311 of file MasterAlgorithm.h.

Referenced by lar_content::MasterAlgorithm::InitializeWorkerInstances(), and lar_content::MasterAlgorithm::Run().

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

larpandoracontent/v04_08_01/source/larpandoradlcontent/LArControlFlow/DLMasterAlgorithm.h
larpandoracontent/v04_08_01/source/larpandoradlcontent/LArControlFlow/DLMasterAlgorithm.cc

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation