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

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

typedef std::vector< StitchingBaseTool * >	StitchingToolVector

typedef std::vector< CosmicRayTaggingBaseTool * >	CosmicRayTaggingToolVector

typedef std::vector< SliceIdBaseTool * >	SliceIdToolVector

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

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

Private Attributes
bool	m_workerInstancesInitialized
	Whether all worker instances have been initialized. 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...

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

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

Detailed Description

MasterAlgorithm class.

Definition at line 36 of file MasterAlgorithm.h.

Member Typedef Documentation

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

private

Definition at line 320 of file MasterAlgorithm.h.

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

Definition at line 60 of file MasterAlgorithm.h.

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

private

Definition at line 321 of file MasterAlgorithm.h.

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

private

Definition at line 319 of file MasterAlgorithm.h.

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

private

Definition at line 92 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_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_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

private

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 CopyMCParticles(), Reset(), RunCosmicRayReconstruction(), RunSliceReconstruction(), and RunSlicing().

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

private

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

private

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

Definition at line 237 of file MasterAlgorithm.cc.

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

Referenced by 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

private

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

Referenced by 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

private

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

private

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

References MultiPandoraApi::AddDaughterPandoraInstance(), CreateWorkerInstance(), m_fullWidthCRWorkerWireGaps, max, min, LArContent::RegisterAlgorithms(), and LArContent::RegisterBasicPlugins().

Referenced by 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

private

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

private

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 CreatePfo(), and 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

private

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

private

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

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

Referenced by 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 ( )

private

Initialize pandora worker instances.

Definition at line 199 of file MasterAlgorithm.cc.

References CreateWorkerInstance(), m_crSettingsFile, m_crWorkerInstances, m_nuSettingsFile, m_pSliceCRWorkerInstance, m_pSliceNuWorkerInstance, m_pSlicingWorkerInstance, m_shouldRunCosmicRecoOption, m_shouldRunNeutrinoRecoOption, m_shouldRunSlicing, m_slicingSettingsFile, m_workerInstancesInitialized, and util::flags::to_string().

Referenced by 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
	)

private

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

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

private

Definition at line 1026 of file MasterAlgorithm.cc.

 {
     ExternalSteeringParameters *pExternalParameters(nullptr);
 
     if (this->ExternalParametersPresent())
     {
         pExternalParameters = dynamic_cast<ExternalSteeringParameters*>(this->GetExternalParameters());
         if (!pExternalParameters) return STATUS_CODE_FAILURE;
     }
 
     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,
         "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

private

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 RecreateCosmicRayPfos(), Reset(), and SelectBestSliceHypotheses().

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

private

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

private

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

References m_crWorkerInstances, and Recreate().

Referenced by 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_content::MasterAlgorithm::Reset ( )

private

Reset all worker instances.

Definition at line 582 of file MasterAlgorithm.cc.

References Copy(), CreateCaloHit(), CreatePfo(), lar_content::LArMCParticle::GetNuanceCode(), lar_content::LArPfoHelper::GetThreeDClusterList(), lar_content::LArPfoHelper::GetTwoDClusterList(), m_crWorkerInstances, lar_content::LArMCParticleParameters::m_nuanceCode, m_passMCParticlesToWorkerInstances, m_pSliceCRWorkerInstance, m_pSliceNuWorkerInstance, m_pSlicingWorkerInstance, m_recreatedClusterListName, m_recreatedPfoListName, m_recreatedVertexListName, Recreate(), Reset(), and lar_content::LArMCParticleHelper::SortByMomentum().

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

private

Definition at line 152 of file MasterAlgorithm.cc.

References CopyMCParticles(), GetVolumeIdToHitListMap(), InitializeWorkerInstances(), m_passMCParticlesToWorkerInstances, m_shouldRunAllHitsCosmicReco, m_shouldRunCosmicHitRemoval, m_shouldRunCosmicRecoOption, m_shouldRunNeutrinoRecoOption, m_shouldRunStitching, m_workerInstancesInitialized, RecreateCosmicRayPfos(), Reset(), RunCosmicRayHitRemoval(), RunCosmicRayReconstruction(), RunSliceReconstruction(), RunSlicing(), SelectBestSliceHypotheses(), StitchCosmicRayPfos(), and TagCosmicRayPfos().

 {
     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

private

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

References lar_content::LArPfoHelper::GetAllConnectedPfos().

Referenced by Run().

 {
     PfoList allPfosToDelete;
     LArPfoHelper::GetAllConnectedPfos(ambiguousPfos, allPfosToDelete);
 
     for (const Pfo *const pPfoToDelete : allPfosToDelete)
     {
         const ClusterList clusterList(pPfoToDelete->GetClusterList());
         const VertexList vertexList(pPfoToDelete->GetVertexList());
         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

private

Run the cosmic-ray reconstruction worker instances.

Parameters

volumeIdToHitListMap the volume id to hit list map

Definition at line 293 of file MasterAlgorithm.cc.

References Copy(), m_crWorkerInstances, m_printOverallRecoStatus, and ProcessEvent().

Referenced by 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

private

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

References Copy(), m_printOverallRecoStatus, m_pSliceCRWorkerInstance, m_pSliceNuWorkerInstance, m_shouldRunCosmicRecoOption, m_shouldRunNeutrinoRecoOption, m_shouldRunSlicing, and ProcessEvent().

Referenced by Run().

 {
     unsigned int sliceCounter(0);
 
     for (const CaloHitList &sliceHits : sliceVector)
     {
         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 " << sliceVector.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 " << sliceVector.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;
     }
 
     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

private

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

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

Referenced by Run().

 {
     for (const VolumeIdToHitListMap::value_type &mapEntry : volumeIdToHitListMap)
     {
         for (const CaloHit *const pCaloHit : mapEntry.second.m_truncatedHitList)
         {
             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

private

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

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

Referenced by 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

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

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

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

 {
     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);
     const float signedX0(larTPCIter->second->IsDriftInPositiveX() ? -x0 : x0);
 
     if (m_visualizeOverallRecoStatus)
     {
         std::cout << "ShiftPfoHierarchy: signedX0 " << signedX0 << 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 = signedX0;
             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 = signedX0;
             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

private

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

References m_stitchingToolVector, and m_visualizeOverallRecoStatus.

Referenced by 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

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

References lar_content::LArClusterHelper::GetClusterHitType(), lar_content::PfoMopUpBaseAlgorithm::GetParentCluster(), m_recreatedClusterListName, m_recreatedPfoListName, and 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

private

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

References m_cosmicRayTaggingToolVector, m_inTimeMaxX0, and m_visualizeOverallRecoStatus.

Referenced by 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

private

The cosmic-ray tagging tool vector.

Definition at line 324 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and TagCosmicRayPfos().

std::string lar_content::MasterAlgorithm::m_crSettingsFile

private

The cosmic-ray reconstruction settings file.

Definition at line 328 of file MasterAlgorithm.h.

Referenced by InitializeWorkerInstances(), and ReadSettings().

PandoraInstanceList lar_content::MasterAlgorithm::m_crWorkerInstances

private

The list of cosmic-ray reconstruction worker instances.

Definition at line 311 of file MasterAlgorithm.h.

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

std::string lar_content::MasterAlgorithm::m_filePathEnvironmentVariable

private

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

Definition at line 327 of file MasterAlgorithm.h.

Referenced by ReadSettings().

bool lar_content::MasterAlgorithm::m_fullWidthCRWorkerWireGaps

private

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

Definition at line 316 of file MasterAlgorithm.h.

Referenced by CreatePfo(), and ReadSettings().

std::string lar_content::MasterAlgorithm::m_inputHitListName

private

The input hit list name.

Definition at line 333 of file MasterAlgorithm.h.

Referenced by GetVolumeIdToHitListMap(), and ReadSettings().

std::string lar_content::MasterAlgorithm::m_inputMCParticleListName

private

The input mc particle list name.

Definition at line 332 of file MasterAlgorithm.h.

Referenced by CopyMCParticles(), and ReadSettings().

float lar_content::MasterAlgorithm::m_inTimeMaxX0

private

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

Definition at line 338 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and TagCosmicRayPfos().

std::string lar_content::MasterAlgorithm::m_nuSettingsFile

private

The neutrino reconstruction settings file.

Definition at line 329 of file MasterAlgorithm.h.

Referenced by InitializeWorkerInstances(), and ReadSettings().

bool lar_content::MasterAlgorithm::m_passMCParticlesToWorkerInstances

private

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

Definition at line 317 of file MasterAlgorithm.h.

Referenced by ReadSettings(), Reset(), and Run().

bool lar_content::MasterAlgorithm::m_printOverallRecoStatus

private

Whether to print current operation status messages.

Definition at line 308 of file MasterAlgorithm.h.

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

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

private

The per-slice cosmic-ray reconstruction worker instance.

Definition at line 314 of file MasterAlgorithm.h.

Referenced by CopyMCParticles(), InitializeWorkerInstances(), Reset(), and RunSliceReconstruction().

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

private

The per-slice neutrino reconstruction worker instance.

Definition at line 313 of file MasterAlgorithm.h.

Referenced by CopyMCParticles(), InitializeWorkerInstances(), Reset(), and RunSliceReconstruction().

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

private

The slicing worker instance.

Definition at line 312 of file MasterAlgorithm.h.

Referenced by CopyMCParticles(), InitializeWorkerInstances(), Reset(), and RunSlicing().

std::string lar_content::MasterAlgorithm::m_recreatedClusterListName

private

The output recreated cluster list name.

Definition at line 335 of file MasterAlgorithm.h.

Referenced by ReadSettings(), Reset(), and StitchPfos().

std::string lar_content::MasterAlgorithm::m_recreatedPfoListName

private

The output recreated pfo list name.

Definition at line 334 of file MasterAlgorithm.h.

Referenced by ReadSettings(), Reset(), and StitchPfos().

std::string lar_content::MasterAlgorithm::m_recreatedVertexListName

private

The output recreated vertex list name.

Definition at line 336 of file MasterAlgorithm.h.

Referenced by ReadSettings(), Reset(), and StitchPfos().

bool lar_content::MasterAlgorithm::m_shouldPerformSliceId

private

Whether to identify slices and select most appropriate pfos.

Definition at line 307 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and SelectBestSliceHypotheses().

bool lar_content::MasterAlgorithm::m_shouldRunAllHitsCosmicReco

private

Whether to run all hits cosmic-ray reconstruction.

Definition at line 301 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::MasterAlgorithm::m_shouldRunCosmicHitRemoval

private

Whether to remove hits from tagged cosmic-rays.

Definition at line 303 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::MasterAlgorithm::m_shouldRunCosmicRecoOption

private

Whether to run cosmic-ray reconstruction for each slice.

Definition at line 306 of file MasterAlgorithm.h.

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

bool lar_content::MasterAlgorithm::m_shouldRunNeutrinoRecoOption

private

Whether to run neutrino reconstruction for each slice.

Definition at line 305 of file MasterAlgorithm.h.

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

bool lar_content::MasterAlgorithm::m_shouldRunSlicing

private

Whether to slice events into separate regions for processing.

Definition at line 304 of file MasterAlgorithm.h.

Referenced by InitializeWorkerInstances(), ReadSettings(), RunSliceReconstruction(), and RunSlicing().

bool lar_content::MasterAlgorithm::m_shouldRunStitching

private

Whether to stitch cosmic-ray muons crossing between volumes.

Definition at line 302 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and Run().

SliceIdToolVector lar_content::MasterAlgorithm::m_sliceIdToolVector

private

The slice id tool vector.

Definition at line 325 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and SelectBestSliceHypotheses().

std::string lar_content::MasterAlgorithm::m_slicingSettingsFile

private

The slicing settings file.

Definition at line 330 of file MasterAlgorithm.h.

Referenced by InitializeWorkerInstances(), and ReadSettings().

StitchingToolVector lar_content::MasterAlgorithm::m_stitchingToolVector

private

The stitching tool vector.

Definition at line 323 of file MasterAlgorithm.h.

Referenced by ReadSettings(), and StitchCosmicRayPfos().

bool lar_content::MasterAlgorithm::m_visualizeOverallRecoStatus

private

Whether to display results of current operations.

Definition at line 309 of file MasterAlgorithm.h.

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

bool lar_content::MasterAlgorithm::m_workerInstancesInitialized

private

Whether all worker instances have been initialized.

Definition at line 299 of file MasterAlgorithm.h.

Referenced by InitializeWorkerInstances(), and Run().

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

/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArControlFlow/MasterAlgorithm.h
/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArControlFlow/MasterAlgorithm.cc

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation