CheatingPfoCreationAlgorithm class. More...

#include <CheatingPfoCreationAlgorithm.h>

Inheritance diagram for lar_content::CheatingPfoCreationAlgorithm:

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

Private Types
typedef std::unordered_map < const pandora::MCParticle *, pandora::ClusterList >	MCParticleToClusterListMap

typedef std::map < pandora::HitType, unsigned int >	HitTypeMap

typedef std::set< int >	ParticleIdList

Private Member Functions
pandora::StatusCode	Run ()

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

void	GetMCParticleToClusterListMap (const pandora::ClusterList *const pClusterList, const LArMCParticleHelper::MCRelationMap &mcPrimaryMap, MCParticleToClusterListMap &mcParticleToClusterListMap) const
	Get a map relating mc particles to a list of daughter clusters. More...

void	CreatePfos (const MCParticleToClusterListMap &mcParticleToClusterListMap) const
	Create pfos corresponding to the details in a provided mc particle to cluster list map. More...

unsigned int	GetNHitTypesAboveThreshold (const pandora::ClusterList &clusterList, const unsigned int nHitsThreshold) const
	Get the number of hit types containing more than a specified number of hits. More...

Private Attributes
pandora::StringVector	m_inputClusterListNames
	The names of the input cluster lists. More...

std::string	m_outputPfoListName
	The output pfo list name. More...

std::string	m_outputVertexListName
	The output vertex list name. More...

bool	m_collapseToPrimaryMCParticles
	Whether to collapse mc particle hierarchies to primary particles. More...

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

bool	m_useOnlyAvailableClusters
	Whether to consider unavailable clusters when identifying cheated pfos. More...

bool	m_addVertices
	Whether to add the start vertex to the cheated pfo. More...

bool	m_replaceCurrentVertexList
	Whether to replace current vertex list. More...

unsigned int	m_minGoodHitTypes
	The min number of good hit types in the clusters collected for a given mc particle. More...

unsigned int	m_nHitsForGoodHitType
	The min number of hits of a particular hit type in order to declare the hit type is good. More...

ParticleIdList	m_particleIdList
	The list of particle ids to consider for pfo creation; will consider all ids if empty. More...

Detailed Description

CheatingPfoCreationAlgorithm class.

Definition at line 23 of file CheatingPfoCreationAlgorithm.h.

Member Typedef Documentation

typedef std::map<pandora::HitType, unsigned int> lar_content::CheatingPfoCreationAlgorithm::HitTypeMap

private

Definition at line 64 of file CheatingPfoCreationAlgorithm.h.

typedef std::unordered_map<const pandora::MCParticle *, pandora::ClusterList> lar_content::CheatingPfoCreationAlgorithm::MCParticleToClusterListMap

private

Definition at line 35 of file CheatingPfoCreationAlgorithm.h.

typedef std::set<int> lar_content::CheatingPfoCreationAlgorithm::ParticleIdList

private

Definition at line 65 of file CheatingPfoCreationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CheatingPfoCreationAlgorithm::CheatingPfoCreationAlgorithm ( )

Default constructor.

Definition at line 20 of file CheatingPfoCreationAlgorithm.cc.

                                                            :
     m_collapseToPrimaryMCParticles(false),
     m_useOnlyAvailableClusters(true),
     m_addVertices(true),
     m_replaceCurrentVertexList(false),
     m_minGoodHitTypes(0),
     m_nHitsForGoodHitType(10)
 {
 }

Member Function Documentation

void lar_content::CheatingPfoCreationAlgorithm::CreatePfos ( const MCParticleToClusterListMap & mcParticleToClusterListMap ) const

private

Create pfos corresponding to the details in a provided mc particle to cluster list map.

Parameters

mcParticleToClusterListMap the mc particle to cluster list map

Definition at line 102 of file CheatingPfoCreationAlgorithm.cc.

 {
     if (mcParticleToClusterListMap.empty())
         return;
 
     const PfoList *pPfoList(nullptr);
     std::string pfoListName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pPfoList, pfoListName));
 
     const VertexList *pVertexList(nullptr);
     std::string vertexListName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pVertexList, vertexListName));
 
     MCParticleVector mcParticleVector;
     for (const auto &mapEntry : mcParticleToClusterListMap)
         mcParticleVector.push_back(mapEntry.first);
     std::sort(mcParticleVector.begin(), mcParticleVector.end(), LArMCParticleHelper::SortByMomentum);
 
     for (const MCParticle *const pMCParticle : mcParticleVector)
     {
         const ClusterList &clusterList(mcParticleToClusterListMap.at(pMCParticle));
 
         if (clusterList.empty())
             continue;
 
         if (this->GetNHitTypesAboveThreshold(clusterList, m_nHitsForGoodHitType) < m_minGoodHitTypes)
             continue;
 
         try
         {
             PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;
             pfoParameters.m_particleId = pMCParticle->GetParticleId();
             pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());
             pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());
             pfoParameters.m_energy = pMCParticle->GetEnergy();
             pfoParameters.m_momentum = pMCParticle->GetMomentum();
             pfoParameters.m_clusterList.insert(pfoParameters.m_clusterList.end(), clusterList.begin(), clusterList.end());
 
             const ParticleFlowObject *pPfo(nullptr);
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pPfo));
 
             if (m_addVertices)
             {
                 PandoraContentApi::Vertex::Parameters parameters;
                 parameters.m_position = pMCParticle->GetVertex();
                 parameters.m_vertexLabel = VERTEX_START;
                 parameters.m_vertexType = VERTEX_3D;
 
                 const Vertex *pVertex(nullptr);
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
                 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo<Vertex>(*this, pPfo, pVertex));
             }
         }
         catch (const StatusCodeException &)
         {
             std::cout << "CheatingPfoCreationAlgorithm: Could not create PFO for MCParticle with pdg code " << pMCParticle->GetParticleId()
                       << std::endl;
         }
     }
 
     if (!pPfoList->empty())
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_outputPfoListName));
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Pfo>(*this, m_outputPfoListName));
     }
 
     if (!pVertexList->empty())
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*this, m_outputVertexListName));
 
         if (m_replaceCurrentVertexList)
             PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Vertex>(*this, m_outputVertexListName));
     }
 }

void lar_content::CheatingPfoCreationAlgorithm::GetMCParticleToClusterListMap	(	const pandora::ClusterList *const	pClusterList,
		const LArMCParticleHelper::MCRelationMap &	mcPrimaryMap,
		MCParticleToClusterListMap &	mcParticleToClusterListMap
	)		const

private

Get a map relating mc particles to a list of daughter clusters.

Parameters

pClusterList	address of a cluster list
mcPrimaryMap	the mapping between mc particles and their parents
mcParticleToClusterListMap	to receive the populated mc particle to cluster list map

Definition at line 67 of file CheatingPfoCreationAlgorithm.cc.

 {
     for (const Cluster *const pCluster : *pClusterList)
     {
         try
         {
             if (m_useOnlyAvailableClusters && !PandoraContentApi::IsAvailable(*this, pCluster))
                 continue;
 
             const MCParticle *pMCParticle(MCParticleHelper::GetMainMCParticle(pCluster));
 
             if (m_collapseToPrimaryMCParticles)
             {
                 LArMCParticleHelper::MCRelationMap::const_iterator primaryIter = mcPrimaryMap.find(pMCParticle);
 
                 if (mcPrimaryMap.end() == primaryIter)
                     throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
                 pMCParticle = primaryIter->second;
             }
 
             if (!m_particleIdList.empty() && !m_particleIdList.count(pMCParticle->GetParticleId()))
                 continue;
 
             mcParticleToClusterListMap[pMCParticle].push_back(pCluster);
         }
         catch (const StatusCodeException &)
         {
         }
     }
 }

unsigned int lar_content::CheatingPfoCreationAlgorithm::GetNHitTypesAboveThreshold	(	const pandora::ClusterList &	clusterList,
		const unsigned int	nHitsThreshold
	)		const

private

Get the number of hit types containing more than a specified number of hits.

Parameters

clusterList	the cluster list, consider all hits in clusters in this list
nHitsThreshold	the threshold number of hits of a specified hit type

Returns: the number of good hit types

Definition at line 179 of file CheatingPfoCreationAlgorithm.cc.

 {
     HitTypeMap hitTypeMap;
 
     for (const Cluster *const pCluster : clusterList)
     {
         hitTypeMap[LArClusterHelper::GetClusterHitType(pCluster)] += pCluster->GetNCaloHits();
     }
 
     unsigned int nGoodViews(0);
 
     for (const HitTypeMap::value_type &mapEntry : hitTypeMap)
     {
         if (mapEntry.second > nHitsThreshold)
             ++nGoodViews;
     }
 
     return nGoodViews;
 }

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

private

Definition at line 201 of file CheatingPfoCreationAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputPfoListName", m_outputPfoListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "CollapseToPrimaryMCParticles", m_collapseToPrimaryMCParticles));
 
     if (m_collapseToPrimaryMCParticles)
     {
         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, "UseOnlyAvailableClusters", m_useOnlyAvailableClusters));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "AddVertices", m_addVertices));
 
     if (m_addVertices)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputVertexListName", m_outputVertexListName));
 
         PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
             XmlHelper::ReadValue(xmlHandle, "ReplaceCurrentVertexList", m_replaceCurrentVertexList));
     }
 
     IntVector particleIdVector;
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "ParticleIdList", particleIdVector));
 
     m_particleIdList.insert(particleIdVector.begin(), particleIdVector.end());
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinGoodHitTypes", m_minGoodHitTypes));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NHitsForGoodHitType", m_nHitsForGoodHitType));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::CheatingPfoCreationAlgorithm::Run ( )

private

Definition at line 32 of file CheatingPfoCreationAlgorithm.cc.

 {
     LArMCParticleHelper::MCRelationMap mcPrimaryMap;
 
     if (m_collapseToPrimaryMCParticles)
     {
         const MCParticleList *pMCParticleList(nullptr);
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));
 
         LArMCParticleHelper::GetMCPrimaryMap(pMCParticleList, mcPrimaryMap);
     }
 
     MCParticleToClusterListMap mcParticleToClusterListMap;
 
     for (const std::string &clusterListName : m_inputClusterListNames)
     {
         const ClusterList *pClusterList(nullptr);
 
         if (STATUS_CODE_SUCCESS != PandoraContentApi::GetList(*this, clusterListName, pClusterList))
         {
             if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                 std::cout << "CheatingPfoCreationAlgorithm - Could not access cluster list with name " << clusterListName << std::endl;
 
             continue;
         }
 
         this->GetMCParticleToClusterListMap(pClusterList, mcPrimaryMap, mcParticleToClusterListMap);
     }
 
     this->CreatePfos(mcParticleToClusterListMap);
     return STATUS_CODE_SUCCESS;
 }