NeutrinoDaughterVerticesAlgorithm class. More...

#include <NeutrinoDaughterVerticesAlgorithm.h>

Inheritance diagram for lar_content::NeutrinoDaughterVerticesAlgorithm:

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

Private Member Functions
pandora::StatusCode	Run ()

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

void	GetDaughterPfos (const pandora::PfoList *const pfoList, pandora::PfoVector &pfoVector) const
	Get the vector of daughter pfos. More...

void	BuildPointingClusterMap (const pandora::PfoVector &pfoVector, LArPointingClusterMap &pointingClusterMap) const
	Build a map of 3D sliding fits from the input Pfos. More...

void	BuildDaughterParticles (const LArPointingClusterMap &pointingClusterMap, const pandora::PfoVector &pfoVector) const
	Reconstruct the vertex and direction of daughter Pfos. More...

void	BuildDaughterTrack (const LArPointingClusterMap &pointingClusterMap, const pandora::ParticleFlowObject *const pDaughterPfo) const
	Reconstruct the vertex and direction of a track-like Pfos. More...

void	BuildDaughterShower (const pandora::ParticleFlowObject *const pDaughterPfo) const
	Reconstruct the vertex and direction of a shower-like Pfos. More...

void	SetParticleParameters (const pandora::CartesianVector &vtxPosition, const pandora::CartesianVector &vtxDirection, const pandora::ParticleFlowObject *const pPfo) const
	Set the vertex and direction of the Pfos. More...

Private Attributes
bool	m_useParentShowerVertex
	use the parent pfo for the shower vertices More...

unsigned int	m_halfWindowLayers
	number of layers to use for half-window of sliding fit More...

std::string	m_neutrinoListName
	The input list of pfo list names. More...

std::string	m_vertexListName
	The name of the output cosmic-ray vertex list. More...

Detailed Description

NeutrinoDaughterVerticesAlgorithm class.

Definition at line 21 of file NeutrinoDaughterVerticesAlgorithm.h.

Constructor & Destructor Documentation

lar_content::NeutrinoDaughterVerticesAlgorithm::NeutrinoDaughterVerticesAlgorithm ( )

Default constructor.

Definition at line 22 of file NeutrinoDaughterVerticesAlgorithm.cc.

                                                                      : m_useParentShowerVertex(false), m_halfWindowLayers(20)
 {
 }

Member Function Documentation

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildDaughterParticles	(	const LArPointingClusterMap &	pointingClusterMap,
		const pandora::PfoVector &	pfoVector
	)		const

private

Reconstruct the vertex and direction of daughter Pfos.

Parameters

pointingClusterMap	the input map of 3D pointing clusters
pfoVector	the input list of Pfos

Definition at line 115 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     for (PfoVector::const_iterator iter = pfoVector.begin(), iterEnd = pfoVector.end(); iter != iterEnd; ++iter)
     {
         const ParticleFlowObject *const pPfo = *iter;
 
         if (LArPfoHelper::IsTrack(pPfo))
         {
             this->BuildDaughterTrack(pointingClusterMap, pPfo);
         }
         else
         {
             this->BuildDaughterShower(pPfo);
         }
     }
 }

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildDaughterShower ( const pandora::ParticleFlowObject *const pDaughterPfo ) const

private

Reconstruct the vertex and direction of a shower-like Pfos.

Parameters

pPfo	the input Pfo

Definition at line 229 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     if (pDaughterPfo->GetParentPfoList().size() != 1)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const ParticleFlowObject *const pParentPfo = *(pDaughterPfo->GetParentPfoList().begin());
 
     if (LArPfoHelper::IsNeutrino(pParentPfo) && pParentPfo->GetVertexList().size() != 1)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     ClusterList parentList, daughterList;
     LArPfoHelper::GetClusters(pParentPfo, TPC_3D, parentList);
     LArPfoHelper::GetClusters(pDaughterPfo, TPC_3D, daughterList);
 
     if (daughterList.empty())
         return;
 
     if (LArPfoHelper::IsNeutrino(pParentPfo))
     {
         const Vertex *const pVertex = *(pParentPfo->GetVertexList().begin());
         const CartesianVector vtxPosition(
             m_useParentShowerVertex ? pVertex->GetPosition() : LArClusterHelper::GetClosestPosition(pVertex->GetPosition(), daughterList));
 
         return this->SetParticleParameters(vtxPosition, CartesianVector(0.f, 0.f, 0.f), pDaughterPfo);
     }
 
     if (parentList.empty())
         return;
 
     bool foundVtx(false);
     float vtxDistanceSquared(0.f);
     CartesianVector vtxPosition(0.f, 0.f, 0.f);
 
     for (ClusterList::const_iterator dIter = daughterList.begin(), dIterEnd = daughterList.end(); dIter != dIterEnd; ++dIter)
     {
         const Cluster *const pDaughterCluster = *dIter;
 
         for (ClusterList::const_iterator pIter = parentList.begin(), pIterEnd = parentList.end(); pIter != pIterEnd; ++pIter)
         {
             const Cluster *const pParentCluster = *pIter;
 
             CartesianVector closestDaughterPosition(0.f, 0.f, 0.f), closestParentPosition(0.f, 0.f, 0.f);
             LArClusterHelper::GetClosestPositions(pDaughterCluster, pParentCluster, closestDaughterPosition, closestParentPosition);
 
             const float closestDistanceSquared((closestDaughterPosition - closestParentPosition).GetMagnitudeSquared());
 
             if (!foundVtx || closestDistanceSquared < vtxDistanceSquared)
             {
                 foundVtx = true;
                 vtxDistanceSquared = closestDistanceSquared;
                 vtxPosition = (m_useParentShowerVertex ? closestParentPosition : closestDaughterPosition);
             }
         }
     }
 
     if (!foundVtx)
         return;
 
     this->SetParticleParameters(vtxPosition, CartesianVector(0.f, 0.f, 0.f), pDaughterPfo);
 }

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildDaughterTrack	(	const LArPointingClusterMap &	pointingClusterMap,
		const pandora::ParticleFlowObject *const	pDaughterPfo
	)		const

private

Reconstruct the vertex and direction of a track-like Pfos.

Parameters

pointingClusterMap	the input map of 3D pointing clusters
pPfo	the input Pfo

Definition at line 134 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     if (pDaughterPfo->GetParentPfoList().size() != 1)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const ParticleFlowObject *const pParentPfo = *(pDaughterPfo->GetParentPfoList().begin());
 
     ClusterList parentList, daughterList;
     LArPfoHelper::GetClusters(pParentPfo, TPC_3D, parentList);
     LArPfoHelper::GetClusters(pDaughterPfo, TPC_3D, daughterList);
 
     if (parentList.empty() && pParentPfo->GetVertexList().empty())
         return;
 
     bool foundVtx(false);
     float vtxDistance(0.f);
     CartesianVector vtxPosition(0.f, 0.f, 0.f);
     CartesianVector vtxDirection(0.f, 0.f, 0.f);
 
     for (ClusterList::const_iterator dIter = daughterList.begin(), dIterEnd = daughterList.end(); dIter != dIterEnd; ++dIter)
     {
         const Cluster *const pDaughterCluster = *dIter;
 
         CartesianVector minPosition(0.f, 0.f, 0.f), maxPosition(0.f, 0.f, 0.f);
         CartesianVector minDirection(0.f, 0.f, 0.f), maxDirection(0.f, 0.f, 0.f);
         bool foundDirection(false);
 
         LArPointingClusterMap::const_iterator cIter = pointingClusterMap.find(pDaughterCluster);
 
         if (pointingClusterMap.end() != cIter)
         {
             const LArPointingCluster &pointingCluster(cIter->second);
 
             minPosition = pointingCluster.GetInnerVertex().GetPosition();
             maxPosition = pointingCluster.GetOuterVertex().GetPosition();
             minDirection = pointingCluster.GetInnerVertex().GetDirection();
             maxDirection = pointingCluster.GetOuterVertex().GetDirection();
             foundDirection = true;
         }
         else
         {
             LArClusterHelper::GetExtremalCoordinates(pDaughterCluster, minPosition, maxPosition);
         }
 
         if ((maxPosition - minPosition).GetMagnitudeSquared() < std::numeric_limits<float>::epsilon())
             continue;
 
         if (!foundDirection)
         {
             minDirection = (maxPosition - minPosition).GetUnitVector();
             maxDirection = (minPosition - maxPosition).GetUnitVector();
         }
 
         float minDistance(std::numeric_limits<float>::max());
         float maxDistance(std::numeric_limits<float>::max());
 
         for (ClusterList::const_iterator pIter = parentList.begin(), pIterEnd = parentList.end(); pIter != pIterEnd; ++pIter)
         {
             const Cluster *const pParentCluster = *pIter;
             minDistance = std::min(minDistance, (LArClusterHelper::GetClosestDistance(minPosition, pParentCluster)));
             maxDistance = std::min(maxDistance, (LArClusterHelper::GetClosestDistance(maxPosition, pParentCluster)));
         }
 
         if (LArPfoHelper::IsNeutrino(pParentPfo) && !pParentPfo->GetVertexList().empty())
         {
             const Vertex *const pVertex = *(pParentPfo->GetVertexList().begin());
             minDistance = std::min(minDistance, (pVertex->GetPosition() - minPosition).GetMagnitude());
             maxDistance = std::min(maxDistance, (pVertex->GetPosition() - maxPosition).GetMagnitude());
         }
 
         if (!foundVtx || (minDistance < vtxDistance))
         {
             foundVtx = true;
             vtxDistance = minDistance;
             vtxPosition = minPosition;
             vtxDirection = minDirection;
         }
 
         if (!foundVtx || (maxDistance < vtxDistance))
         {
             foundVtx = true;
             vtxDistance = maxDistance;
             vtxPosition = maxPosition;
             vtxDirection = maxDirection;
         }
     }
 
     if (!foundVtx)
         return;
 
     this->SetParticleParameters(vtxPosition, vtxDirection, pDaughterPfo);
 }

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildPointingClusterMap	(	const pandora::PfoVector &	pfoVector,
		LArPointingClusterMap &	pointingClusterMap
	)		const

private

Build a map of 3D sliding fits from the input Pfos.

Parameters

pfoVector	the input particle flow objects
pointingClusterMap	the output map of 3D pointing clusters

Definition at line 79 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     for (PfoVector::const_iterator pIter = pfoList.begin(), pIterEnd = pfoList.end(); pIter != pIterEnd; ++pIter)
     {
         const ParticleFlowObject *const pPfo = *pIter;
 
         if (!LArPfoHelper::IsTrack(pPfo))
             continue;
 
         ClusterList clusterList;
         LArPfoHelper::GetClusters(pPfo, TPC_3D, clusterList);
 
         for (ClusterList::const_iterator cIter = clusterList.begin(), cIterEnd = clusterList.end(); cIter != cIterEnd; ++cIter)
         {
             const Cluster *const pCluster = *cIter;
 
             try
             {
                 const LArPointingCluster pointingCluster(pCluster, m_halfWindowLayers, slidingFitPitch);
 
                 if (!pointingClusterMap.insert(LArPointingClusterMap::value_type(pCluster, pointingCluster)).second)
                     throw StatusCodeException(STATUS_CODE_FAILURE);
             }
             catch (StatusCodeException &statusCodeException)
             {
                 if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                     throw statusCodeException;
             }
         }
     }
 }

void lar_content::NeutrinoDaughterVerticesAlgorithm::GetDaughterPfos	(	const pandora::PfoList *const	pfoList,
		pandora::PfoVector &	pfoVector
	)		const

private

Get the vector of daughter pfos.

Parameters

pfoList	the input list of neutrino pfos
pfoVector	to receive the vector of daughter pfos

Definition at line 53 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     PfoList outputList;
 
     for (PfoList::const_iterator pIter = pPfoList->begin(), pIterEnd = pPfoList->end(); pIter != pIterEnd; ++pIter)
     {
         if (!LArPfoHelper::IsNeutrino(*pIter) && (*pIter)->GetVertexList().size() != 1)
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
         LArPfoHelper::GetAllDownstreamPfos(*pIter, outputList);
     }
 
     for (PfoList::const_iterator pIter = outputList.begin(), pIterEnd = outputList.end(); pIter != pIterEnd; ++pIter)
     {
         ClusterList clusterList;
         LArPfoHelper::GetClusters(*pIter, TPC_3D, clusterList);
 
         if (clusterList.empty())
             continue;
 
         pfoVector.push_back(*pIter);
     }
 }

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

private

Definition at line 323 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "NeutrinoPfoListName", m_neutrinoListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputVertexListName", m_vertexListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "UseParentForShowerVertex", m_useParentShowerVertex));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitHalfWindow", m_halfWindowLayers));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::NeutrinoDaughterVerticesAlgorithm::Run ( )

private

Definition at line 28 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     const PfoList *pPfoList = NULL;
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_neutrinoListName, pPfoList));
 
     if (!pPfoList || pPfoList->empty())
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "NeutrinoDaughterVerticesAlgorithm: unable to find pfo list " << m_neutrinoListName << std::endl;
 
         return STATUS_CODE_SUCCESS;
     }
 
     PfoVector pfoVector;
     LArPointingClusterMap pointingClusterMap;
 
     this->GetDaughterPfos(pPfoList, pfoVector);
     this->BuildPointingClusterMap(pfoVector, pointingClusterMap);
     this->BuildDaughterParticles(pointingClusterMap, pfoVector);
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::NeutrinoDaughterVerticesAlgorithm::SetParticleParameters	(	const pandora::CartesianVector &	vtxPosition,
		const pandora::CartesianVector &	vtxDirection,
		const pandora::ParticleFlowObject *const	pPfo
	)		const

private

Set the vertex and direction of the Pfos.

Parameters

vtxPosition	the input vertex position
vtxDirection	the input vertex direction
pPfo	the input Pfo

Definition at line 292 of file NeutrinoDaughterVerticesAlgorithm.cc.

 {
     if (!pPfo->GetVertexList().empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     PandoraContentApi::ParticleFlowObject::Metadata metadata;
     metadata.m_momentum = vtxDirection;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));
 
     const VertexList *pVertexList = NULL;
     std::string vertexListName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pVertexList, vertexListName));
 
     PandoraContentApi::Vertex::Parameters parameters;
     parameters.m_position = vtxPosition;
     parameters.m_vertexLabel = VERTEX_INTERACTION;
     parameters.m_vertexType = VERTEX_3D;
 
     const Vertex *pVertex(NULL);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
 
     if (!pVertexList->empty())
     {
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*this, m_vertexListName));
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo<Vertex>(*this, pPfo, pVertex));
     }
 }