CosmicRayVertexBuildingAlgorithm class. More...

#include <CosmicRayVertexBuildingAlgorithm.h>

Inheritance diagram for lar_content::CosmicRayVertexBuildingAlgorithm:

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

Private Member Functions
pandora::StatusCode	Run ()

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

void	GetCosmicPfos (const pandora::PfoList *const pPfoList, pandora::PfoVector &pfoVector) const
	Get the list of input pfos to this algorithm. More...

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

void	BuildCosmicRayParticles (const LArPointingClusterMap &pointingClusterMap, const pandora::PfoVector &pfoVector) const
	Reconstruct the vertex and direction of a list of cosmic-ray Pfos. More...

void	BuildCosmicRayParent (const LArPointingClusterMap &pointingClusterMap, const pandora::ParticleFlowObject *const pPfo) const
	Reconstruct the vertex and direction of a parent cosmic-ray Pfo. More...

void	BuildCosmicRayDaughter (const pandora::ParticleFlowObject *const pPfo) const
	Reconstruct the vertex and direction of a daughter cosmic-ray Pfo. 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...

bool	m_isDualPhase
	type of geometry More...

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

std::string	m_parentPfoListName
	The name of the input pfo list. More...

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

float	m_maxVertexDisplacementFromTrack
	The maximum separation of a close vertex from the cosmic ray track. More...

Detailed Description

CosmicRayVertexBuildingAlgorithm class.

Definition at line 21 of file CosmicRayVertexBuildingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CosmicRayVertexBuildingAlgorithm::CosmicRayVertexBuildingAlgorithm ( )

Default constructor.

Definition at line 22 of file CosmicRayVertexBuildingAlgorithm.cc.

                                                                    :
     m_useParentShowerVertex(false),
     m_isDualPhase(false),
     m_halfWindowLayers(30),
     m_maxVertexDisplacementFromTrack(1.f)
 {
 }

Member Function Documentation

void lar_content::CosmicRayVertexBuildingAlgorithm::BuildCosmicRayDaughter ( const pandora::ParticleFlowObject *const pPfo ) const

private

Reconstruct the vertex and direction of a daughter cosmic-ray Pfo.

Parameters

pPfo	the daughter Pfo

Definition at line 235 of file CosmicRayVertexBuildingAlgorithm.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 (daughterList.empty() || parentList.empty())
         return;
 
     bool found(false);
     float closestMaxVerticalCoordinate(-std::numeric_limits<float>::max()), maxVerticalCoordinate(-std::numeric_limits<float>::max());
     CartesianVector closestMaxVerticalVertex(0.f, 0.f, 0.f), maxVerticalVertex(0.f, 0.f, 0.f);
 
     for (const Cluster *const pDaughterCluster : daughterList)
     {
         CaloHitList daughterCaloHitList;
         pDaughterCluster->GetOrderedCaloHitList().FillCaloHitList(daughterCaloHitList);
 
         for (const Cluster *const pParentCluster : parentList)
         {
             CaloHitList parentCaloHitList;
             pParentCluster->GetOrderedCaloHitList().FillCaloHitList(parentCaloHitList);
 
             for (const CaloHit *const pDaughterCaloHit : daughterCaloHitList)
             {
                 const CartesianVector &daughterPosition(pDaughterCaloHit->GetPositionVector());
 
                 for (const CaloHit *const pParentCaloHit : parentCaloHitList)
                 {
                     const CartesianVector &parentPosition(pParentCaloHit->GetPositionVector());
                     const float separationSquared((daughterPosition - parentPosition).GetMagnitudeSquared());
                     const float verticalCoordinate(m_isDualPhase ? daughterPosition.GetX() : daughterPosition.GetY());
 
                     if (verticalCoordinate > maxVerticalCoordinate)
                     {
                         maxVerticalCoordinate = verticalCoordinate;
                         maxVerticalVertex = daughterPosition;
                     }
 
                     if (separationSquared < (m_maxVertexDisplacementFromTrack * m_maxVertexDisplacementFromTrack))
                     {
                         if (verticalCoordinate > closestMaxVerticalCoordinate)
                         {
                             found = true;
                             closestMaxVerticalCoordinate = verticalCoordinate;
                             closestMaxVerticalVertex = daughterPosition;
                         }
                     }
                 }
             }
         }
     }
 
     const CartesianVector &daughterVertex(found ? closestMaxVerticalVertex : maxVerticalVertex);
     const CartesianVector &vertexPosition(m_useParentShowerVertex ? LArClusterHelper::GetClosestPosition(daughterVertex, parentList) : daughterVertex);
 
     this->SetParticleParameters(vertexPosition, CartesianVector(0.f, 0.f, 0.f), pDaughterPfo);
 }

void lar_content::CosmicRayVertexBuildingAlgorithm::BuildCosmicRayParent	(	const LArPointingClusterMap &	pointingClusterMap,
		const pandora::ParticleFlowObject *const	pPfo
	)		const

private

Reconstruct the vertex and direction of a parent cosmic-ray Pfo.

Parameters

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

Definition at line 139 of file CosmicRayVertexBuildingAlgorithm.cc.

 {
     ClusterList clusterList;
     LArPfoHelper::GetClusters(pPfo, TPC_3D, clusterList);
 
     if (clusterList.empty())
         return;
 
     // Take highest point as vertex of parent Pfos (TODO: do something more sophisticated for horizontal events)
     bool foundVtx(false);
     CartesianVector vtxPosition(0.f, 0.f, 0.f);
     CartesianVector vtxDirection(0.f, 0.f, 0.f);
 
     bool foundEnd(false);
     CartesianVector endPosition(0.f, 0.f, 0.f);
     CartesianVector endDirection(0.f, 0.f, 0.f);
 
     for (ClusterList::const_iterator cIter1 = clusterList.begin(), cIterEnd1 = clusterList.end(); cIter1 != cIterEnd1; ++cIter1)
     {
         const Cluster *const pCluster = *cIter1;
 
         try
         {
             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);
 
             LArPointingClusterMap::const_iterator cIter2 = pointingClusterMap.find(pCluster);
 
             if (pointingClusterMap.end() != cIter2)
             {
                 const LArPointingCluster &pointingCluster(cIter2->second);
 
                 minPosition = pointingCluster.GetInnerVertex().GetPosition();
                 maxPosition = pointingCluster.GetOuterVertex().GetPosition();
                 minDirection = pointingCluster.GetInnerVertex().GetDirection();
                 maxDirection = pointingCluster.GetOuterVertex().GetDirection();
             }
             else
             {
                 LArClusterHelper::GetExtremalCoordinates(pCluster, minPosition, maxPosition);
                 minDirection = (maxPosition - minPosition).GetUnitVector();
                 maxDirection = (minPosition - maxPosition).GetUnitVector();
             }
 
             if ((maxPosition - minPosition).GetMagnitudeSquared() < std::numeric_limits<float>::epsilon())
                 throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
             // ATTN X is the vertical coordinate in Dual-Phase geometry
             const float minVerticalCoordinate(m_isDualPhase ? minPosition.GetX() : minPosition.GetY());
             const float maxVerticalCoordinate(m_isDualPhase ? maxPosition.GetX() : maxPosition.GetY());
 
             if (!foundVtx || (minVerticalCoordinate > std::max(maxVerticalCoordinate, m_isDualPhase ? vtxPosition.GetX() : vtxPosition.GetY())))
             {
                 foundVtx = true;
                 vtxPosition = minPosition;
                 vtxDirection = minDirection;
             }
 
             if (!foundVtx || (maxVerticalCoordinate > std::max(minVerticalCoordinate, m_isDualPhase ? vtxPosition.GetX() : vtxPosition.GetY())))
             {
                 foundVtx = true;
                 vtxPosition = maxPosition;
                 vtxDirection = maxDirection;
             }
 
             if (!foundEnd || (minVerticalCoordinate < std::min(maxVerticalCoordinate, m_isDualPhase ? endPosition.GetX() : endPosition.GetY())))
             {
                 foundEnd = true;
                 endPosition = minPosition;
                 endDirection = minDirection;
             }
 
             if (!foundEnd || (maxVerticalCoordinate < std::min(minVerticalCoordinate, m_isDualPhase ? endPosition.GetX() : endPosition.GetY())))
             {
                 foundEnd = true;
                 endPosition = maxPosition;
                 endDirection = maxDirection;
             }
         }
         catch (StatusCodeException &statusCodeException)
         {
             if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                 throw statusCodeException;
 
             continue;
         }
     }
 
     if (!(foundVtx && foundEnd))
         return;
 
     this->SetParticleParameters(vtxPosition, vtxDirection, pPfo);
 }

void lar_content::CosmicRayVertexBuildingAlgorithm::BuildCosmicRayParticles	(	const LArPointingClusterMap &	pointingClusterMap,
		const pandora::PfoVector &	pfoVector
	)		const

private

Reconstruct the vertex and direction of a list of cosmic-ray Pfos.

Parameters

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

Definition at line 120 of file CosmicRayVertexBuildingAlgorithm.cc.

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

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

private

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

Parameters

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

Definition at line 84 of file CosmicRayVertexBuildingAlgorithm.cc.

 {
     const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     for (PfoVector::const_iterator pIter = pfoVector.begin(), pIterEnd = pfoVector.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::CosmicRayVertexBuildingAlgorithm::GetCosmicPfos	(	const pandora::PfoList *const	pPfoList,
		pandora::PfoVector &	pfoVector
	)		const

private

Get the list of input pfos to this algorithm.

Parameters

pfoList to receive the list of input pfos

Definition at line 58 of file CosmicRayVertexBuildingAlgorithm.cc.

 {
     PfoList outputList;
 
     for (PfoList::const_iterator pIter = pPfoList->begin(), pIterEnd = pPfoList->end(); pIter != pIterEnd; ++pIter)
     {
         if (!LArPfoHelper::IsFinalState(*pIter))
             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::CosmicRayVertexBuildingAlgorithm::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 332 of file CosmicRayVertexBuildingAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputPfoListName", m_parentPfoListName));
 
     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));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "IsDualPhase", m_isDualPhase));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxVertexDisplacementFromTrack", m_maxVertexDisplacementFromTrack));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::CosmicRayVertexBuildingAlgorithm::Run ( )

private

Definition at line 32 of file CosmicRayVertexBuildingAlgorithm.cc.

 {
     const PfoList *pPfoList = NULL;
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_parentPfoListName, pPfoList));
 
     if (NULL == pPfoList)
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "CosmicRayVertexBuildingAlgorithm: pfo list unavailable." << std::endl;
 
         return STATUS_CODE_SUCCESS;
     }
 
     PfoVector pfoVector;
     LArPointingClusterMap pointingClusterMap;
 
     this->GetCosmicPfos(pPfoList, pfoVector);
     this->BuildPointingClusterMap(pfoVector, pointingClusterMap);
     this->BuildCosmicRayParticles(pointingClusterMap, pfoVector);
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::CosmicRayVertexBuildingAlgorithm::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 301 of file CosmicRayVertexBuildingAlgorithm.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_START;
     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));
     }
 }