#include <MasterAlgorithm.h>

Inheritance diagram for lar_content::MasterAlgorithm:

Classes
class	ExternalSteeringParameters
	External steering parameters class. More...

class	LArTPCHitList
	LArTPCHitList class. More...

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

Public Member Functions
	MasterAlgorithm ()
	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	Run ()

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

virtual 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)

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

Detailed Description

MasterAlgorithm class.

Definition at line 38 of file MasterAlgorithm.h.

Member Typedef Documentation

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

protected

Definition at line 334 of file MasterAlgorithm.h.

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

Definition at line 62 of file MasterAlgorithm.h.

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

protected

Definition at line 335 of file MasterAlgorithm.h.

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

protected

Definition at line 336 of file MasterAlgorithm.h.

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

protected

Definition at line 333 of file MasterAlgorithm.h.

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

protected

Definition at line 94 of file MasterAlgorithm.h.

Constructor & Destructor Documentation

lar_content::MasterAlgorithm::MasterAlgorithm ( )

Default constructor.

Definition at line 35 of file MasterAlgorithm.cc.

                                  :
     m_workerInstancesInitialized(false),
     m_larCaloHitVersion(1),
     m_shouldRunAllHitsCosmicReco(true),
     m_shouldRunStitching(true),
     m_shouldRunCosmicHitRemoval(true),
     m_shouldRunSlicing(true),
     m_shouldRunNeutrinoRecoOption(true),
     m_shouldRunCosmicRecoOption(true),
     m_shouldPerformSliceId(true),
     m_printOverallRecoStatus(false),
     m_visualizeOverallRecoStatus(false),
     m_shouldRemoveOutOfTimeHits(true),
     m_pSlicingWorkerInstance(nullptr),
     m_pSliceNuWorkerInstance(nullptr),
     m_pSliceCRWorkerInstance(nullptr),
     m_fullWidthCRWorkerWireGaps(true),
     m_passMCParticlesToWorkerInstances(false),
     m_filePathEnvironmentVariable("FW_SEARCH_PATH"),
     m_inTimeMaxX0(1.f)
 {
 }

Member Function Documentation

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

protected

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

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

protected

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

protected

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

Definition at line 239 of file MasterAlgorithm.cc.

 {
     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

protected

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.

 {
     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

protected

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

protected

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.

 {
     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

protected

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

protected

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

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

protected

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

protected

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.

 {
     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 ( )

protected

Initialize pandora worker instances.

Definition at line 200 of file MasterAlgorithm.cc.

 {
     // 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
	)

protected

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 1223 of file MasterAlgorithm.cc.

 {
     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_content::MasterAlgorithm::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

protected

Definition at line 1063 of file MasterAlgorithm.cc.

 {
     ExternalSteeringParameters *pExternalParameters(nullptr);
 
     if (this->ExternalParametersPresent())
     {
         pExternalParameters = dynamic_cast<ExternalSteeringParameters *>(this->GetExternalParameters());
         if (!pExternalParameters)
             return STATUS_CODE_FAILURE;
     }
 
     {
         AlgorithmToolVector algorithmToolVector;
         PANDORA_RETURN_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "SliceSelectionTools", algorithmToolVector));
 
         for (AlgorithmTool *const pAlgorithmTool : algorithmToolVector)
         {
             SliceSelectionBaseTool *const pSliceSelectionTool(dynamic_cast<SliceSelectionBaseTool *>(pAlgorithmTool));
             if (!pSliceSelectionTool)
                 return STATUS_CODE_INVALID_PARAMETER;
             m_sliceSelectionToolVector.push_back(pSliceSelectionTool);
         }
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldRunAllHitsCosmicReco,
             xmlHandle, "ShouldRunAllHitsCosmicReco", m_shouldRunAllHitsCosmicReco));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldRunStitching,
             xmlHandle, "ShouldRunStitching", m_shouldRunStitching));
 
     if (m_shouldRunStitching && !m_shouldRunAllHitsCosmicReco)
     {
         std::cout << "MasterAlgorithm::ReadSettings - ShouldRunStitching requires ShouldRunAllHitsCosmicReco to be true" << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     if (m_shouldRunStitching)
     {
         AlgorithmToolVector algorithmToolVector;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "StitchingTools", algorithmToolVector));
 
         for (AlgorithmTool *const pAlgorithmTool : algorithmToolVector)
         {
             StitchingBaseTool *const pStitchingTool(dynamic_cast<StitchingBaseTool *>(pAlgorithmTool));
             if (!pStitchingTool)
                 return STATUS_CODE_INVALID_PARAMETER;
             m_stitchingToolVector.push_back(pStitchingTool);
         }
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldRunCosmicHitRemoval,
             xmlHandle, "ShouldRunCosmicHitRemoval", m_shouldRunCosmicHitRemoval));
 
     if (m_shouldRunCosmicHitRemoval && !m_shouldRunAllHitsCosmicReco)
     {
         std::cout << "MasterAlgorithm::ReadSettings - ShouldRunCosmicHitRemoval requires ShouldRunAllHitsCosmicReco to be true" << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     if (m_shouldRunCosmicHitRemoval)
     {
         AlgorithmToolVector algorithmToolVector;
         PANDORA_RETURN_RESULT_IF(
             STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "CosmicRayTaggingTools", algorithmToolVector));
 
         for (AlgorithmTool *const pAlgorithmTool : algorithmToolVector)
         {
             CosmicRayTaggingBaseTool *const pCosmicRayTaggingTool(dynamic_cast<CosmicRayTaggingBaseTool *>(pAlgorithmTool));
             if (!pCosmicRayTaggingTool)
                 return STATUS_CODE_INVALID_PARAMETER;
             m_cosmicRayTaggingToolVector.push_back(pCosmicRayTaggingTool);
         }
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldRunSlicing,
             xmlHandle, "ShouldRunSlicing", m_shouldRunSlicing));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldRunNeutrinoRecoOption,
             xmlHandle, "ShouldRunNeutrinoRecoOption", m_shouldRunNeutrinoRecoOption));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldRunCosmicRecoOption,
             xmlHandle, "ShouldRunCosmicRecoOption", m_shouldRunCosmicRecoOption));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_shouldPerformSliceId,
             xmlHandle, "ShouldPerformSliceId", m_shouldPerformSliceId));
 
     if (m_shouldPerformSliceId && (!m_shouldRunSlicing || !m_shouldRunNeutrinoRecoOption || !m_shouldRunCosmicRecoOption))
     {
         std::cout << "MasterAlgorithm::ReadSettings - ShouldPerformSliceId requires ShouldRunSlicing and both neutrino and cosmic reconstruction options"
                   << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     if (m_shouldPerformSliceId)
     {
         AlgorithmToolVector algorithmToolVector;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "SliceIdTools", algorithmToolVector));
 
         for (AlgorithmTool *const pAlgorithmTool : algorithmToolVector)
         {
             SliceIdBaseTool *const pSliceIdIdTool(dynamic_cast<SliceIdBaseTool *>(pAlgorithmTool));
             if (!pSliceIdIdTool)
                 return STATUS_CODE_INVALID_PARAMETER;
             m_sliceIdToolVector.push_back(pSliceIdIdTool);
         }
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         this->ReadExternalSettings(pExternalParameters, !pExternalParameters ? InputBool() : pExternalParameters->m_printOverallRecoStatus,
             xmlHandle, "PrintOverallRecoStatus", m_printOverallRecoStatus));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "VisualizeOverallRecoStatus", m_visualizeOverallRecoStatus));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "LArCaloHitVersion", m_larCaloHitVersion));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ShouldRemoveOutOfTimeHits", m_shouldRemoveOutOfTimeHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "FullWidthCRWorkerWireGaps", m_fullWidthCRWorkerWireGaps));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "PassMCParticlesToWorkerInstances", m_passMCParticlesToWorkerInstances));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "FilePathEnvironmentVariable", m_filePathEnvironmentVariable));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CRSettingsFile", m_crSettingsFile));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "NuSettingsFile", m_nuSettingsFile));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "SlicingSettingsFile", m_slicingSettingsFile));
     m_crSettingsFile = LArFileHelper::FindFileInPath(m_crSettingsFile, m_filePathEnvironmentVariable);
     m_nuSettingsFile = LArFileHelper::FindFileInPath(m_nuSettingsFile, m_filePathEnvironmentVariable);
     m_slicingSettingsFile = LArFileHelper::FindFileInPath(m_slicingSettingsFile, m_filePathEnvironmentVariable);
 
     if (m_passMCParticlesToWorkerInstances)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputMCParticleListName", m_inputMCParticleListName));
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputHitListName", m_inputHitListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "RecreatedPfoListName", m_recreatedPfoListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "RecreatedClusterListName", m_recreatedClusterListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "RecreatedVertexListName", m_recreatedVertexListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "InTimeMaxX0", m_inTimeMaxX0));
 
     return STATUS_CODE_SUCCESS;
 }

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

protected

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

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

protected

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

protected

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.

 {
     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_content::MasterAlgorithm::RegisterCustomContent ( const pandora::Pandora *const pPandora ) const

protectedvirtual

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

Parameters

pPandora the address of the pandora instance

Reimplemented in lar_dl_content::DLMasterAlgorithm.

Definition at line 1056 of file MasterAlgorithm.cc.

 {
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::MasterAlgorithm::Reset ( void )

protected

Reset all worker instances.

Definition at line 628 of file MasterAlgorithm.cc.

 {
     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_content::MasterAlgorithm::Run ( )

protected

Definition at line 153 of file MasterAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->Reset());
 
     if (!m_workerInstancesInitialized)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->InitializeWorkerInstances());
 
     if (m_passMCParticlesToWorkerInstances)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->CopyMCParticles());
 
     PfoToFloatMap stitchedPfosToX0Map;
     VolumeIdToHitListMap volumeIdToHitListMap;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetVolumeIdToHitListMap(volumeIdToHitListMap));
 
     if (m_shouldRunAllHitsCosmicReco)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RunCosmicRayReconstruction(volumeIdToHitListMap));
 
         PfoToLArTPCMap pfoToLArTPCMap;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RecreateCosmicRayPfos(pfoToLArTPCMap));
 
         if (m_shouldRunStitching)
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->StitchCosmicRayPfos(pfoToLArTPCMap, stitchedPfosToX0Map));
     }
 
     if (m_shouldRunCosmicHitRemoval)
     {
         PfoList clearCosmicRayPfos, ambiguousPfos;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->TagCosmicRayPfos(stitchedPfosToX0Map, clearCosmicRayPfos, ambiguousPfos));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RunCosmicRayHitRemoval(ambiguousPfos));
     }
 
     SliceVector sliceVector;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RunSlicing(volumeIdToHitListMap, sliceVector));
 
     if (m_shouldRunNeutrinoRecoOption || m_shouldRunCosmicRecoOption)
     {
         SliceHypotheses nuSliceHypotheses, crSliceHypotheses;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RunSliceReconstruction(sliceVector, nuSliceHypotheses, crSliceHypotheses));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->SelectBestSliceHypotheses(nuSliceHypotheses, crSliceHypotheses));
     }
 
     return STATUS_CODE_SUCCESS;
 }

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

protected

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.

 {
     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

protected

Run the cosmic-ray reconstruction worker instances.

Parameters

volumeIdToHitListMap the volume id to hit list map

Definition at line 298 of file MasterAlgorithm.cc.

 {
     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

protected

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.

 {
     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

protected

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.

 {
     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

protected

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.

 {
     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

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.

 {
     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

protected

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.

 {
     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

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.

 {
     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

protected

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.

 {
     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

protected

The cosmic-ray tagging tool vector.

Definition at line 339 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_crSettingsFile

protected

The cosmic-ray reconstruction settings file.

Definition at line 344 of file MasterAlgorithm.h.

PandoraInstanceList lar_content::MasterAlgorithm::m_crWorkerInstances

protected

The list of cosmic-ray reconstruction worker instances.

Definition at line 325 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_filePathEnvironmentVariable

protected

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

Definition at line 343 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_fullWidthCRWorkerWireGaps

protected

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

Definition at line 330 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_inputHitListName

protected

The input hit list name.

Definition at line 349 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_inputMCParticleListName

protected

The input mc particle list name.

Definition at line 348 of file MasterAlgorithm.h.

float lar_content::MasterAlgorithm::m_inTimeMaxX0

protected

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

Definition at line 354 of file MasterAlgorithm.h.

LArCaloHitFactory lar_content::MasterAlgorithm::m_larCaloHitFactory

protected

Factory for creating LArCaloHits during hit copying.

Definition at line 355 of file MasterAlgorithm.h.

unsigned int lar_content::MasterAlgorithm::m_larCaloHitVersion

protected

The LArCaloHit version for LArCaloHitFactory.

Definition at line 312 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_nuSettingsFile

protected

The neutrino reconstruction settings file.

Definition at line 345 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_passMCParticlesToWorkerInstances

protected

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

Definition at line 331 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_printOverallRecoStatus

protected

Whether to print current operation status messages.

Definition at line 321 of file MasterAlgorithm.h.

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

protected

The per-slice cosmic-ray reconstruction worker instance.

Definition at line 328 of file MasterAlgorithm.h.

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

protected

The per-slice neutrino reconstruction worker instance.

Definition at line 327 of file MasterAlgorithm.h.

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

protected

The slicing worker instance.

Definition at line 326 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_recreatedClusterListName

protected

The output recreated cluster list name.

Definition at line 351 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_recreatedPfoListName

protected

The output recreated pfo list name.

Definition at line 350 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_recreatedVertexListName

protected

The output recreated vertex list name.

Definition at line 352 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldPerformSliceId

protected

Whether to identify slices and select most appropriate pfos.

Definition at line 320 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRemoveOutOfTimeHits

protected

Whether to remove out of time hits.

Definition at line 323 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRunAllHitsCosmicReco

protected

Whether to run all hits cosmic-ray reconstruction.

Definition at line 314 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRunCosmicHitRemoval

protected

Whether to remove hits from tagged cosmic-rays.

Definition at line 316 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRunCosmicRecoOption

protected

Whether to run cosmic-ray reconstruction for each slice.

Definition at line 319 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRunNeutrinoRecoOption

protected

Whether to run neutrino reconstruction for each slice.

Definition at line 318 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRunSlicing

protected

Whether to slice events into separate regions for processing.

Definition at line 317 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_shouldRunStitching

protected

Whether to stitch cosmic-ray muons crossing between volumes.

Definition at line 315 of file MasterAlgorithm.h.

SliceIdToolVector lar_content::MasterAlgorithm::m_sliceIdToolVector

protected

The slice id tool vector.

Definition at line 340 of file MasterAlgorithm.h.

SliceSelectionToolVector lar_content::MasterAlgorithm::m_sliceSelectionToolVector

protected

The slice selection tool vector.

Definition at line 341 of file MasterAlgorithm.h.

std::string lar_content::MasterAlgorithm::m_slicingSettingsFile

protected

The slicing settings file.

Definition at line 346 of file MasterAlgorithm.h.

StitchingToolVector lar_content::MasterAlgorithm::m_stitchingToolVector

protected

The stitching tool vector.

Definition at line 338 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus

protected

Whether to display results of current operations.

Definition at line 322 of file MasterAlgorithm.h.

bool lar_content::MasterAlgorithm::m_workerInstancesInitialized

protected

Whether all worker instances have been initialized.

Definition at line 310 of file MasterAlgorithm.h.

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

larpandoracontent/larpandoracontent/LArControlFlow/MasterAlgorithm.h
larpandoracontent/larpandoracontent/LArControlFlow/MasterAlgorithm.cc

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation