CheatingNeutrinoCreationAlgorithm::Algorithm class. More...

#include <CheatingNeutrinoCreationAlgorithm.h>

Inheritance diagram for lar_content::CheatingNeutrinoCreationAlgorithm:

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

Private Types
typedef std::unordered_map < const pandora::MCParticle , const pandora::ParticleFlowObject >	MCParticleToPfoMap

Private Member Functions
pandora::StatusCode	Run ()

void	GetMCNeutrinoVector (pandora::MCParticleVector &mcNeutrinoVector) const
	Get the mc neutrino vector. More...

void	CreateAndSaveNeutrinoPfo (const pandora::MCParticle const pMCNeutrino, const pandora::ParticleFlowObject &pNeutrinoPfo) const
	Create and save a neutrino pfo with properties dictated by the mc neutrino. More...

void	AddNeutrinoVertex (const pandora::MCParticle const pMCNeutrino, const pandora::ParticleFlowObject const pNeutrinoPfo) const
	Extract reconstructed vertex from external list, check its position agrees with mc neutrino, and add to pfo. More...

void	GetMCParticleToDaughterPfoMap (MCParticleToPfoMap &mcParticleToPfoMap) const
	Extract candidate daughter pfos from external lists and populate a map from main mc particle (or primary) to pfo. More...

void	CreatePfoHierarchy (const pandora::MCParticle const pParentMCParticle, const pandora::ParticleFlowObject const pParentPfo, const MCParticleToPfoMap &mcParticleToPfoMap) const
	Use information from mc particles and the mc particle to pfo map to fully-reconstruct the daughter pfo hierarchy. More...

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

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

std::string	m_mcParticleListName
	The name of the three d mc particle list name. More...

std::string	m_neutrinoPfoListName
	The name of the neutrino pfo list. More...

std::string	m_vertexListName
	The name of the neutrino vertex list. More...

pandora::StringVector	m_daughterPfoListNames
	The list of daughter pfo list names. More...

float	m_vertexTolerance
	Tolerance, 3d displacement, allowed between reco neutrino vertex and mc neutrino endpoint. More...

Detailed Description

CheatingNeutrinoCreationAlgorithm::Algorithm class.

Definition at line 23 of file CheatingNeutrinoCreationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::MCParticle *, const pandora::ParticleFlowObject *> lar_content::CheatingNeutrinoCreationAlgorithm::MCParticleToPfoMap

private

Definition at line 57 of file CheatingNeutrinoCreationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CheatingNeutrinoCreationAlgorithm::CheatingNeutrinoCreationAlgorithm ( )

Default constructor.

Definition at line 21 of file CheatingNeutrinoCreationAlgorithm.cc.

                                                                      : m_collapseToPrimaryMCParticles(false), m_vertexTolerance(0.5f)
 {
 }

Member Function Documentation

void lar_content::CheatingNeutrinoCreationAlgorithm::AddNeutrinoVertex	(	const pandora::MCParticle *const	pMCNeutrino,
		const pandora::ParticleFlowObject *const	pNeutrinoPfo
	)		const

private

Extract reconstructed vertex from external list, check its position agrees with mc neutrino, and add to pfo.

Parameters

pMCNeutrino	the address of the mc neutrino
pNeutrinoPfo	the address of the neutrino pfo

Definition at line 94 of file CheatingNeutrinoCreationAlgorithm.cc.

 {
     const VertexList *pVertexList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));
 
     const Vertex *pNeutrinoVertex(nullptr);
     float closestVertexDistance(std::numeric_limits<float>::max());
 
     for (const Vertex *const pVertex : *pVertexList)
     {
         const float distance((pVertex->GetPosition() - pMCNeutrino->GetEndpoint()).GetMagnitude());
 
         if (distance < closestVertexDistance)
         {
             pNeutrinoVertex = pVertex;
             closestVertexDistance = distance;
         }
     }
 
     if (!pNeutrinoVertex || (VERTEX_3D != pNeutrinoVertex->GetVertexType()) ||
         ((pNeutrinoVertex->GetPosition() - pMCNeutrino->GetEndpoint()).GetMagnitude() > m_vertexTolerance))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*this, pNeutrinoPfo, pNeutrinoVertex));
 }

void lar_content::CheatingNeutrinoCreationAlgorithm::CreateAndSaveNeutrinoPfo	(	const pandora::MCParticle *const	pMCNeutrino,
		const pandora::ParticleFlowObject *&	pNeutrinoPfo
	)		const

private

Create and save a neutrino pfo with properties dictated by the mc neutrino.

Parameters

pMCNeutrino	the address of the mc neutrino
pNeutrinoPfo	to receive the address of the neutrino pfo

Definition at line 69 of file CheatingNeutrinoCreationAlgorithm.cc.

 {
     pNeutrinoPfo = nullptr;
 
     PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;
     pfoParameters.m_particleId = pMCNeutrino->GetParticleId();
     pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());
     pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());
     pfoParameters.m_energy = pMCNeutrino->GetEnergy();
     pfoParameters.m_momentum = pMCNeutrino->GetMomentum();
 
     std::string neutrinoPfoListName;
     const PfoList *pNeutrinoPfoList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pNeutrinoPfoList, neutrinoPfoListName));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pNeutrinoPfo));
 
     if (!pNeutrinoPfoList || pNeutrinoPfoList->empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_neutrinoPfoListName));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Pfo>(*this, m_neutrinoPfoListName));
 }

void lar_content::CheatingNeutrinoCreationAlgorithm::CreatePfoHierarchy	(	const pandora::MCParticle *const	pParentMCParticle,
		const pandora::ParticleFlowObject *const	pParentPfo,
		const MCParticleToPfoMap &	mcParticleToPfoMap
	)		const

private

Use information from mc particles and the mc particle to pfo map to fully-reconstruct the daughter pfo hierarchy.

Parameters

pParentMCParticle	the address of the (current) parent mc particle
pParentPfo	the address of the (current) parent pfo
mcParticleToPfoMap	the mc particle to pfo map

Definition at line 168 of file CheatingNeutrinoCreationAlgorithm.cc.

 {
     for (const MCParticle *const pDaughterMCParticle : pParentMCParticle->GetDaughterList())
     {
         MCParticleToPfoMap::const_iterator mapIter = mcParticleToPfoMap.find(pDaughterMCParticle);
 
         if (mcParticleToPfoMap.end() == mapIter)
         {
             this->CreatePfoHierarchy(pDaughterMCParticle, pParentPfo, mcParticleToPfoMap);
             continue;
         }
 
         const ParticleFlowObject *const pDaughterPfo(mapIter->second);
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SetPfoParentDaughterRelationship(*this, pParentPfo, pDaughterPfo));
         this->CreatePfoHierarchy(pDaughterMCParticle, pDaughterPfo, mcParticleToPfoMap);
     }
 }

void lar_content::CheatingNeutrinoCreationAlgorithm::GetMCNeutrinoVector ( pandora::MCParticleVector & mcNeutrinoVector ) const

private

Get the mc neutrino vector.

Parameters

mcNeutrinoVector to receive the mc neutrino vector

Definition at line 52 of file CheatingNeutrinoCreationAlgorithm.cc.

 {
     const MCParticleList *pMCParticleList(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_mcParticleListName, pMCParticleList));
 
     MCParticleVector allMCNeutrinoVector;
     LArMCParticleHelper::GetTrueNeutrinos(pMCParticleList, allMCNeutrinoVector);
 
     for (const MCParticle *const pMCNeutrino : allMCNeutrinoVector)
     {
         if (LArMCParticleHelper::IsNeutrino(pMCNeutrino) && (MC_3D == pMCNeutrino->GetMCParticleType()))
             mcNeutrinoVector.push_back(pMCNeutrino);
     }
 }

void lar_content::CheatingNeutrinoCreationAlgorithm::GetMCParticleToDaughterPfoMap ( MCParticleToPfoMap & mcParticleToPfoMap ) const

private

Extract candidate daughter pfos from external lists and populate a map from main mc particle (or primary) to pfo.

Parameters

mcParticleToPfoMap to receive the mc particle to pfo map

Definition at line 122 of file CheatingNeutrinoCreationAlgorithm.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);
     }
 
     for (const std::string &daughterPfoListName : m_daughterPfoListNames)
     {
         const PfoList *pDaughterPfoList(nullptr);
 
         if (STATUS_CODE_SUCCESS != PandoraContentApi::GetList(*this, daughterPfoListName, pDaughterPfoList))
         {
             if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                 std::cout << "CheatingNeutrinoCreationAlgorithm: pfo list " << daughterPfoListName << " unavailable." << std::endl;
 
             continue;
         }
 
         for (const ParticleFlowObject *const pDaughterPfo : *pDaughterPfoList)
         {
             const MCParticle *pMCParticle(LArMCParticleHelper::GetMainMCParticle(pDaughterPfo));
 
             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 (!mcParticleToPfoMap.insert(MCParticleToPfoMap::value_type(pMCParticle, pDaughterPfo)).second)
                 throw StatusCodeException(STATUS_CODE_OUT_OF_RANGE);
         }
     }
 }

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

private

Definition at line 189 of file CheatingNeutrinoCreationAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "CollapseToPrimaryMCParticles", m_collapseToPrimaryMCParticles));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "MCParticleListName", m_mcParticleListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "NeutrinoPfoListName", m_neutrinoPfoListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "VertexListName", m_vertexListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "DaughterPfoListNames", m_daughterPfoListNames));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexTolerance", m_vertexTolerance));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::CheatingNeutrinoCreationAlgorithm::Run ( )

private

Definition at line 27 of file CheatingNeutrinoCreationAlgorithm.cc.

 {
     MCParticleVector mcNeutrinoVector;
     this->GetMCNeutrinoVector(mcNeutrinoVector);
 
     for (const MCParticle *const pMCNeutrino : mcNeutrinoVector)
     {
         const ParticleFlowObject *pNeutrinoPfo(nullptr);
         this->CreateAndSaveNeutrinoPfo(pMCNeutrino, pNeutrinoPfo);
 
         if (!pNeutrinoPfo)
             return STATUS_CODE_FAILURE;
 
         this->AddNeutrinoVertex(pMCNeutrino, pNeutrinoPfo);
 
         MCParticleToPfoMap mcParticleToPfoMap;
         this->GetMCParticleToDaughterPfoMap(mcParticleToPfoMap);
         this->CreatePfoHierarchy(pMCNeutrino, pNeutrinoPfo, mcParticleToPfoMap);
     }
 
     return STATUS_CODE_SUCCESS;
 }