ElectronInitialRegionRefinementAlgorithm class. More...

#include "ElectronInitialRegionRefinementAlgorithm.h"

Inheritance diagram for lar_content::ElectronInitialRegionRefinementAlgorithm:

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

Private Types
typedef std::map< const pandora::MCParticle *, pandora::CaloHitList >	HitOwnershipMap

Private Member Functions
pandora::StatusCode	Run ()

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

void	FillShowerPfoVector (pandora::PfoVector &showerPfoVector) const
	Obtain a sorted vector of the reconstructed shower pfos. More...

void	RefineShower (const pandora::ParticleFlowObject *const pShowerPfo) const
	Find and evaluate shower connection pathway, removing if necessary. More...

pandora::StatusCode	GetNeutrinoVertex (pandora::CartesianVector &nuVertex3D) const
	Obtain the reconstructed neutrino vertex. More...

void	BuildViewProtoShowers (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::CartesianVector &nuVertex3D, pandora::HitType hitType, ProtoShowerVector &protoShowerVector) const
	Build the 2D ProtoShower objects for a given view. More...

pandora::StatusCode	GetHitListOfType (const pandora::HitType hitType, const pandora::CaloHitList *&pCaloHitList) const
	Obtain the event hit list of a given view. More...

pandora::CartesianVector	GetShowerVertex (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::HitType hitType, const pandora::CartesianVector &nuVertex3D) const
	Fit the shower to obtain a 2D shower vertex. More...

void	RefineShowerVertex (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::HitType hitType, const pandora::CartesianVector &nuVertex3D, const pandora::CartesianVector &peakDirection, pandora::CartesianVector &showerVertexPosition) const
	Move the shower vertex closer to the connection pathway. More...

bool	IsShowerConnected (const pandora::CartesianVector &showerVertexPosition, const pandora::CartesianVector &nuVertex2D, const pandora::CartesianVector &peakDirection) const
	To determine whether the shower vertex lies on the connection pathway. More...

bool	IsSpineCoincident (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::CartesianVector &nuVertex3D, const pandora::HitType hitType, const pandora::CartesianVector &showerVertex, const pandora::CaloHitList &showerSpineHitList) const
	To determine if the hits downstream of the shower vertex lie within the shower. More...

void	BuildViewPathways (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::CaloHitList &protectedHits, const pandora::CartesianVector &nuVertex3D, pandora::HitType hitType, ConnectionPathwayVector &viewPathways) const
	Build the connection pathways of all other particles in the event. More...

void	RefineHitsToAdd (const pandora::CartesianVector &nuVertex3D, const pandora::HitType hitType, const ConnectionPathwayVector &viewPathways, ProtoShower &protoShower) const
	Determine the continuous and unambiguous hits to add to an electron-like shower pfo. More...

void	FindContinuousPath (const pandora::CaloHitList &refinedHitList, const pandora::CartesianVector &nuVertex2D, pandora::CaloHitList &continuousHitList) const
	Find the continuous path of hits that lies closest to a given point. More...

void	SetMetadata (const pandora::ParticleFlowObject *const pShowerPfo, const LArMvaHelper::MvaFeatureMap &featureMap) const
	Add the shower characterisation information to the pfo metadata. More...

void	FillElectronHitMap (HitOwnershipMap &electronHitMap) const
	Determine the one-to-one mapping of leading MCParticle electrons and the hits which contain their energy depositions. More...

bool	IsElectron (const pandora::ParticleFlowObject *const pShowerPfo, const HitOwnershipMap &electronHitMap) const
	To determine whether a pfo is a true leading electron via its completeness and purity. More...

Private Attributes
PeakDirectionFinderTool *	m_pShowerPeakDirectionFinderTool
	The shower initial pathway direction finder tool. More...

PeakDirectionFinderTool *	m_pEventPeakDirectionFinderTool
	The other (not incl. shower) initial pathway direction finder tool. More...

ShowerSpineFinderTool *	m_pShowerSpineFinderTool
	The shower spine finder tool for the shower. More...

ShowerSpineFinderTool *	m_pEventPathwayFinderTool
	The shower spine finder tool for all other event particles. More...

ShowerStartFinderTool *	m_pShowerStartFinderTool
	The shower start finder tool. More...

ProtoShowerMatchingTool *	m_pProtoShowerMatchingTool
	The 2D -> 3D ProtoShower matching tool. More...

std::string	m_showerPfoListName
	The shower pfo list name. More...

std::string	m_neutrinoVertexListName
	The neutrino vertex list name. More...

std::string	m_caloHitListNameU
	The U calo hit list name. More...

std::string	m_caloHitListNameV
	The V calo hit list name. More...

std::string	m_caloHitListNameW
	The W calo hit list name. More...

unsigned int	m_minShowerHits3D
	The min. number of hits of a significant shower. More...

unsigned int	m_showerSlidingFitWindow
	The sliding fit window for shower fits. More...

float	m_maxCoincidenceTransverseSeparation
	The max. transverse distance from the pathway direction of a coincident shower vertex. More...

float	m_minSpinePurity
	The min. purity of a coincident shower spine downstream of the shower vertex. More...

bool	m_trainingMode
	Whether to run the algorithm to train the BDT. More...

std::string	m_trainingFileName
	The name of the output training file name. More...

float	m_unambiguousThreshold
	The min. transverse distance of an unambiguous shower hit from another pathway direction. More...

float	m_maxConnectionDistance
	The max. distance between connected hits. More...

unsigned int	m_minNConnectedHits
	The number of connected hits needed for a conntected pathway. More...

float	m_minElectronCompleteness
	The min. completeness of an electron-like pfo. More...

float	m_minElectronPurity
	The min. purity of an electron-like pfo. More...

float	m_maxSeparationFromHit
	The max. separation between the projected 3D shower start and the closest 2D shower hit. More...

float	m_maxProjectionSeparation
	The max. separation between the projected 3D shower start and the shower start of that view. More...

float	m_maxXSeparation
	The max. drift-coordinate separation between a 3D shower start and a matched 2D shower hit. More...

ConnectionPathwayFeatureTool::FeatureToolMap	m_featureToolMap
	The feature tool map. More...

pandora::StringVector	m_algorithmToolNames
	The algorithm tool names. More...

Detailed Description

ElectronInitialRegionRefinementAlgorithm class.

Definition at line 26 of file ElectronInitialRegionRefinementAlgorithm.h.

Member Typedef Documentation

typedef std::map<const pandora::MCParticle *, pandora::CaloHitList> lar_content::ElectronInitialRegionRefinementAlgorithm::HitOwnershipMap

private

Definition at line 35 of file ElectronInitialRegionRefinementAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ElectronInitialRegionRefinementAlgorithm::ElectronInitialRegionRefinementAlgorithm ( )

Default constructor.

Definition at line 32 of file ElectronInitialRegionRefinementAlgorithm.cc.

                                                                                    :
     m_minShowerHits3D(50),
     m_showerSlidingFitWindow(1000),
     m_maxCoincidenceTransverseSeparation(5.f),
     m_minSpinePurity(0.7f),
     m_trainingMode(false),
     m_trainingFileName("ConnectionPathwayTrain.txt"),
     m_unambiguousThreshold(0.5f),
     m_maxConnectionDistance(1.f),
     m_minNConnectedHits(2),
     m_minElectronCompleteness(0.33f),
     m_minElectronPurity(0.5f),
     m_maxSeparationFromHit(3.f),
     m_maxProjectionSeparation(5.f),
     m_maxXSeparation(0.5f)
 {
 }

Member Function Documentation

void lar_content::ElectronInitialRegionRefinementAlgorithm::BuildViewPathways	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CaloHitList &	protectedHits,
		const pandora::CartesianVector &	nuVertex3D,
		pandora::HitType	hitType,
		ConnectionPathwayVector &	viewPathways
	)		const

private

Build the connection pathways of all other particles in the event.

Parameters

pShowerPfo	the input shower pfo
protectedHits	the list of protected hits which will not be considered
nuVertex3D	the 3D neutrino vertex
hitType	the 2D view
viewPathways	the output vector of found connection pathways

Definition at line 404 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::LArPfoHelper::GetCaloHits(), GetHitListOfType(), m_pEventPathwayFinderTool, m_pEventPeakDirectionFinderTool, lar_content::LArGeometryHelper::ProjectPosition(), lar_content::ShowerSpineFinderTool::Run(), and lar_content::PeakDirectionFinderTool::Run().

Referenced by RefineShower().

 {
     const CaloHitList *pViewHitList(nullptr);
 
     if (this->GetHitListOfType(hitType, pViewHitList) != STATUS_CODE_SUCCESS)
         return;
 
     // Get the peak direction vector
     CartesianPointVector eventPeakDirectionVector;
     m_pEventPeakDirectionFinderTool->Run(pShowerPfo, nuVertex3D, pViewHitList, hitType, eventPeakDirectionVector);
 
     CaloHitList unavailableHitList(protectedHits);
     LArPfoHelper::GetCaloHits(pShowerPfo, hitType, unavailableHitList);
 
     for (CartesianVector &eventPeakDirection : eventPeakDirectionVector)
     {
         CaloHitList pathwayHitList;
         if (m_pEventPathwayFinderTool->Run(nuVertex3D, pViewHitList, hitType, eventPeakDirection, unavailableHitList, pathwayHitList) != STATUS_CODE_SUCCESS)
             continue;
 
         const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
         const ConnectionPathway connectionPathway(nuVertex2D, eventPeakDirection);
 
         viewPathways.push_back(connectionPathway);
         unavailableHitList.insert(unavailableHitList.begin(), pathwayHitList.begin(), pathwayHitList.end());
     }
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::BuildViewProtoShowers	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CartesianVector &	nuVertex3D,
		pandora::HitType	hitType,
		ProtoShowerVector &	protoShowerVector
	)		const

private

Build the 2D ProtoShower objects for a given view.

Parameters

pShowerPfo	the input shower pfo
nuVertex3D	the 3D neutrino vertex
hitType	the 2D view
protoShowerVector	the output vector of ProtoShower objects

Definition at line 191 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::ProtoShower::AddHitToAdd(), f, lar_content::LArPfoHelper::GetCaloHits(), GetHitListOfType(), GetShowerVertex(), IsSpineCoincident(), m_pShowerPeakDirectionFinderTool, m_pShowerSpineFinderTool, m_pShowerStartFinderTool, lar_content::LArGeometryHelper::ProjectPosition(), RefineShowerVertex(), lar_content::ShowerSpineFinderTool::Run(), lar_content::PeakDirectionFinderTool::Run(), and lar_content::ShowerStartFinderTool::Run().

Referenced by RefineShower().

 {
     const CaloHitList *pViewHitList(nullptr);
 
     if (this->GetHitListOfType(hitType, pViewHitList) != STATUS_CODE_SUCCESS)
         return;
 
     CartesianVector showerVertexPosition(0.f, 0.f, 0.f);
     try
     {
         showerVertexPosition = this->GetShowerVertex(pShowerPfo, hitType, nuVertex3D);
     }
     catch (...)
     {
         return;
     }
 
     // Determine directions of pathways out of neutrino vertex
     CartesianPointVector peakDirectionVector;
     if (m_pShowerPeakDirectionFinderTool->Run(pShowerPfo, nuVertex3D, pViewHitList, hitType, peakDirectionVector) != STATUS_CODE_SUCCESS)
         return;
 
     // Investigate each direction
     CaloHitList unavailableHitList;
     for (CartesianVector &peakDirection : peakDirectionVector)
     {
         // Collect the hits associated with the pathway (the shower spine)
         CaloHitList showerSpineHitList;
         if (m_pShowerSpineFinderTool->Run(nuVertex3D, pViewHitList, hitType, peakDirection, unavailableHitList, showerSpineHitList) != STATUS_CODE_SUCCESS)
             continue;
 
         this->RefineShowerVertex(pShowerPfo, hitType, nuVertex3D, peakDirection, showerVertexPosition);
 
         // Quality check: If the spine passes the shower vertex, does it live inside the shower?
         if (!this->IsSpineCoincident(pShowerPfo, nuVertex3D, hitType, showerVertexPosition, showerSpineHitList))
             continue;
 
         // Find the 2D shower start position
         CartesianVector showerStartPosition(0.f, 0.f, 0.f);
         CartesianVector showerStartDirection(0.f, 0.f, 0.f);
 
         if (m_pShowerStartFinderTool->Run(pShowerPfo, peakDirection, hitType, showerSpineHitList, showerStartPosition, showerStartDirection) != STATUS_CODE_SUCCESS)
             continue;
 
         // Create the ProtoShower object
         const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
 
         ProtoShower protoShower(ShowerCore(showerStartPosition, showerStartDirection), ConnectionPathway(nuVertex2D, peakDirection),
             showerSpineHitList, CaloHitList(), CartesianPointVector(), CaloHitList());
 
         // Now determine the hits to be added to the shower from the found spine
         CaloHitList viewShowerHitList;
         LArPfoHelper::GetCaloHits(pShowerPfo, hitType, viewShowerHitList);
 
         const float showerVertexL(std::max(
             peakDirection.GetDotProduct(showerStartPosition - nuVertex2D), peakDirection.GetDotProduct(showerVertexPosition - nuVertex2D)));
 
         for (const CaloHit *const pCaloHit : showerSpineHitList)
         {
             if (std::find(viewShowerHitList.begin(), viewShowerHitList.end(), pCaloHit) != viewShowerHitList.end())
                 continue;
 
             const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
             const float showerL(peakDirection.GetDotProduct(hitPosition - nuVertex2D));
 
             if ((showerL > 0.f) && (showerL < showerVertexL))
                 protoShower.AddHitToAdd(pCaloHit);
         }
 
         protoShowerVector.push_back(protoShower);
         unavailableHitList.insert(unavailableHitList.begin(), showerSpineHitList.begin(), showerSpineHitList.end());
     }
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::FillElectronHitMap ( HitOwnershipMap & electronHitMap ) const

private

Determine the one-to-one mapping of leading MCParticle electrons and the hits which contain their energy depositions.

Parameters

electronHitMap the output [MCParticle -> CaloHitList] map

Definition at line 591 of file ElectronInitialRegionRefinementAlgorithm.cc.

References util::abs(), f, GetHitListOfType(), lar_content::LArMCParticleHelper::GetPrimaryMCParticle(), and weight.

Referenced by RefineShower().

 {
     electronHitMap.clear();
 
     for (HitType hitType : {TPC_VIEW_U, TPC_VIEW_V, TPC_VIEW_W})
     {
         const CaloHitList *pViewHitList(nullptr);
 
         if (this->GetHitListOfType(hitType, pViewHitList) != STATUS_CODE_SUCCESS)
             continue;
 
         for (const CaloHit *const pCaloHit : *pViewHitList)
         {
             MCParticleVector contributingMCParticleVector;
             const MCParticleWeightMap &weightMap(pCaloHit->GetMCParticleWeightMap());
 
             for (const auto &mapEntry : weightMap)
                 contributingMCParticleVector.push_back(mapEntry.first);
 
             std::sort(contributingMCParticleVector.begin(), contributingMCParticleVector.end(), PointerLessThan<MCParticle>());
 
             float highestWeight(0.f);
             const MCParticle *highestElectronContributor(nullptr);
 
             for (const MCParticle *const pMCParticle : contributingMCParticleVector)
             {
                 const bool isLeadingElectron((std::abs(pMCParticle->GetParticleId()) == 11) &&
                     (LArMCParticleHelper::GetPrimaryMCParticle(pMCParticle) == pMCParticle));
 
                 if (isLeadingElectron)
                 {
                     const float weight(weightMap.at(pMCParticle));
 
                     if (weight > highestWeight)
                     {
                         highestWeight = weight;
                         highestElectronContributor = pMCParticle;
                     }
                 }
             }
 
             if (highestElectronContributor)
                 electronHitMap[highestElectronContributor].push_back(pCaloHit);
         }
     }
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::FillShowerPfoVector ( pandora::PfoVector & showerPfoVector ) const

private

Obtain a sorted vector of the reconstructed shower pfos.

Parameters

showerPfoVector the sorted shower vector to be filled

Definition at line 77 of file ElectronInitialRegionRefinementAlgorithm.cc.

References m_showerPfoListName, and lar_content::LArPfoHelper::SortByNHits().

Referenced by Run().

 {
     const PfoList *pPfoList(nullptr);
 
     if (PandoraContentApi::GetList(*this, m_showerPfoListName, pPfoList) != STATUS_CODE_SUCCESS)
         return;
 
     if (!pPfoList || pPfoList->empty())
     {
         std::cout << "ElectronInitialRegionRefinementAlgorithm: unable to find shower pfo list " << m_showerPfoListName << std::endl;
         return;
     }
 
     showerPfoVector.insert(showerPfoVector.begin(), pPfoList->begin(), pPfoList->end());
 
     std::sort(showerPfoVector.begin(), showerPfoVector.end(), LArPfoHelper::SortByNHits);
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::FindContinuousPath	(	const pandora::CaloHitList &	refinedHitList,
		const pandora::CartesianVector &	nuVertex2D,
		pandora::CaloHitList &	continuousHitList
	)		const

private

Find the continuous path of hits that lies closest to a given point.

Parameters

refinedHitList	the input hit list
nuVertex2D	the given point (the 2D neutrino vertex)
continuousHitList	the input hit list to be filled

Definition at line 483 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::LArClusterHelper::GetClosestDistance(), m_maxConnectionDistance, and m_minNConnectedHits.

Referenced by RefineHitsToAdd().

 {
     continuousHitList.clear();
 
     CaloHitVector refinedHitVector(refinedHitList.begin(), refinedHitList.end());
     std::sort(refinedHitVector.begin(), refinedHitVector.end(), LArConnectionPathwayHelper::SortByDistanceToPoint(nuVertex2D));
 
     unsigned int startIndex(refinedHitVector.size());
 
     for (unsigned int i = 0; i < refinedHitVector.size(); ++i)
     {
         CaloHitList connectedHitList;
         connectedHitList.push_back(refinedHitVector[i]);
 
         bool found(true);
 
         while (found)
         {
             found = false;
 
             for (unsigned int j = (i + 1); j < refinedHitVector.size(); ++j)
             {
                 const CaloHit *const pCaloHit(refinedHitVector[j]);
 
                 if (std::find(connectedHitList.begin(), connectedHitList.end(), pCaloHit) != connectedHitList.end())
                     continue;
 
                 if (LArClusterHelper::GetClosestDistance(pCaloHit->GetPositionVector(), connectedHitList) < m_maxConnectionDistance)
                 {
                     found = true;
                     connectedHitList.push_back(pCaloHit);
                     break;
                 }
             }
         }
 
         if ((connectedHitList.size() >= m_minNConnectedHits) || (connectedHitList.size() == refinedHitVector.size()))
         {
             startIndex = i;
             break;
         }
     }
 
     for (unsigned int i = startIndex; i < refinedHitVector.size(); ++i)
         continuousHitList.push_back(refinedHitVector[i]);
 }

StatusCode lar_content::ElectronInitialRegionRefinementAlgorithm::GetHitListOfType	(	const pandora::HitType	hitType,
		const pandora::CaloHitList *&	pCaloHitList
	)		const

private

Obtain the event hit list of a given view.

Parameters

hitType	the 2D view
pCaloHitList	the output 2D hit list

Returns: whether a valid 2D hit list could be found

Definition at line 268 of file ElectronInitialRegionRefinementAlgorithm.cc.

References m_caloHitListNameU, m_caloHitListNameV, and m_caloHitListNameW.

Referenced by BuildViewPathways(), BuildViewProtoShowers(), and FillElectronHitMap().

 {
     const std::string typeHitListName(hitType == TPC_VIEW_U ? m_caloHitListNameU
             : hitType == TPC_VIEW_V                         ? m_caloHitListNameV
                                                             : m_caloHitListNameW);
 
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, typeHitListName, pCaloHitList));
 
     if (!pCaloHitList || pCaloHitList->empty())
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "ShowerStartRefinementBaseTool: unable to find calo hit list " << typeHitListName << std::endl;
 
         return STATUS_CODE_NOT_INITIALIZED;
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ElectronInitialRegionRefinementAlgorithm::GetNeutrinoVertex ( pandora::CartesianVector & nuVertex3D ) const

private

Obtain the reconstructed neutrino vertex.

Parameters

nuVertex3D the output neutrino vertex

Returns: whether a reconstructed neutrino vertex could be found

Definition at line 167 of file ElectronInitialRegionRefinementAlgorithm.cc.

References m_neutrinoVertexListName.

Referenced by RefineShower().

 {
     const VertexList *pNuVertexList(nullptr);
     const StatusCode statusCode(PandoraContentApi::GetList(*this, m_neutrinoVertexListName, pNuVertexList));
 
     if (statusCode != STATUS_CODE_SUCCESS)
         return statusCode;
 
     if (!pNuVertexList || (pNuVertexList->size() != 1))
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "ElectronInitialRegionRefinementAlgorithm: unable to find vertex list " << m_neutrinoVertexListName
                       << " if it does exist, it may have more than one nu vertex" << std::endl;
 
         return STATUS_CODE_NOT_INITIALIZED;
     }
 
     nuVertex3D = pNuVertexList->front()->GetPosition();
 
     return STATUS_CODE_SUCCESS;
 }

CartesianVector lar_content::ElectronInitialRegionRefinementAlgorithm::GetShowerVertex	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::HitType	hitType,
		const pandora::CartesianVector &	nuVertex3D
	)		const

private

Fit the shower to obtain a 2D shower vertex.

Parameters

pShowerPfo	the input shower pfo
hitType	the 2D view
nuVertex3D	the 3D neutrino vertex

Returns: the 2D shower vertex position

Definition at line 289 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::LArPfoHelper::GetClusters(), lar_content::LArGeometryHelper::GetWirePitch(), m_showerSlidingFitWindow, and lar_content::LArGeometryHelper::ProjectPosition().

Referenced by BuildViewProtoShowers().

 {
     ClusterList viewCusterList;
     LArPfoHelper::GetClusters(pShowerPfo, hitType, viewCusterList);
 
     if (viewCusterList.empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const TwoDSlidingShowerFitResult twoDShowerSlidingFit(
         viewCusterList.front(), m_showerSlidingFitWindow, LArGeometryHelper::GetWirePitch(this->GetPandora(), hitType));
     const CartesianVector &minLayerPosition(twoDShowerSlidingFit.GetShowerFitResult().GetGlobalMinLayerPosition());
     const CartesianVector &maxLayerPosition(twoDShowerSlidingFit.GetShowerFitResult().GetGlobalMaxLayerPosition());
     const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
 
     if ((nuVertex2D.GetZ() > minLayerPosition.GetZ()) && (nuVertex2D.GetZ() < maxLayerPosition.GetZ()))
         return nuVertex2D;
 
     const float minSeparation((nuVertex2D - minLayerPosition).GetMagnitudeSquared());
     const float maxSeparation((nuVertex2D - maxLayerPosition).GetMagnitudeSquared());
     CartesianVector showerVertexPosition(minSeparation < maxSeparation ? minLayerPosition : maxLayerPosition);
 
     return (minSeparation < maxSeparation ? minLayerPosition : maxLayerPosition);
 }

bool lar_content::ElectronInitialRegionRefinementAlgorithm::IsElectron	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const HitOwnershipMap &	electronHitMap
	)		const

private

To determine whether a pfo is a true leading electron via its completeness and purity.

Parameters

pShowerPfo	the input shower pfo
electronHitMap	the mapping of [MCParticle leading electrons -> their associated hits]

Definition at line 640 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::LArPfoHelper::GetCaloHits(), lar_content::LArMCParticleHelper::GetSharedHits(), m_minElectronCompleteness, and m_minElectronPurity.

Referenced by RefineShower().

 {
     MCParticleVector mcElectronVector;
 
     for (auto &entry : electronHitMap)
         mcElectronVector.push_back(entry.first);
 
     CaloHitList pfoHitList;
     LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_U, pfoHitList);
     LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_V, pfoHitList);
     LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_W, pfoHitList);
 
     for (const MCParticle *const pMCElectron : mcElectronVector)
     {
         const CaloHitList &mcElectronHitList(electronHitMap.at(pMCElectron));
         const CaloHitList sharedHitList(LArMCParticleHelper::GetSharedHits(pfoHitList, mcElectronHitList));
 
         const float completeness(static_cast<float>(sharedHitList.size()) / static_cast<float>(mcElectronHitList.size()));
         const float purity(static_cast<float>(sharedHitList.size()) / static_cast<float>(pfoHitList.size()));
 
         if (completeness < m_minElectronCompleteness)
             continue;
 
         if (purity < m_minElectronPurity)
             continue;
 
         return true;
     }
 
     return false;
 }

bool lar_content::ElectronInitialRegionRefinementAlgorithm::IsShowerConnected	(	const pandora::CartesianVector &	showerVertexPosition,
		const pandora::CartesianVector &	nuVertex2D,
		const pandora::CartesianVector &	peakDirection
	)		const

private

To determine whether the shower vertex lies on the connection pathway.

Parameters

showerVertexPosition	the input 2D shower vertex position
nuVertex2D	the 2D neutrino vertex
peakDirection	the initial direction of the connection pathway

Returns: whether the shower vertex lies on the connection pathway

Definition at line 349 of file ElectronInitialRegionRefinementAlgorithm.cc.

References f, and m_maxCoincidenceTransverseSeparation.

Referenced by RefineShowerVertex().

 {
     CartesianVector displacement(showerVertexPosition - nuVertex2D);
 
     const float longitudinalSeparation(peakDirection.GetDotProduct(displacement));
 
     if (longitudinalSeparation < (-1.f))
         return false;
 
     const float transverseSeparation((peakDirection.GetCrossProduct(displacement)).GetMagnitude());
 
     if (transverseSeparation > m_maxCoincidenceTransverseSeparation)
         return false;
 
     return true;
 }

bool lar_content::ElectronInitialRegionRefinementAlgorithm::IsSpineCoincident	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CartesianVector &	nuVertex3D,
		const pandora::HitType	hitType,
		const pandora::CartesianVector &	showerVertex,
		const pandora::CaloHitList &	showerSpineHitList
	)		const

private

To determine if the hits downstream of the shower vertex lie within the shower.

Parameters

pShowerPfo	the input shower pfo
nuVertex3D	the 3D neutrino vertex
hitType	the 2D view
showerVertex	the 2D shower vertex
showerSpineHitList	the hits of the found shower spine

Returns: whether the hits downstream of the shower vertex lie within the shower

Definition at line 369 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::LArPfoHelper::GetCaloHits(), lar_content::LArMCParticleHelper::GetSharedHits(), m_minSpinePurity, and lar_content::LArGeometryHelper::ProjectPosition().

Referenced by BuildViewProtoShowers().

 {
     const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
 
     CaloHitList viewShowerHitList;
     LArPfoHelper::GetCaloHits(pShowerPfo, hitType, viewShowerHitList);
 
     CaloHitList postShowerVertexSpineHits;
     const float showerDistanceFromNuSquared((showerVertex - nuVertex2D).GetMagnitudeSquared());
 
     for (const CaloHit *const pSpineHit : showerSpineHitList)
     {
         const CartesianVector &hitPosition(pSpineHit->GetPositionVector());
         const float separationSquared((hitPosition - nuVertex2D).GetMagnitudeSquared());
 
         if (separationSquared > showerDistanceFromNuSquared)
             postShowerVertexSpineHits.push_back(pSpineHit);
     }
 
     if (postShowerVertexSpineHits.size() == 0)
         return true;
 
     // Check whether shower spine is pure
     const CaloHitList sharedHitList(LArMCParticleHelper::GetSharedHits(postShowerVertexSpineHits, viewShowerHitList));
     const float spinePurity(static_cast<float>(sharedHitList.size()) / static_cast<float>(postShowerVertexSpineHits.size()));
 
     if (spinePurity < m_minSpinePurity)
         return false;
 
     return true;
 }

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

private

Definition at line 674 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::LArMvaHelper::AddFeatureToolToMap(), m_algorithmToolNames, m_caloHitListNameU, m_caloHitListNameV, m_caloHitListNameW, m_featureToolMap, m_maxCoincidenceTransverseSeparation, m_maxConnectionDistance, m_maxProjectionSeparation, m_maxSeparationFromHit, m_maxXSeparation, m_minElectronCompleteness, m_minElectronPurity, m_minNConnectedHits, m_minShowerHits3D, m_minSpinePurity, m_neutrinoVertexListName, m_pEventPathwayFinderTool, m_pEventPeakDirectionFinderTool, m_pProtoShowerMatchingTool, m_pShowerPeakDirectionFinderTool, m_pShowerSpineFinderTool, m_pShowerStartFinderTool, m_showerPfoListName, m_showerSlidingFitWindow, m_trainingFileName, m_trainingMode, m_unambiguousThreshold, and lar_content::LArMvaHelper::ProcessAlgorithmToolListToMap().

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ShowerPfoListName", m_showerPfoListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "NeutrinoVertexListName", m_neutrinoVertexListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListNameU", m_caloHitListNameU));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListNameV", m_caloHitListNameV));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListNameW", m_caloHitListNameW));
 
     AlgorithmTool *pAlgorithmTool1(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "ShowerPeakDirectionFinder", pAlgorithmTool1));
     m_pShowerPeakDirectionFinderTool = dynamic_cast<PeakDirectionFinderTool *>(pAlgorithmTool1);
 
     if (!m_pShowerPeakDirectionFinderTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     AlgorithmTool *pAlgorithmTool2(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "EventPeakDirectionFinder", pAlgorithmTool2));
     m_pEventPeakDirectionFinderTool = dynamic_cast<PeakDirectionFinderTool *>(pAlgorithmTool2);
 
     if (!m_pEventPeakDirectionFinderTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     AlgorithmTool *pAlgorithmTool3(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "ShowerSpineFinder", pAlgorithmTool3));
     m_pShowerSpineFinderTool = dynamic_cast<ShowerSpineFinderTool *>(pAlgorithmTool3);
 
     if (!m_pShowerSpineFinderTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     AlgorithmTool *pAlgorithmTool4(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "EventPathwayFinder", pAlgorithmTool4));
     m_pEventPathwayFinderTool = dynamic_cast<ShowerSpineFinderTool *>(pAlgorithmTool4);
 
     if (!m_pEventPathwayFinderTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     AlgorithmTool *pAlgorithmTool5(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "ShowerStartFinder", pAlgorithmTool5));
     m_pShowerStartFinderTool = dynamic_cast<ShowerStartFinderTool *>(pAlgorithmTool5);
 
     if (!m_pShowerSpineFinderTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     AlgorithmTool *pAlgorithmTool6(nullptr);
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmTool(*this, xmlHandle, "ProtoShowerMatching", pAlgorithmTool6));
     m_pProtoShowerMatchingTool = dynamic_cast<ProtoShowerMatchingTool *>(pAlgorithmTool6);
 
     if (!m_pProtoShowerMatchingTool)
         return STATUS_CODE_INVALID_PARAMETER;
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinShowerHits3D", m_minShowerHits3D));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowerSlidingFitWindow", m_showerSlidingFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxCoincidenceTransverseSeparation", m_maxCoincidenceTransverseSeparation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinSpinePurity", m_minSpinePurity));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingMode", m_trainingMode));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TrainingFileName", m_trainingFileName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UnambiguousThreshold", m_unambiguousThreshold));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxConnectionDistance", m_maxConnectionDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinNConnectedHits", m_minNConnectedHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinElectronCompleteness", m_minElectronCompleteness));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinElectronPurity", m_minElectronPurity));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxSeparationFromHit", m_maxSeparationFromHit));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxProjectionSeparation", m_maxProjectionSeparation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxXSeparation", m_maxXSeparation));
 
     AlgorithmToolVector algorithmToolVector;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "FeatureTools", algorithmToolVector));
 
     LArMvaHelper::AlgorithmToolMap algorithmToolMap;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=,
         LArMvaHelper::ProcessAlgorithmToolListToMap(*this, xmlHandle, "FeatureTools", m_algorithmToolNames, algorithmToolMap));
 
     for (auto const &[pAlgorithmToolName, pAlgorithmTool] : algorithmToolMap)
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, LArMvaHelper::AddFeatureToolToMap(pAlgorithmTool, pAlgorithmToolName, m_featureToolMap));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::RefineHitsToAdd	(	const pandora::CartesianVector &	nuVertex3D,
		const pandora::HitType	hitType,
		const ConnectionPathwayVector &	viewPathways,
		ProtoShower &	protoShower
	)		const

private

Determine the continuous and unambiguous hits to add to an electron-like shower pfo.

Parameters

nuVertex3D	the 3D neutrino vertex
hitType	the 2D view
viewPathways	the vector of other event connection pathways
protoShower	the ProtoShower object associated with the input shower

Definition at line 435 of file ElectronInitialRegionRefinementAlgorithm.cc.

References lar_content::ProtoShower::AddAmbiguousDirection(), lar_content::ProtoShower::AddAmbiguousHit(), FindContinuousPath(), lar_content::ProtoShower::GetAmbiguousDirectionVector(), lar_content::ProtoShower::GetConnectionPathway(), lar_content::ProtoShower::GetHitsToAddList(), lar_content::ConnectionPathway::GetStartDirection(), m_unambiguousThreshold, lar_content::LArGeometryHelper::ProjectPosition(), and lar_content::ProtoShower::SetHitsToAddList().

Referenced by RefineShower().

 {
     const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
     const CartesianVector &peakDirection(protoShower.GetConnectionPathway().GetStartDirection());
 
     CaloHitList refinedHitList;
 
     for (const CaloHit *const pHitToAdd : protoShower.GetHitsToAddList())
     {
         bool found(false);
 
         const CartesianVector &hitPosition(pHitToAdd->GetPositionVector());
         const CartesianVector displacement(hitPosition - nuVertex2D);
         const float thisT((peakDirection.GetCrossProduct(displacement)).GetMagnitudeSquared());
 
         for (const ConnectionPathway &connectionPathway : viewPathways)
         {
             const CartesianVector &eventPeakDirection(connectionPathway.GetStartDirection());
 
             if (peakDirection.GetOpeningAngle(eventPeakDirection) > (M_PI / 2))
                 continue;
 
             const float otherT((eventPeakDirection.GetCrossProduct(displacement)).GetMagnitudeSquared());
 
             if ((otherT < thisT) || (otherT < m_unambiguousThreshold))
             {
                 found = true;
 
                 if (std::find(protoShower.GetAmbiguousDirectionVector().begin(), protoShower.GetAmbiguousDirectionVector().end(),
                         eventPeakDirection) == protoShower.GetAmbiguousDirectionVector().end())
                 {
                     protoShower.AddAmbiguousDirection(connectionPathway.GetStartDirection());
                 }
             }
         }
 
         found ? protoShower.AddAmbiguousHit(pHitToAdd) : refinedHitList.push_back(pHitToAdd);
     }
 
     CaloHitList continuousHitList;
     this->FindContinuousPath(refinedHitList, nuVertex2D, continuousHitList);
 
     protoShower.SetHitsToAddList(continuousHitList);
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::RefineShower ( const pandora::ParticleFlowObject *const pShowerPfo ) const

private

Find and evaluate shower connection pathway, removing if necessary.

Parameters

pShowerPfo the input shower pfo

Definition at line 97 of file ElectronInitialRegionRefinementAlgorithm.cc.

References BuildViewPathways(), BuildViewProtoShowers(), lar_content::LArMvaHelper::CalculateFeatures(), f, FillElectronHitMap(), lar_content::LArConnectionPathwayHelper::FindShowerStarts3D(), GetNeutrinoVertex(), IsElectron(), m_algorithmToolNames, m_featureToolMap, m_maxProjectionSeparation, m_maxSeparationFromHit, m_maxXSeparation, m_pProtoShowerMatchingTool, m_trainingFileName, m_trainingMode, lar_content::LArMvaHelper::ProduceTrainingExample(), RefineHitsToAdd(), lar_content::ProtoShowerMatchingTool::Run(), and SetMetadata().

Referenced by Run().

 {
     CartesianVector nuVertex3D(0.f, 0.f, 0.f);
 
     if (this->GetNeutrinoVertex(nuVertex3D) != STATUS_CODE_SUCCESS)
         return;
 
     // Create the 2D connetion pathways
     ProtoShowerVector protoShowerVectorU, protoShowerVectorV, protoShowerVectorW;
 
     this->BuildViewProtoShowers(pShowerPfo, nuVertex3D, TPC_VIEW_U, protoShowerVectorU);
     this->BuildViewProtoShowers(pShowerPfo, nuVertex3D, TPC_VIEW_V, protoShowerVectorV);
     this->BuildViewProtoShowers(pShowerPfo, nuVertex3D, TPC_VIEW_W, protoShowerVectorW);
 
     // 2D->3D connection pathway matching
     ProtoShowerMatchVector protoShowerMatchVector;
     m_pProtoShowerMatchingTool->Run(protoShowerVectorU, protoShowerVectorV, protoShowerVectorW, protoShowerMatchVector);
 
     if (protoShowerMatchVector.empty())
         return;
 
     for (ProtoShowerMatch &protoShowerMatch : protoShowerMatchVector)
     {
         // Remove ambiguous hits from hits to add list
         ConnectionPathwayVector viewPathwaysU, viewPathwaysV, viewPathwaysW;
 
         this->BuildViewPathways(pShowerPfo, protoShowerMatch.GetProtoShowerU().GetSpineHitList(), nuVertex3D, TPC_VIEW_U, viewPathwaysU);
         this->BuildViewPathways(pShowerPfo, protoShowerMatch.GetProtoShowerV().GetSpineHitList(), nuVertex3D, TPC_VIEW_V, viewPathwaysV);
         this->BuildViewPathways(pShowerPfo, protoShowerMatch.GetProtoShowerW().GetSpineHitList(), nuVertex3D, TPC_VIEW_W, viewPathwaysW);
 
         this->RefineHitsToAdd(nuVertex3D, TPC_VIEW_U, viewPathwaysU, protoShowerMatch.GetProtoShowerToModify(TPC_VIEW_U));
         this->RefineHitsToAdd(nuVertex3D, TPC_VIEW_V, viewPathwaysV, protoShowerMatch.GetProtoShowerToModify(TPC_VIEW_V));
         this->RefineHitsToAdd(nuVertex3D, TPC_VIEW_W, viewPathwaysW, protoShowerMatch.GetProtoShowerToModify(TPC_VIEW_W));
 
         // Determine the 3D shower vertex
         CartesianPointVector showerStarts3D;
         if (!LArConnectionPathwayHelper::FindShowerStarts3D(this, pShowerPfo, protoShowerMatch, nuVertex3D, m_maxSeparationFromHit,
                 m_maxProjectionSeparation, m_maxXSeparation, showerStarts3D))
         {
             continue;
         }
 
         // Fill BDT information
         StringVector featureOrder;
         const LArMvaHelper::MvaFeatureMap featureMap(LArMvaHelper::CalculateFeatures(
             m_algorithmToolNames, m_featureToolMap, featureOrder, this, pShowerPfo, nuVertex3D, protoShowerMatch, showerStarts3D));
 
         this->SetMetadata(pShowerPfo, featureMap);
 
         if (m_trainingMode)
         {
             // To truth match electrons
             HitOwnershipMap electronHitMap;
             this->FillElectronHitMap(electronHitMap);
 
             if (this->IsElectron(pShowerPfo, electronHitMap))
             {
                 LArMvaHelper::ProduceTrainingExample(m_trainingFileName, true, featureOrder, featureMap);
                 break;
             }
 
             LArMvaHelper::ProduceTrainingExample(m_trainingFileName, false, featureOrder, featureMap);
 
             break;
         }
     }
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::RefineShowerVertex	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::HitType	hitType,
		const pandora::CartesianVector &	nuVertex3D,
		const pandora::CartesianVector &	peakDirection,
		pandora::CartesianVector &	showerVertexPosition
	)		const

private

Move the shower vertex closer to the connection pathway.

Parameters

pShowerPfo	the input shower pfo
hitType	the 2D view
nuVertex3D	the 3D neutrino vertex
peakDirection	the initial direction of the connection pathway
showerVertexPosition	the (perhaps) refined 2D shower vertex position

Definition at line 316 of file ElectronInitialRegionRefinementAlgorithm.cc.

References f, lar_content::LArPfoHelper::GetCaloHits(), IsShowerConnected(), m_maxCoincidenceTransverseSeparation, and lar_content::LArGeometryHelper::ProjectPosition().

Referenced by BuildViewProtoShowers().

 {
     const CartesianVector nuVertex2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), nuVertex3D, hitType));
 
     if (!this->IsShowerConnected(showerVertexPosition, nuVertex2D, peakDirection))
     {
         CaloHitList viewShowerHitList;
         LArPfoHelper::GetCaloHits(pShowerPfo, hitType, viewShowerHitList);
 
         float minL(std::numeric_limits<float>::max());
 
         for (const CaloHit *const pCaloHit : viewShowerHitList)
         {
             const CartesianVector displacement(pCaloHit->GetPositionVector() - nuVertex2D);
             const float longitudinalSeparation(peakDirection.GetDotProduct(displacement));
 
             if ((longitudinalSeparation < (-1.f)) || (longitudinalSeparation > minL))
                 continue;
 
             const float transverseSeparation((peakDirection.GetCrossProduct(displacement)).GetMagnitude());
 
             if (transverseSeparation < m_maxCoincidenceTransverseSeparation)
             {
                 showerVertexPosition = pCaloHit->GetPositionVector();
                 minL = longitudinalSeparation;
             }
         }
     }
 }

StatusCode lar_content::ElectronInitialRegionRefinementAlgorithm::Run ( )

private

Definition at line 52 of file ElectronInitialRegionRefinementAlgorithm.cc.

References FillShowerPfoVector(), lar_content::LArPfoHelper::GetCaloHits(), m_minShowerHits3D, and RefineShower().

 {
     PfoVector showerPfoVector;
     this->FillShowerPfoVector(showerPfoVector);
 
     if (showerPfoVector.empty())
         return STATUS_CODE_SUCCESS;
 
     for (const ParticleFlowObject *const pShowerPfo : showerPfoVector)
     {
         // Only consider significant showers
         CaloHitList caloHits3D;
         LArPfoHelper::GetCaloHits(pShowerPfo, TPC_3D, caloHits3D);
 
         if (caloHits3D.size() < m_minShowerHits3D)
             continue;
 
         this->RefineShower(pShowerPfo);
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ElectronInitialRegionRefinementAlgorithm::SetMetadata	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const LArMvaHelper::MvaFeatureMap &	featureMap
	)		const

private

Add the shower characterisation information to the pfo metadata.

Parameters

pShowerPfo	the input shower pfo
featureMap	the map of [characterisation variable -> value]

Definition at line 533 of file ElectronInitialRegionRefinementAlgorithm.cc.

Referenced by RefineShower().

 {
     object_creation::ParticleFlowObject::Metadata metadata;
 
     metadata.m_propertiesToAdd["FoundConnectionPathway"] = true;
 
     if (featureMap.find("LArInitialRegionFeatureTool_initialGapSize") != featureMap.end())
         metadata.m_propertiesToAdd["MaxInitialGapSize"] = featureMap.at("LArInitialRegionFeatureTool_initialGapSize").Get();
 
     if (featureMap.find("LArInitialRegionFeatureTool_largestGapSize") != featureMap.end())
         metadata.m_propertiesToAdd["MinLargestProjectedGapSize"] = featureMap.at("LArInitialRegionFeatureTool_largestGapSize").Get();
 
     if (featureMap.find("LArConnectionRegionFeatureTool_pathwayLength") != featureMap.end())
         metadata.m_propertiesToAdd["PathwayLengthMin"] = featureMap.at("LArConnectionRegionFeatureTool_pathwayLength").Get();
 
     if (featureMap.find("LArConnectionRegionFeatureTool_pathwayScatteringAngle2D") != featureMap.end())
         metadata.m_propertiesToAdd["MaxShowerStartPathwayScatteringAngle2D"] =
             featureMap.at("LArConnectionRegionFeatureTool_pathwayScatteringAngle2D").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_nShowerHits") != featureMap.end())
         metadata.m_propertiesToAdd["MaxNPostShowerStartHits"] = featureMap.at("LArShowerRegionFeatureTool_nShowerHits").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_foundHitRatio") != featureMap.end())
         metadata.m_propertiesToAdd["MaxFoundHitRatio"] = featureMap.at("LArShowerRegionFeatureTool_foundHitRatio").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_scatterAngle") != featureMap.end())
         metadata.m_propertiesToAdd["MaxPostShowerStartScatterAngle"] = featureMap.at("LArShowerRegionFeatureTool_scatterAngle").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_openingAngle") != featureMap.end())
         metadata.m_propertiesToAdd["MaxPostShowerStartOpeningAngle"] = featureMap.at("LArShowerRegionFeatureTool_openingAngle").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_nuVertexEnergyAsymmetry") != featureMap.end())
         metadata.m_propertiesToAdd["MaxPostShowerStartNuVertexEnergyAsymmetry"] =
             featureMap.at("LArShowerRegionFeatureTool_nuVertexEnergyAsymmetry").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_nuVertexEnergyWeightedMeanRadialDistance") != featureMap.end())
         metadata.m_propertiesToAdd["MaxPostShowerStartNuVertexEnergyWeightedMeanRadialDistance"] =
             featureMap.at("LArShowerRegionFeatureTool_nuVertexEnergyWeightedMeanRadialDistance").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_showerStartEnergyAsymmetry") != featureMap.end())
         metadata.m_propertiesToAdd["MaxPostShowerStartShowerStartEnergyAsymmetry"] =
             featureMap.at("LArShowerRegionFeatureTool_showerStartEnergyAsymmetry").Get();
 
     if (featureMap.find("LArShowerRegionFeatureTool_showerStartMoliereRadius") != featureMap.end())
         metadata.m_propertiesToAdd["MinPostShowerStartShowerStartMoliereRadius"] =
             featureMap.at("LArShowerRegionFeatureTool_showerStartMoliereRadius").Get();
 
     if (featureMap.find("LArAmbiguousRegionFeatureTool_nAmbiguousViews") != featureMap.end())
         metadata.m_propertiesToAdd["NViewsWithAmbiguousHits"] = featureMap.at("LArAmbiguousRegionFeatureTool_nAmbiguousViews").Get();
 
     if (featureMap.find("LArAmbiguousRegionFeatureTool_maxUnaccountedEnergy") != featureMap.end())
         metadata.m_propertiesToAdd["AmbiguousHitMaxUnaccountedEnergy"] = featureMap.at("LArAmbiguousRegionFeatureTool_maxUnaccountedEnergy").Get();
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pShowerPfo, metadata));
 }

Member Data Documentation

pandora::StringVector lar_content::ElectronInitialRegionRefinementAlgorithm::m_algorithmToolNames

private

The algorithm tool names.

Definition at line 216 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

std::string lar_content::ElectronInitialRegionRefinementAlgorithm::m_caloHitListNameU

private

The U calo hit list name.

Definition at line 198 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by GetHitListOfType(), and ReadSettings().

std::string lar_content::ElectronInitialRegionRefinementAlgorithm::m_caloHitListNameV

private

The V calo hit list name.

Definition at line 199 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by GetHitListOfType(), and ReadSettings().

std::string lar_content::ElectronInitialRegionRefinementAlgorithm::m_caloHitListNameW

private

The W calo hit list name.

Definition at line 200 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by GetHitListOfType(), and ReadSettings().

ConnectionPathwayFeatureTool::FeatureToolMap lar_content::ElectronInitialRegionRefinementAlgorithm::m_featureToolMap

private

The feature tool map.

Definition at line 215 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_maxCoincidenceTransverseSeparation

private

The max. transverse distance from the pathway direction of a coincident shower vertex.

Definition at line 203 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by IsShowerConnected(), ReadSettings(), and RefineShowerVertex().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_maxConnectionDistance

private

The max. distance between connected hits.

Definition at line 208 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by FindContinuousPath(), and ReadSettings().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_maxProjectionSeparation

private

The max. separation between the projected 3D shower start and the shower start of that view.

Definition at line 213 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_maxSeparationFromHit

private

The max. separation between the projected 3D shower start and the closest 2D shower hit.

Definition at line 212 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_maxXSeparation

private

The max. drift-coordinate separation between a 3D shower start and a matched 2D shower hit.

Definition at line 214 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_minElectronCompleteness

private

The min. completeness of an electron-like pfo.

Definition at line 210 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by IsElectron(), and ReadSettings().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_minElectronPurity

private

The min. purity of an electron-like pfo.

Definition at line 211 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by IsElectron(), and ReadSettings().

unsigned int lar_content::ElectronInitialRegionRefinementAlgorithm::m_minNConnectedHits

private

The number of connected hits needed for a conntected pathway.

Definition at line 209 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by FindContinuousPath(), and ReadSettings().

unsigned int lar_content::ElectronInitialRegionRefinementAlgorithm::m_minShowerHits3D

private

The min. number of hits of a significant shower.

Definition at line 201 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and Run().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_minSpinePurity

private

The min. purity of a coincident shower spine downstream of the shower vertex.

Definition at line 204 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by IsSpineCoincident(), and ReadSettings().

std::string lar_content::ElectronInitialRegionRefinementAlgorithm::m_neutrinoVertexListName

private

The neutrino vertex list name.

Definition at line 197 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by GetNeutrinoVertex(), and ReadSettings().

ShowerSpineFinderTool* lar_content::ElectronInitialRegionRefinementAlgorithm::m_pEventPathwayFinderTool

private

The shower spine finder tool for all other event particles.

Definition at line 193 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by BuildViewPathways(), and ReadSettings().

PeakDirectionFinderTool* lar_content::ElectronInitialRegionRefinementAlgorithm::m_pEventPeakDirectionFinderTool

private

The other (not incl. shower) initial pathway direction finder tool.

Definition at line 191 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by BuildViewPathways(), and ReadSettings().

ProtoShowerMatchingTool* lar_content::ElectronInitialRegionRefinementAlgorithm::m_pProtoShowerMatchingTool

private

The 2D -> 3D ProtoShower matching tool.

Definition at line 195 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

PeakDirectionFinderTool* lar_content::ElectronInitialRegionRefinementAlgorithm::m_pShowerPeakDirectionFinderTool

private

The shower initial pathway direction finder tool.

Definition at line 190 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by BuildViewProtoShowers(), and ReadSettings().

ShowerSpineFinderTool* lar_content::ElectronInitialRegionRefinementAlgorithm::m_pShowerSpineFinderTool

private

The shower spine finder tool for the shower.

Definition at line 192 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by BuildViewProtoShowers(), and ReadSettings().

ShowerStartFinderTool* lar_content::ElectronInitialRegionRefinementAlgorithm::m_pShowerStartFinderTool

private

The shower start finder tool.

Definition at line 194 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by BuildViewProtoShowers(), and ReadSettings().

std::string lar_content::ElectronInitialRegionRefinementAlgorithm::m_showerPfoListName

private

The shower pfo list name.

Definition at line 196 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by FillShowerPfoVector(), and ReadSettings().

unsigned int lar_content::ElectronInitialRegionRefinementAlgorithm::m_showerSlidingFitWindow

private

The sliding fit window for shower fits.

Definition at line 202 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by GetShowerVertex(), and ReadSettings().

std::string lar_content::ElectronInitialRegionRefinementAlgorithm::m_trainingFileName

private

The name of the output training file name.

Definition at line 206 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

bool lar_content::ElectronInitialRegionRefinementAlgorithm::m_trainingMode

private

Whether to run the algorithm to train the BDT.

Definition at line 205 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineShower().

float lar_content::ElectronInitialRegionRefinementAlgorithm::m_unambiguousThreshold

private

The min. transverse distance of an unambiguous shower hit from another pathway direction.

Definition at line 207 of file ElectronInitialRegionRefinementAlgorithm.h.

Referenced by ReadSettings(), and RefineHitsToAdd().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArShowerRefinement/ElectronInitialRegionRefinementAlgorithm.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArShowerRefinement/ElectronInitialRegionRefinementAlgorithm.cc

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation