RecursivePfoMopUpAlgorithm class. More...

#include "ThreeDReclusteringAlgorithm.h"

Inheritance diagram for lar_content::ThreeDReclusteringAlgorithm:

Public Types
enum	FigureOfMeritType { CHEATED }
	FigureOfMerit type enumeration. More...

Public Member Functions
	ThreeDReclusteringAlgorithm ()
	Default constructor. More...

	~ThreeDReclusteringAlgorithm ()
	Destructor. More...

Private Types
typedef std::vector< ClusteringTool * >	ClusteringToolVector

Private Member Functions
pandora::StatusCode	Run ()

pandora::StatusCode	RebuildPfo (const pandora::Pfo *pPfoToRebuild, pandora::ClusterList &newClustersList)
	Create new TwoD clusters and Pfos for each new ThreeD cluster in newClustersList. More...

pandora::StatusCode	BuildNewTwoDClusters (const pandora::Pfo *pPfoToRebuild, pandora::ClusterList &newClustersList)
	Create new TwoD clusters for each new ThreeD cluster in newClustersList. More...

pandora::StatusCode	BuildNewPfos (const pandora::Pfo *pPfoToRebuild, pandora::ClusterList &newClustersList)
	Create new Pfos for each new ThreeD cluster in newClustersList. More...

float	GetFigureOfMerit (const pandora::CaloHitList &mergedClusterCaloHitList3D)
	Loop over all specified figure of merit names, calculate figures of merit for the CaloHitList under consideration, and return the smallest FOM. More...

float	GetFigureOfMerit (const std::string &figureOfMeritName, const pandora::CaloHitList &mergedClusterCaloHitList3D)
	Calculate the specified figure of merit for the CaloHitList under consideration, and return the smallest FOM. More...

float	GetFigureOfMerit (const std::vector< pandora::CaloHitList > &newClustersCaloHitList3D)
	Loop over all specified figure of merit names, calculate figures of merit for each CaloHitList in the provided vector, and return the smallest FOM. More...

float	GetFigureOfMerit (const std::string &figureOfMeritName, const std::vector< pandora::CaloHitList > &newClustersCaloHitLists3D)
	Calculate the specified figure of merit for each CaloHitList in the provided vector, and return the smallest FOM. More...

float	GetCheatedFigureOfMerit (const pandora::CaloHitList &mergedClusterCaloHitList3D)
	Get cheated FOM as an impurity: the fraction of hits that are NOT contributed by the main MC particle. If clustering was perfect, cheated FOM would always be 0. More...

bool	PassesCutsForReclustering (const pandora::ParticleFlowObject *const pPfo)
	Select pfos to be reclustered if it passes reclustering criteria. More...

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

Private Attributes
ClusteringToolVector	m_algorithmToolVector
	The reclustering algorithm tool vector. More...

std::string	m_pfoListName
	Name of the list of pfos to consider for reclustering. More...

std::string	m_clusterListName
	Name of the list of clusters to consider for reclustering. More...

pandora::StringVector	m_figureOfMeritNames
	The names of the figures of merit to use. More...

std::string	m_PfosForReclusteringListName
	Name of the internal list to contain new Pfos before/after reclustering. More...

std::string	m_mcParticleListName
	The mc particle list name. More...

float	m_fomThresholdForReclustering
	A threshold on the minimum figure of merit for reclustering. More...

long unsigned int	m_minNumCaloHitsForReclustering

std::string	m_uClustersListName

std::string	m_vClustersListName

std::string	m_wClustersListName

std::map< int, const pandora::Cluster * >	m_newClustersUMap

std::map< int, const pandora::Cluster * >	m_newClustersVMap

std::map< int, const pandora::Cluster * >	m_newClustersWMap
	Per-view maps associating new 3D clusters with new 2D clusters. More...

Static Private Attributes
static const std::unordered_map< std::string, ThreeDReclusteringAlgorithm::FigureOfMeritType >	m_stringToEnumMap

Detailed Description

RecursivePfoMopUpAlgorithm class.

Definition at line 27 of file ThreeDReclusteringAlgorithm.h.

Member Typedef Documentation

typedef std::vector<ClusteringTool *> lar_content::ThreeDReclusteringAlgorithm::ClusteringToolVector

private

Definition at line 49 of file ThreeDReclusteringAlgorithm.h.

Member Enumeration Documentation

enum lar_content::ThreeDReclusteringAlgorithm::FigureOfMeritType

FigureOfMerit type enumeration.

Enumerator
CHEATED

Definition at line 33 of file ThreeDReclusteringAlgorithm.h.

     {
         CHEATED
     };

Constructor & Destructor Documentation

lar_content::ThreeDReclusteringAlgorithm::ThreeDReclusteringAlgorithm ( )

Default constructor.

Definition at line 28 of file ThreeDReclusteringAlgorithm.cc.

                                                          :
     m_pfoListName("ShowerParticles3D"),
     m_clusterListName("ShowerClusters3D"),
     m_fomThresholdForReclustering(0.3),
     m_minNumCaloHitsForReclustering(2),
     m_uClustersListName("ClustersU"),
     m_vClustersListName("ClustersV"),
     m_wClustersListName("ClustersW")
 {
 }

lar_content::ThreeDReclusteringAlgorithm::~ThreeDReclusteringAlgorithm ( )

Destructor.

Definition at line 41 of file ThreeDReclusteringAlgorithm.cc.

42 {

43 }

Member Function Documentation

StatusCode lar_content::ThreeDReclusteringAlgorithm::BuildNewPfos	(	const pandora::Pfo *	pPfoToRebuild,
		pandora::ClusterList &	newClustersList
	)

private

Create new Pfos for each new ThreeD cluster in newClustersList.

Parameters

pPfoToRebuild	the address of the original pfo to rebuild
newClustersList	a reference to the new list of clusters obtained via the reclustering process

Definition at line 279 of file ThreeDReclusteringAlgorithm.cc.

References f, m_newClustersUMap, m_newClustersVMap, m_newClustersWMap, and m_PfosForReclusteringListName.

Referenced by RebuildPfo().

 {
     const PfoList *pNewPfoList(nullptr);
     std::string newPfoListName = "changedShowerParticles3D";
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pNewPfoList, newPfoListName));
 
     const std::string originalClusterListName = "InitialCluster";
     int iCluster(0);
 
     for (const Cluster *pNewThreeDCluster : newClustersList)
     {
         PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;
         const bool isAvailableU((m_newClustersUMap.count(iCluster)) && m_newClustersUMap.at(iCluster)->IsAvailable());
         const bool isAvailableV((m_newClustersVMap.count(iCluster)) && m_newClustersVMap.at(iCluster)->IsAvailable());
         const bool isAvailableW((m_newClustersWMap.count(iCluster)) && m_newClustersWMap.at(iCluster)->IsAvailable());
         CaloHitList clusterUHits, clusterVHits, clusterWHits;
         if (isAvailableU)
         {
             m_newClustersUMap.at(iCluster)->GetOrderedCaloHitList().FillCaloHitList(clusterUHits);
             pfoParameters.m_clusterList.push_back(m_newClustersUMap.at(iCluster));
         }
         if (isAvailableV)
         {
             m_newClustersVMap.at(iCluster)->GetOrderedCaloHitList().FillCaloHitList(clusterVHits);
             pfoParameters.m_clusterList.push_back(m_newClustersVMap.at(iCluster));
         }
         if (isAvailableW)
         {
             m_newClustersWMap.at(iCluster)->GetOrderedCaloHitList().FillCaloHitList(clusterWHits);
             pfoParameters.m_clusterList.push_back(m_newClustersWMap.at(iCluster));
         }
         pfoParameters.m_clusterList.push_back(pNewThreeDCluster);
 
         pfoParameters.m_particleId = pPfoToRebuild->GetParticleId();
         pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());
         pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());
         pfoParameters.m_energy = 0.f;
         pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);
 
         const ParticleFlowObject *pNewPfo(nullptr);
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pNewPfo));
 
         iCluster++;
     }
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, newPfoListName, m_PfosForReclusteringListName));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ThreeDReclusteringAlgorithm::BuildNewTwoDClusters	(	const pandora::Pfo *	pPfoToRebuild,
		pandora::ClusterList &	newClustersList
	)

private

Create new TwoD clusters for each new ThreeD cluster in newClustersList.

Parameters

pPfoToRebuild	the address of the original pfo to rebuild
newClustersList	a reference to the new list of clusters obtained via the reclustering process

Definition at line 169 of file ThreeDReclusteringAlgorithm.cc.

References larg4::dist(), lar_content::LArClusterHelper::GetClosestDistance(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArPfoHelper::GetTwoDClusterList(), m_newClustersUMap, m_newClustersVMap, m_newClustersWMap, m_uClustersListName, m_vClustersListName, and m_wClustersListName.

Referenced by RebuildPfo().

 {
     ClusterList clusterList2D;
     LArPfoHelper::GetTwoDClusterList(pPfoToRebuild, clusterList2D);
 
     for (const Cluster *const pTwoDCluster : clusterList2D)
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RemoveFromPfo(*this, pPfoToRebuild, pTwoDCluster));
         HitType hitType = LArClusterHelper::GetClusterHitType(pTwoDCluster);
         std::string clusterListName(hitType == TPC_VIEW_U ? m_uClustersListName
                 : hitType == TPC_VIEW_V                   ? m_vClustersListName
                                                           : m_wClustersListName);
 
         std::string initialListName = "";
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentListName<Cluster>(*this, initialListName));
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, clusterListName));
 
         std::string originalListName, fragmentListName;
         ClusterList originalClusterList;
         originalClusterList.push_back(pTwoDCluster);
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
             PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));
 
         const OrderedCaloHitList &twoDClusterOrderedCaloHitList(pTwoDCluster->GetOrderedCaloHitList());
         OrderedCaloHitList leftoverCaloHitList = twoDClusterOrderedCaloHitList;
 
         int iCluster(0);
         for (const Cluster *pNewCluster3D : newClustersList)
         {
             if (!pNewCluster3D)
             {
                 std::cout << "Error: found null pointer in list of new clusters!" << std::endl;
                 continue;
             }
             PandoraContentApi::Cluster::Parameters parameters;
             CaloHitList newClusterCaloHitList3D;
             pNewCluster3D->GetOrderedCaloHitList().FillCaloHitList(newClusterCaloHitList3D);
 
             for (const CaloHit *const p3DCaloHit : newClusterCaloHitList3D)
             {
                 for (const OrderedCaloHitList::value_type &mapEntry : twoDClusterOrderedCaloHitList)
                 {
                     for (const CaloHit *const pCaloHit : *mapEntry.second)
                     {
                         if (pCaloHit == static_cast<const CaloHit *>(p3DCaloHit->GetParentAddress()))
                         {
                             parameters.m_caloHitList.push_back(static_cast<const CaloHit *>(pCaloHit));
                             leftoverCaloHitList.Remove(pCaloHit);
                             break;
                         }
                     }
                 }
             }
             const Cluster *pNewTwoDCluster(nullptr);
             if (!parameters.m_caloHitList.empty())
             {
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pNewTwoDCluster));
             }
             if (pNewTwoDCluster != nullptr && !parameters.m_caloHitList.empty() && hitType == TPC_VIEW_U)
             {
                 m_newClustersUMap.insert(std::make_pair(iCluster, pNewTwoDCluster));
             }
             else if (pNewTwoDCluster != nullptr && !parameters.m_caloHitList.empty() && hitType == TPC_VIEW_V)
             {
                 m_newClustersVMap.insert(std::make_pair(iCluster, pNewTwoDCluster));
             }
             else if (pNewTwoDCluster != nullptr && !parameters.m_caloHitList.empty() && hitType == TPC_VIEW_W)
             {
                 m_newClustersWMap.insert(std::make_pair(iCluster, pNewTwoDCluster));
             }
 
             iCluster++;
         }
 
         //Check the leftover caloHits. Attach to the nearest cluster in the new cluster list.
         std::map<int, const Cluster *> clustersForLeftoverHitsMap(hitType == TPC_VIEW_U ? m_newClustersUMap
                 : hitType == TPC_VIEW_V                                                 ? m_newClustersVMap
                                                                                         : m_newClustersWMap);
 
         if (!clustersForLeftoverHitsMap.empty())
         {
             for (const OrderedCaloHitList::value_type &mapEntry : leftoverCaloHitList)
             {
                 for (const CaloHit *const pCaloHit : *mapEntry.second)
                 {
                     const Cluster *pNearestCluster(nullptr);
                     double minimumDistance(std::numeric_limits<float>::max());
                     for (const auto &[clusterIndex, pNewTwoDCluster] : clustersForLeftoverHitsMap)
                     {
                         double dist = LArClusterHelper::GetClosestDistance(pCaloHit->GetPositionVector(), pNewTwoDCluster);
                         if (dist < minimumDistance)
                         {
                             minimumDistance = dist;
                             pNearestCluster = pNewTwoDCluster;
                         }
                     }
                     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pNearestCluster, pCaloHit));
                 }
             }
         }
 
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, initialListName));
     }
 
     return STATUS_CODE_SUCCESS;
 }

float lar_content::ThreeDReclusteringAlgorithm::GetCheatedFigureOfMerit ( const pandora::CaloHitList & mergedClusterCaloHitList3D )

private

Get cheated FOM as an impurity: the fraction of hits that are NOT contributed by the main MC particle. If clustering was perfect, cheated FOM would always be 0.

Parameters

List	of calo hits for the pfo to recluster

Returns: The figure of merit (purity)

Definition at line 374 of file ThreeDReclusteringAlgorithm.cc.

References f, GetFigureOfMerit(), m_figureOfMeritNames, m_stringToEnumMap, x, and y.

 {
     std::map<const pandora::MCParticle *, int> mainMcParticleMap;
     for (const CaloHit *const pCaloHit3D : mergedClusterCaloHitList3D)
     {
         const CaloHit *const pParentCaloHit2D = static_cast<const CaloHit *>(pCaloHit3D->GetParentAddress());
 
         const MCParticle *const pMainMCParticle(MCParticleHelper::GetMainMCParticle(pParentCaloHit2D));
 
         std::map<const pandora::MCParticle *, int>::iterator it = mainMcParticleMap.find(pMainMCParticle);
 
         if (it != mainMcParticleMap.end())
             it->second++;
         else
             mainMcParticleMap.insert(std::make_pair(pMainMCParticle, 1));
     }
     const auto maxSharedHits =
         std::max_element(mainMcParticleMap.begin(), mainMcParticleMap.end(), [](const auto &x, const auto &y) { return x.second < y.second; });
     const float mainMcParticleFraction = (float)maxSharedHits->second / mergedClusterCaloHitList3D.size();
     return (1.f - mainMcParticleFraction);
 }

float lar_content::ThreeDReclusteringAlgorithm::GetFigureOfMerit ( const pandora::CaloHitList & mergedClusterCaloHitList3D )

private

Loop over all specified figure of merit names, calculate figures of merit for the CaloHitList under consideration, and return the smallest FOM.

Parameters

mergedClusterCaloHitList3D the CaloHitList under consideration

Returns: The figure of merit

Referenced by GetCheatedFigureOfMerit(), PassesCutsForReclustering(), and Run().

float lar_content::ThreeDReclusteringAlgorithm::GetFigureOfMerit	(	const std::string &	figureOfMeritName,
		const pandora::CaloHitList &	mergedClusterCaloHitList3D
	)

private

Calculate the specified figure of merit for the CaloHitList under consideration, and return the smallest FOM.

Parameters

figureOfMeritName	the name of the figure of merit
mergedClusterCaloHitList3D	the CaloHitList under consideration

Returns: The figure of merit

float lar_content::ThreeDReclusteringAlgorithm::GetFigureOfMerit ( const std::vector< pandora::CaloHitList > & newClustersCaloHitList3D )

private

Loop over all specified figure of merit names, calculate figures of merit for each CaloHitList in the provided vector, and return the smallest FOM.

Parameters

newClustersCaloHitLists3D the vector of CaloHitLists under consideration

Returns: The figure of merit

float lar_content::ThreeDReclusteringAlgorithm::GetFigureOfMerit	(	const std::string &	figureOfMeritName,
		const std::vector< pandora::CaloHitList > &	newClustersCaloHitLists3D
	)

private

Calculate the specified figure of merit for each CaloHitList in the provided vector, and return the smallest FOM.

Parameters

figureOfMeritName	the name of the figure of merit
newClustersCaloHitLists3D	the vector of CaloHitLists under consideration

Returns: The figure of merit

bool lar_content::ThreeDReclusteringAlgorithm::PassesCutsForReclustering ( const pandora::ParticleFlowObject *const pPfo )

private

Select pfos to be reclustered if it passes reclustering criteria.

Parameters

pPfo	the address of the pfo

Returns: bool corresponding to decision: recluster (1), do not recluster (0)

Definition at line 345 of file ThreeDReclusteringAlgorithm.cc.

References GetFigureOfMerit(), lar_content::LArPfoHelper::GetThreeDClusterList(), lar_content::LArPfoHelper::IsShower(), m_clusterListName, m_fomThresholdForReclustering, and m_minNumCaloHitsForReclustering.

Referenced by Run().

 {
     if (!LArPfoHelper::IsShower(pShowerPfo))
         return false;
     ClusterList clusterList3D;
     LArPfoHelper::GetThreeDClusterList(pShowerPfo, clusterList3D);
 
     if (clusterList3D.empty())
         return false;
     CaloHitList caloHitList3D;
     clusterList3D.front()->GetOrderedCaloHitList().FillCaloHitList(caloHitList3D);
 
     //Quality cuts
     if (caloHitList3D.size() < m_minNumCaloHitsForReclustering)
         return false;
 
     //Some pfos are shower-like and yet include track-like 3D clusters. For the moment I don't want to deal with these.
     const ClusterList *pShowerClusters(nullptr);
     PandoraContentApi::GetList(*this, m_clusterListName, pShowerClusters);
     if (!pShowerClusters)
         return false;
 
     if (this->GetFigureOfMerit(caloHitList3D) < m_fomThresholdForReclustering)
         return false;
     return true;
 }

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

private

Definition at line 459 of file ThreeDReclusteringAlgorithm.cc.

References m_algorithmToolVector, m_clusterListName, m_figureOfMeritNames, m_fomThresholdForReclustering, m_mcParticleListName, m_minNumCaloHitsForReclustering, m_pfoListName, m_uClustersListName, m_vClustersListName, and m_wClustersListName.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "FigureOfMeritNames", m_figureOfMeritNames));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MCParticleListName", m_mcParticleListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PfoListName", m_pfoListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ClusterListName", m_clusterListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "FOMThresholdForReclustering", m_fomThresholdForReclustering));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinimumNumberCaloHitsForReclustering", m_minNumCaloHitsForReclustering));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UClustersListName", m_uClustersListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VClustersListName", m_vClustersListName));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "WClustersListName", m_wClustersListName));
 
     AlgorithmToolVector algorithmToolVector;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "ClusteringTools", algorithmToolVector));
 
     for (auto algorithmTool : algorithmToolVector)
     {
         ClusteringTool *const pClusteringTool(dynamic_cast<ClusteringTool *>(algorithmTool));
 
         if (!pClusteringTool)
             return STATUS_CODE_INVALID_PARAMETER;
 
         m_algorithmToolVector.push_back(pClusteringTool);
     }
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ThreeDReclusteringAlgorithm::RebuildPfo	(	const pandora::Pfo *	pPfoToRebuild,
		pandora::ClusterList &	newClustersList
	)

private

Create new TwoD clusters and Pfos for each new ThreeD cluster in newClustersList.

Parameters

pPfoToRebuild	the address of the original pfo to rebuild
newClustersList	a reference to the new list of clusters obtained via the reclustering process

Definition at line 330 of file ThreeDReclusteringAlgorithm.cc.

References BuildNewPfos(), BuildNewTwoDClusters(), m_newClustersUMap, m_newClustersVMap, and m_newClustersWMap.

Referenced by Run().

 {
     m_newClustersUMap.clear();
     m_newClustersVMap.clear();
     m_newClustersWMap.clear();
 
     //For each of the new 3D clusters, build a new 2D cluster in each view, and a new Pfo
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->BuildNewTwoDClusters(pPfoToRebuild, newClustersList));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->BuildNewPfos(pPfoToRebuild, newClustersList));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ThreeDReclusteringAlgorithm::Run ( )

private

Definition at line 47 of file ThreeDReclusteringAlgorithm.cc.

References GetFigureOfMerit(), lar_content::LArPfoHelper::GetThreeDClusterList(), m_algorithmToolVector, m_clusterListName, m_pfoListName, m_PfosForReclusteringListName, PassesCutsForReclustering(), and RebuildPfo().

 {
     //Only proceed if successfuly get shower pfo list, and it has at least one pfo
     const PfoList *pShowerPfoList(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_pfoListName, pShowerPfoList));
 
     if (pShowerPfoList->empty())
         return STATUS_CODE_SUCCESS;
 
     m_PfosForReclusteringListName = "newShowerParticles3D";
     PfoList unchangedPfoList;
 
     //Save current pfo list name, so that this can be set as current again at the end of reclustering
     std::string initialPfoListName;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentListName<Pfo>(*this, initialPfoListName));
 
     //Some pfos are shower-like and yet include track-like 3D clusters. For the moment I don't want to deal with these.
     const ClusterList *pShowerClusters(nullptr);
     PandoraContentApi::GetList(*this, m_clusterListName, pShowerClusters);
 
     if (!pShowerClusters)
         return STATUS_CODE_NOT_FOUND;
 
     for (const Pfo *const pShowerPfo : *pShowerPfoList)
     {
         ClusterList clusterList3D;
         LArPfoHelper::GetThreeDClusterList(pShowerPfo, clusterList3D);
 
         //Check if pfo passes cuts for reclustering. Also, some pfos are shower-like and yet are made of track-like 3D clusters. For the moment I don't want to deal with these.
         if ((!this->PassesCutsForReclustering(pShowerPfo)) ||
             (pShowerClusters->end() == std::find(pShowerClusters->begin(), pShowerClusters->end(), clusterList3D.front())))
         {
             unchangedPfoList.push_back(pShowerPfo);
             continue;
         }
 
         CaloHitList initialCaloHitList;
         clusterList3D.front()->GetOrderedCaloHitList().FillCaloHitList(initialCaloHitList);
 
         //Create a variable for the minimum figure of merit and initialize to initial FOM
         float minimumFigureOfMerit(this->GetFigureOfMerit(initialCaloHitList));
 
         //Free the hits in this cluster, so that they are not owned by the original pfo, and are available for reclustering
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RemoveFromPfo(*this, pShowerPfo, clusterList3D.front()));
 
         // Initialize reclustering with these local lists
         std::string currentClustersListName;
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentListName<Cluster>(*this, currentClustersListName));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, m_clusterListName));
 
         //Split the calo hit list into a new set of calo hit lists, taking the best outcome out of different algorithms
         std::vector<CaloHitList> newCaloHitListsVector, minimumFigureOfMeritCaloHitListsVector;
         minimumFigureOfMeritCaloHitListsVector.push_back(initialCaloHitList);
 
         for (auto *const pTool : m_algorithmToolVector)
         {
             try
             {
                 pTool->Run(initialCaloHitList, newCaloHitListsVector);
             }
             catch (const StatusCodeException &)
             {
                 std::cout << "Exception caught! Cannot run reclustering tool!" << std::endl;
                 continue;
             }
 
             //Calculate FOM for this vector of new CaloHitLists
             const float newFigureOfMerit(this->GetFigureOfMerit(newCaloHitListsVector));
 
             //Is this FOM smaller?
             if (newFigureOfMerit < minimumFigureOfMerit)
             {
                 minimumFigureOfMerit = newFigureOfMerit;
                 minimumFigureOfMeritCaloHitListsVector = newCaloHitListsVector;
             }
             newCaloHitListsVector.clear();
         }
 
         //If the new best calo hit lists outcome is equivalent to original, move pfo to unchanged pfo list. Else, create new vector of 3D clusters
         if ((minimumFigureOfMeritCaloHitListsVector.size() == 1) && (minimumFigureOfMeritCaloHitListsVector.at(0) == initialCaloHitList))
         {
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*this, pShowerPfo, clusterList3D.front()));
             unchangedPfoList.push_back(pShowerPfo);
             continue;
         }
 
         const ClusterList reclusterClusterList(1, clusterList3D.front());
         std::string clusterListToSaveName, clusterListToDeleteName;
 
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
             PandoraContentApi::InitializeFragmentation(*this, reclusterClusterList, clusterListToDeleteName, clusterListToSaveName));
 
         ClusterList newClustersList;
         for (CaloHitList &list : minimumFigureOfMeritCaloHitListsVector)
         {
             const Cluster *pCluster = nullptr;
             PandoraContentApi::Cluster::Parameters parameters;
             parameters.m_caloHitList = list;
             PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pCluster));
             newClustersList.push_back(pCluster);
         }
 
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, clusterListToSaveName, clusterListToDeleteName));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RebuildPfo(pShowerPfo, newClustersList));
         newCaloHitListsVector.clear();
     }
     //If there are any pfos that did not change after reclustering procedure, move them into list of new pfos after reclustering (where there may be some reclustered showers too)
     if (unchangedPfoList.size() > 0)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
             PandoraContentApi::SaveList<PfoList>(*this, m_pfoListName, m_PfosForReclusteringListName, unchangedPfoList));
 
     //Save list of Pfos after reclustering and save into list called m_pfoListName
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_PfosForReclusteringListName, m_pfoListName));
 
     //Set current list to be the same as before reclustering
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Pfo>(*this, initialPfoListName));
 
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

ClusteringToolVector lar_content::ThreeDReclusteringAlgorithm::m_algorithmToolVector

private

The reclustering algorithm tool vector.

Definition at line 135 of file ThreeDReclusteringAlgorithm.h.

Referenced by ReadSettings(), and Run().

std::string lar_content::ThreeDReclusteringAlgorithm::m_clusterListName

private

Name of the list of clusters to consider for reclustering.

Definition at line 137 of file ThreeDReclusteringAlgorithm.h.

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

pandora::StringVector lar_content::ThreeDReclusteringAlgorithm::m_figureOfMeritNames

private

The names of the figures of merit to use.

Definition at line 138 of file ThreeDReclusteringAlgorithm.h.

Referenced by GetCheatedFigureOfMerit(), and ReadSettings().

float lar_content::ThreeDReclusteringAlgorithm::m_fomThresholdForReclustering

private

A threshold on the minimum figure of merit for reclustering.

Definition at line 141 of file ThreeDReclusteringAlgorithm.h.

Referenced by PassesCutsForReclustering(), and ReadSettings().

std::string lar_content::ThreeDReclusteringAlgorithm::m_mcParticleListName

private

The mc particle list name.

Definition at line 140 of file ThreeDReclusteringAlgorithm.h.

Referenced by ReadSettings().

long unsigned int lar_content::ThreeDReclusteringAlgorithm::m_minNumCaloHitsForReclustering

private

Definition at line 142 of file ThreeDReclusteringAlgorithm.h.

Referenced by PassesCutsForReclustering(), and ReadSettings().

std::map<int, const pandora::Cluster *> lar_content::ThreeDReclusteringAlgorithm::m_newClustersUMap

private

Definition at line 146 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewPfos(), BuildNewTwoDClusters(), and RebuildPfo().

std::map<int, const pandora::Cluster *> lar_content::ThreeDReclusteringAlgorithm::m_newClustersVMap

private

Definition at line 146 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewPfos(), BuildNewTwoDClusters(), and RebuildPfo().

std::map<int, const pandora::Cluster *> lar_content::ThreeDReclusteringAlgorithm::m_newClustersWMap

private

Per-view maps associating new 3D clusters with new 2D clusters.

Definition at line 146 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewPfos(), BuildNewTwoDClusters(), and RebuildPfo().

std::string lar_content::ThreeDReclusteringAlgorithm::m_pfoListName

private

Name of the list of pfos to consider for reclustering.

Definition at line 136 of file ThreeDReclusteringAlgorithm.h.

Referenced by ReadSettings(), and Run().

std::string lar_content::ThreeDReclusteringAlgorithm::m_PfosForReclusteringListName

private

Name of the internal list to contain new Pfos before/after reclustering.

Definition at line 139 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewPfos(), and Run().

const std::unordered_map< std::string, ThreeDReclusteringAlgorithm::FigureOfMeritType > lar_content::ThreeDReclusteringAlgorithm::m_stringToEnumMap

staticprivate

Initial value:

= {

{"cheated", ThreeDReclusteringAlgorithm::FigureOfMeritType::CHEATED}}

Definition at line 148 of file ThreeDReclusteringAlgorithm.h.

Referenced by GetCheatedFigureOfMerit().

std::string lar_content::ThreeDReclusteringAlgorithm::m_uClustersListName

private

Definition at line 143 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewTwoDClusters(), and ReadSettings().

std::string lar_content::ThreeDReclusteringAlgorithm::m_vClustersListName

private

Definition at line 144 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewTwoDClusters(), and ReadSettings().

std::string lar_content::ThreeDReclusteringAlgorithm::m_wClustersListName

private

Definition at line 145 of file ThreeDReclusteringAlgorithm.h.

Referenced by BuildNewTwoDClusters(), and ReadSettings().

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

larpandoracontent/v04_14_00/source/larpandoracontent/LArReclustering/ThreeDReclusteringAlgorithm.h
larpandoracontent/v04_14_00/source/larpandoracontent/LArReclustering/ThreeDReclusteringAlgorithm.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation