#include "ShowerStartFinderTool.h"

Inheritance diagram for lar_content::ShowerStartFinderTool:

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

pandora::StatusCode	Run (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::CartesianVector &peakDirection, const pandora::HitType hitType, const pandora::CaloHitList &showerSpineHitList, pandora::CartesianVector &showerStartPosition, pandora::CartesianVector &showerStartDirection)

template<typename T >
int	FindShowerStartLongitudinalCoordinate (const ParticleFlowObject *const pShowerPfo, const HitType hitType, const TwoDSlidingFitResult &spineTwoDSlidingFit, const EnergySpectrumMap &energySpectrumMap, const CaloHitList &showerSpineHitList, const bool isEndDownstream, const T startIter, const T endIter) const

Private Types
typedef std::map< const pandora::CaloHit *, float >	LongitudinalPositionMap

typedef std::map< int, float >	EnergySpectrumMap

typedef std::map< int, pandora::CaloHitList >	LayerToHitMap

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

void	ObtainLongitudinalDecomposition (const TwoDSlidingFitResult &spineTwoDSlidingFit, const pandora::CaloHitList &showerSpineHitList, LongitudinalPositionMap &longitudinalPositionMap) const
	Create the [shower spine hit -> shower spine fit longitudinal projection] map. More...

void	GetEnergyDistribution (const pandora::CaloHitList &showerSpineHitList, const LongitudinalPositionMap &longitudinalPositionMap, EnergySpectrumMap &energySpectrumMap) const
	Create the longituidnal energy distribution. More...

void	FindShowerStartAndDirection (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::HitType hitType, const TwoDSlidingFitResult &spineTwoDSlidingFit, const EnergySpectrumMap &energySpectrumMap, const pandora::CaloHitList &showerSpineHitList, const bool isEndDownstream, pandora::CartesianVector &showerStartPosition, pandora::CartesianVector &showerStartDirection) const
	Find the position at which the shower cascade looks to originate, and its initial direction. More...

template<typename T >
int	FindShowerStartLongitudinalCoordinate (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::HitType hitType, const TwoDSlidingFitResult &spineTwoDSlidingFit, const EnergySpectrumMap &energySpectrumMap, const pandora::CaloHitList &showerSpineHitList, const bool isEndDownstream, const T startIter, const T endIter) const
	Find the longitudinal bin which corresponds to the start position of the shower cascade. More...

void	CharacteriseInitialEnergy (const EnergySpectrumMap &energySpectrumMap, const bool isEndDownstream, float &meanEnergy, float &energySigma) const
	Find the mean and standard deviation of the energy depositions in the initial region. More...

bool	IsShowerTopology (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::HitType hitType, const TwoDSlidingFitResult &spineTwoDSlidingFit, const float longitudinalDistance, const pandora::CaloHitList &showerSpineHitList, const bool isEndDownstream) const
	Whether a sensible shower cascade looks to originate at a given position. More...

void	ConvertLongitudinalProjectionToGlobal (const TwoDSlidingFitResult &spineTwoDSlidingFit, const float longitudinalDistance, pandora::CartesianVector &globalPosition, pandora::CartesianVector &globalDirection) const
	Determine the (X,Y,Z) position and direction at a given longitudinal distance along the spine. More...

pandora::StatusCode	BuildShowerRegion (const pandora::ParticleFlowObject *const pShowerPfo, const pandora::HitType hitType, const pandora::CaloHitList &showerSpineHitList, const pandora::CartesianVector &showerStartPosition, const pandora::CartesianVector &showerStartDirection, const bool isEndDownstream, pandora::CartesianPointVector &showerRegionPositionVector) const
	Build the downstream 'shower region' at a given longitudinal distance along the spine. More...

pandora::StatusCode	CharacteriseShowerTopology (const pandora::CartesianPointVector &showerRegionPositionVector, const pandora::CartesianVector &showerStartPosition, const pandora::HitType hitType, const bool isEndDownstream, const pandora::CartesianVector &showerStartDirection, pandora::CartesianVector &positiveEdgeStart, pandora::CartesianVector &positiveEdgeEnd, pandora::CartesianVector &negativeEdgeStart, pandora::CartesianVector &negativeEdgeEnd, bool &isBetween) const
	Parameterise the topological structure of the shower region. More...

bool	IsClockwiseRotation (const pandora::CartesianVector &showerStartDirection, const pandora::CartesianVector &displacementVector) const
	Determine whether a point lies on the RHS or LHS (wrt +ve Z) of the shower core. More...

pandora::StatusCode	GetBoundaryExtremalPoints (const TwoDSlidingShowerFitResult &showerTwoDSlidingFit, const LayerFitResultMap &layerFitResultMap, const pandora::CartesianVector &showerStartPosition, const int showerStartLayer, const int showerEndLayer, pandora::CartesianVector &boundaryEdgeStart, pandora::CartesianVector &boundaryEdgeEnd) const
	Determine the start and end positions of a shower boundary. More...

Private Attributes
unsigned int	m_spineSlidingFitWindow
	The sliding window used to fit the shower spine. More...

float	m_longitudinalCoordinateBinSize
	The longitudinal coordinate bin size. More...

unsigned int	m_nInitialEnergyBins
	The number of longitudinal bins that define the initial region. More...

float	m_minSigmaDeviation
	The min. average energy deviation of a candidate shower start. More...

float	m_maxEdgeGap
	The max. allowed layer gap in a shower boundary. More...

float	m_longitudinalShowerFraction
	The shower region fraction considered. More...

float	m_minShowerOpeningAngle
	The min. opening angle of a sensible shower. More...

float	m_molliereRadius
	The max. distance from the shower core of a collected shower region hit. More...

unsigned int	m_showerSlidingFitWindow
	The sliding window used to fit the shower region. More...

int	m_maxLayerSeparation
	The max. allowed separation between the shower start and boundary start layers. More...

Detailed Description

Definition at line 20 of file ShowerStartFinderTool.h.

Member Typedef Documentation

typedef std::map<int, float> lar_content::ShowerStartFinderTool::EnergySpectrumMap

private

Definition at line 34 of file ShowerStartFinderTool.h.

typedef std::map<int, pandora::CaloHitList> lar_content::ShowerStartFinderTool::LayerToHitMap

private

Definition at line 35 of file ShowerStartFinderTool.h.

typedef std::map<const pandora::CaloHit *, float> lar_content::ShowerStartFinderTool::LongitudinalPositionMap

private

Definition at line 33 of file ShowerStartFinderTool.h.

Constructor & Destructor Documentation

lar_content::ShowerStartFinderTool::ShowerStartFinderTool ( )

Default constructor.

Definition at line 26 of file ShowerStartFinderTool.cc.

                                              :
     m_spineSlidingFitWindow(10),
     m_longitudinalCoordinateBinSize(1.f),
     m_nInitialEnergyBins(5),
     m_minSigmaDeviation(1.f),
     m_maxEdgeGap(3.f),
     m_longitudinalShowerFraction(0.85f),
     m_minShowerOpeningAngle(2.f),
     m_molliereRadius(4.5f),
     m_showerSlidingFitWindow(1000),
     m_maxLayerSeparation(5)
 {
 }

Member Function Documentation

StatusCode lar_content::ShowerStartFinderTool::BuildShowerRegion	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::HitType	hitType,
		const pandora::CaloHitList &	showerSpineHitList,
		const pandora::CartesianVector &	showerStartPosition,
		const pandora::CartesianVector &	showerStartDirection,
		const bool	isEndDownstream,
		pandora::CartesianPointVector &	showerRegionPositionVector
	)		const

private

Build the downstream 'shower region' at a given longitudinal distance along the spine.

Parameters

pShowerPfo	the shower pfo
hitType	the 2D view
showerSpineHitList	the shower spine hit list
showerStartPosition	the candidate shower start position
showerStartDirection	the candidate shower start direction
isEndDownstream	whether the shower direction is downstream (in Z) of the neutrino vertex
showerRegionPositionVector	the ouput vector of shower region hit positions

Returns: whether the 'shower region finder' mechanics could proceed

Definition at line 354 of file ShowerStartFinderTool.cc.

References f, lar_content::LArPfoHelper::GetCaloHits(), lar_content::TwoDSlidingFitResult::GetGlobalPosition(), lar_content::TwoDSlidingFitResult::GetLayer(), lar_content::TwoDSlidingFitResult::GetLayerFitResultMap(), lar_content::TwoDSlidingFitResult::GetLocalPosition(), lar_content::TwoDSlidingShowerFitResult::GetNegativeEdgeFitResult(), lar_content::TwoDSlidingShowerFitResult::GetPositiveEdgeFitResult(), lar_content::TwoDSlidingShowerFitResult::GetShowerFitResult(), lar_content::LArGeometryHelper::GetWirePitch(), m_longitudinalShowerFraction, m_maxEdgeGap, m_molliereRadius, and m_showerSlidingFitWindow.

Referenced by IsShowerTopology().

 {
     CaloHitList viewShowerHitList;
     LArPfoHelper::GetCaloHits(pShowerPfo, hitType, viewShowerHitList);
 
     // Find shower region hits
     CaloHitList showerRegionHitList;
 
     for (const CaloHit *const pCaloHit : viewShowerHitList)
     {
         if (std::find(showerSpineHitList.begin(), showerSpineHitList.end(), pCaloHit) != showerSpineHitList.end())
             continue;
 
         const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
         float l(showerStartDirection.GetDotProduct(hitPosition - showerStartPosition));
 
         l *= isEndDownstream ? 1.f : -1.f;
 
         if (l < 0.f)
             continue;
 
         if (showerStartDirection.GetCrossProduct(hitPosition - showerStartPosition).GetMagnitude() > m_molliereRadius)
             continue;
 
         showerRegionPositionVector.push_back(pCaloHit->GetPositionVector());
         showerRegionHitList.push_back(pCaloHit);
     }
 
     // Searching for a continuous shower, so truncate at first gap
     CartesianPointVector coordinateListP, coordinateListN;
     try
     {
         // Perform shower sliding fit
         const TwoDSlidingShowerFitResult twoDShowerSlidingFit(
             &showerRegionPositionVector, m_showerSlidingFitWindow, LArGeometryHelper::GetWirePitch(this->GetPandora(), hitType));
         const LayerFitResultMap &layerFitResultMapS(twoDShowerSlidingFit.GetShowerFitResult().GetLayerFitResultMap());
         const LayerFitResultMap &layerFitResultMapP(twoDShowerSlidingFit.GetPositiveEdgeFitResult().GetLayerFitResultMap());
         const LayerFitResultMap &layerFitResultMapN(twoDShowerSlidingFit.GetNegativeEdgeFitResult().GetLayerFitResultMap());
 
         float showerStartL(0.f), showerStartT(0.f);
         twoDShowerSlidingFit.GetShowerFitResult().GetLocalPosition(showerStartPosition, showerStartL, showerStartT);
 
         const int startLayer(twoDShowerSlidingFit.GetShowerFitResult().GetLayer(showerStartL));
 
         // Check for gaps in the shower
         for (LayerFitResultMap::const_iterator iterS = layerFitResultMapS.begin(); iterS != layerFitResultMapS.end(); ++iterS)
         {
             const int layer(iterS->first);
 
             if (isEndDownstream && (layer < startLayer))
                 continue;
 
             if (!isEndDownstream && (layer > startLayer))
                 continue;
 
             LayerFitResultMap::const_iterator iterP = layerFitResultMapP.find(layer);
             LayerFitResultMap::const_iterator iterN = layerFitResultMapN.find(layer);
 
             if (layerFitResultMapP.end() != iterP)
             {
                 CartesianVector positiveEdgePosition(0.f, 0.f, 0.f);
                 twoDShowerSlidingFit.GetShowerFitResult().GetGlobalPosition(iterP->second.GetL(), iterP->second.GetFitT(), positiveEdgePosition);
                 coordinateListP.push_back(positiveEdgePosition);
             }
 
             if (layerFitResultMapN.end() != iterN)
             {
                 CartesianVector negativeEdgePosition(0.f, 0.f, 0.f);
                 twoDShowerSlidingFit.GetShowerFitResult().GetGlobalPosition(iterN->second.GetL(), iterN->second.GetFitT(), negativeEdgePosition);
                 coordinateListN.push_back(negativeEdgePosition);
             }
         }
 
         if ((coordinateListP.size() == 0) || (coordinateListN.size() == 0))
             return STATUS_CODE_FAILURE;
 
         std::sort(coordinateListP.begin(), coordinateListP.end(), LArConnectionPathwayHelper::SortByDistanceToPoint(showerStartPosition));
         std::sort(coordinateListN.begin(), coordinateListN.end(), LArConnectionPathwayHelper::SortByDistanceToPoint(showerStartPosition));
 
         float pMaximumL(std::numeric_limits<float>::max());
         CartesianVector previousCoordinateP(coordinateListP.front());
 
         for (auto iterP = std::next(coordinateListP.begin()); iterP != coordinateListP.end(); ++iterP)
         {
             const CartesianVector &coordinateP(*iterP);
             const float separationSquared((coordinateP - previousCoordinateP).GetMagnitudeSquared());
 
             if (separationSquared > (m_maxEdgeGap * m_maxEdgeGap))
                 break;
 
             float thisT(0.f);
             twoDShowerSlidingFit.GetShowerFitResult().GetLocalPosition(coordinateP, pMaximumL, thisT);
 
             previousCoordinateP = coordinateP;
         }
 
         float nMaximumL(std::numeric_limits<float>::max());
         CartesianVector previousCoordinateN(coordinateListN.front());
 
         for (auto iterN = std::next(coordinateListN.begin()); iterN != coordinateListN.end(); ++iterN)
         {
             const CartesianVector &coordinateN(*iterN);
             const float separationSquared((coordinateN - previousCoordinateN).GetMagnitudeSquared());
 
             if (separationSquared > (m_maxEdgeGap * m_maxEdgeGap))
                 break;
 
             float thisT(0.f);
             twoDShowerSlidingFit.GetShowerFitResult().GetLocalPosition(coordinateN, nMaximumL, thisT);
 
             previousCoordinateN = coordinateN;
         }
 
         // Now truncate the halo hit position vector
         showerRegionPositionVector.clear();
 
         for (const CaloHit *const pCaloHit : showerRegionHitList)
         {
             float thisL(0.f), thisT(0.f);
             const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
 
             twoDShowerSlidingFit.GetShowerFitResult().GetLocalPosition(hitPosition, thisL, thisT);
 
             // because the end of showers can get really narrow and thus fail the opening angle check
             if (isEndDownstream && (thisL > (m_longitudinalShowerFraction * std::max(pMaximumL, nMaximumL))))
                 continue;
 
             if (!isEndDownstream && (thisL < (m_longitudinalShowerFraction * std::min(pMaximumL, nMaximumL))))
                 continue;
 
             showerRegionPositionVector.push_back(pCaloHit->GetPositionVector());
         }
     }
     catch (const StatusCodeException &)
     {
         return STATUS_CODE_FAILURE;
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ShowerStartFinderTool::CharacteriseInitialEnergy	(	const EnergySpectrumMap &	energySpectrumMap,
		const bool	isEndDownstream,
		float &	meanEnergy,
		float &	energySigma
	)		const

private

Find the mean and standard deviation of the energy depositions in the initial region.

Parameters

energySpectrumMap	the [longitudial projection bin -> contained energy] map
isEndDownstream	whether the shower direction is downstream (in Z) of the neutrino vertex
meanEnergy	the output mean energy
energySigma	the output standard deviation

Definition at line 250 of file ShowerStartFinderTool.cc.

References m_nInitialEnergyBins.

Referenced by FindShowerStartLongitudinalCoordinate().

 {
     auto energySpectrumIter(isEndDownstream ? energySpectrumMap.begin() : std::prev(energySpectrumMap.end()));
 
     for (unsigned int i = 0; i < m_nInitialEnergyBins; ++i)
     {
         meanEnergy += energySpectrumIter->second;
         isEndDownstream ? ++energySpectrumIter : --energySpectrumIter;
     }
 
     meanEnergy /= static_cast<float>(m_nInitialEnergyBins);
 
     energySpectrumIter = isEndDownstream ? energySpectrumMap.begin() : std::prev(energySpectrumMap.end());
 
     for (unsigned int i = 0; i < m_nInitialEnergyBins; ++i)
     {
         energySigma += std::pow(energySpectrumIter->second - meanEnergy, 2);
         isEndDownstream ? ++energySpectrumIter : --energySpectrumIter;
     }
 
     energySigma = std::sqrt(energySigma / m_nInitialEnergyBins);
 }

StatusCode lar_content::ShowerStartFinderTool::CharacteriseShowerTopology	(	const pandora::CartesianPointVector &	showerRegionPositionVector,
		const pandora::CartesianVector &	showerStartPosition,
		const pandora::HitType	hitType,
		const bool	isEndDownstream,
		const pandora::CartesianVector &	showerStartDirection,
		pandora::CartesianVector &	positiveEdgeStart,
		pandora::CartesianVector &	positiveEdgeEnd,
		pandora::CartesianVector &	negativeEdgeStart,
		pandora::CartesianVector &	negativeEdgeEnd,
		bool &	isBetween
	)		const

private

Parameterise the topological structure of the shower region.

Parameters

showerRegionPositionVector	the vector of shower region hit positions
showerStartPosition	the shower start position
hitType	the 2D view
isEndDownstream	whether the shower direction is downstream (in Z) of the neutrino vertex
showerStartDirection	the shower start direction
positiveEdgeStart	the start position of one shower boundary
positiveEdgeEnd	the end position of one shower boundary
negativeEdgeStart	the start position of the other shower boundary
negativeEdgeEnd	the end position of the other shower boundary
isBetween	if the shower core is between either the start or end boundary positions

Returns: whether the 'shower characterisation' mechanics could proceed

Definition at line 499 of file ShowerStartFinderTool.cc.

Referenced by IsShowerTopology().

 {
     try
     {
         // Perform shower sliding fit
         const TwoDSlidingShowerFitResult twoDShowerSlidingFit(
             &showerRegionPositionVector, m_showerSlidingFitWindow, LArGeometryHelper::GetWirePitch(this->GetPandora(), hitType));
         const LayerFitResultMap &layerFitResultMapS(twoDShowerSlidingFit.GetShowerFitResult().GetLayerFitResultMap());
         const LayerFitResultMap &layerFitResultMapP(twoDShowerSlidingFit.GetPositiveEdgeFitResult().GetLayerFitResultMap());
         const LayerFitResultMap &layerFitResultMapN(twoDShowerSlidingFit.GetNegativeEdgeFitResult().GetLayerFitResultMap());
 
         float showerStartL(0.f), showerStartT(0.f);
         twoDShowerSlidingFit.GetShowerFitResult().GetLocalPosition(showerStartPosition, showerStartL, showerStartT);
 
         const int startLayer(twoDShowerSlidingFit.GetShowerFitResult().GetLayer(showerStartL));
         const int endLayer(twoDShowerSlidingFit.GetShowerFitResult().GetMaxLayer());
 
         // Does the shower look to originate from the shower start position
         int layerCount(0);
         bool isFirstBetween(false), isLastBetween(false);
         CartesianPointVector coordinateListP, coordinateListN;
 
         for (LayerFitResultMap::const_iterator iterS = layerFitResultMapS.begin(); iterS != layerFitResultMapS.end(); ++iterS)
         {
             int layer(iterS->first);
 
             if (isEndDownstream && (layer < startLayer))
                 continue;
 
             if (!isEndDownstream && (layer > startLayer))
                 continue;
 
             LayerFitResultMap::const_iterator iterP = layerFitResultMapP.find(layer);
             LayerFitResultMap::const_iterator iterN = layerFitResultMapN.find(layer);
 
             CartesianVector positiveEdgePosition(0.f, 0.f, 0.f), negativeEdgePosition(0.f, 0.f, 0.f);
             if (layerFitResultMapP.end() != iterP)
             {
                 twoDShowerSlidingFit.GetShowerFitResult().GetGlobalPosition(iterP->second.GetL(), iterP->second.GetFitT(), positiveEdgePosition);
                 coordinateListP.push_back(positiveEdgePosition);
             }
 
             if (layerFitResultMapN.end() != iterN)
             {
                 twoDShowerSlidingFit.GetShowerFitResult().GetGlobalPosition(iterN->second.GetL(), iterN->second.GetFitT(), negativeEdgePosition);
                 coordinateListN.push_back(negativeEdgePosition);
             }
 
             if ((layerFitResultMapP.end() != iterP) && (layerFitResultMapN.end() != iterN))
             {
                 const CartesianVector positiveDisplacement((positiveEdgePosition - showerStartPosition).GetUnitVector());
                 const bool isPositiveClockwise(this->IsClockwiseRotation(showerStartDirection, positiveDisplacement));
 
                 const CartesianVector negativeDisplacement((negativeEdgePosition - showerStartPosition).GetUnitVector());
                 const bool isNegativeClockwise(this->IsClockwiseRotation(showerStartDirection, negativeDisplacement));
 
                 ++layerCount;
 
                 if (layerCount == 1)
                     isFirstBetween = (isPositiveClockwise != isNegativeClockwise);
 
                 isLastBetween = (isPositiveClockwise != isNegativeClockwise);
             }
         }
 
         isBetween = (isFirstBetween || isLastBetween);
 
         // Find the extremal points of the shower
         if (this->GetBoundaryExtremalPoints(twoDShowerSlidingFit, layerFitResultMapP, showerStartPosition, startLayer, endLayer,
                 positiveEdgeStart, positiveEdgeEnd) != STATUS_CODE_SUCCESS)
         {
             return STATUS_CODE_FAILURE;
         }
 
         if (this->GetBoundaryExtremalPoints(twoDShowerSlidingFit, layerFitResultMapN, showerStartPosition, startLayer, endLayer,
                 negativeEdgeStart, negativeEdgeEnd) != STATUS_CODE_SUCCESS)
         {
             return STATUS_CODE_FAILURE;
         }
     }
     catch (const StatusCodeException &)
     {
         return STATUS_CODE_FAILURE;
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ShowerStartFinderTool::ConvertLongitudinalProjectionToGlobal	(	const TwoDSlidingFitResult &	spineTwoDSlidingFit,
		const float	longitudinalDistance,
		pandora::CartesianVector &	globalPosition,
		pandora::CartesianVector &	globalDirection
	)		const

private

Determine the (X,Y,Z) position and direction at a given longitudinal distance along the spine.

Parameters

spineTwoDSlidingFit	the shower spine fit
longitudinalDistance	the input longitudinal distance
globalPosition	the output (X,Y,Z) position
globalDirection	the output (X,Y,Z) direction

Definition at line 319 of file ShowerStartFinderTool.cc.

References f, lar_content::TwoDSlidingFitResult::GetGlobalDirection(), lar_content::TwoDSlidingFitResult::GetGlobalPosition(), and lar_content::TwoDSlidingFitResult::GetLayerFitResultMap().

Referenced by FindShowerStartAndDirection(), and IsShowerTopology().

 {
     const LayerFitResultMap &layerFitResultMap(spineTwoDSlidingFit.GetLayerFitResultMap());
 
     float runningDistance(0.f);
     int showerStartLayer(0);
     CartesianVector previousLayerPosition(0.f, 0.f, 0.f);
     spineTwoDSlidingFit.GetGlobalPosition(layerFitResultMap.begin()->second.GetL(), layerFitResultMap.begin()->second.GetFitT(), previousLayerPosition);
 
     for (auto iter = std::next(layerFitResultMap.begin()); iter != layerFitResultMap.end(); ++iter)
     {
         const int layer(iter->first);
         showerStartLayer = layer;
 
         CartesianVector layerPosition(0.f, 0.f, 0.f);
         spineTwoDSlidingFit.GetGlobalPosition(layerFitResultMap.at(layer).GetL(), layerFitResultMap.at(layer).GetFitT(), layerPosition);
 
         runningDistance += (layerPosition - previousLayerPosition).GetMagnitude();
 
         if (runningDistance > longitudinalDistance)
             break;
 
         previousLayerPosition = layerPosition;
     }
 
     const float lCoordinate(layerFitResultMap.at(showerStartLayer).GetL()), tCoordinate(layerFitResultMap.at(showerStartLayer).GetFitT());
     const float localGradient(layerFitResultMap.at(showerStartLayer).GetGradient());
 
     spineTwoDSlidingFit.GetGlobalPosition(lCoordinate, tCoordinate, globalPosition);
     spineTwoDSlidingFit.GetGlobalDirection(localGradient, globalDirection);
 }

void lar_content::ShowerStartFinderTool::FindShowerStartAndDirection	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::HitType	hitType,
		const TwoDSlidingFitResult &	spineTwoDSlidingFit,
		const EnergySpectrumMap &	energySpectrumMap,
		const pandora::CaloHitList &	showerSpineHitList,
		const bool	isEndDownstream,
		pandora::CartesianVector &	showerStartPosition,
		pandora::CartesianVector &	showerStartDirection
	)		const

private

Find the position at which the shower cascade looks to originate, and its initial direction.

Parameters

pShowerPfo	the shower pfo
hitType	the 2D view
spineTwoDSlidingFit	the shower spine fit
energySpectrumMap	the [longitudial projection bin -> contained energy] map
showerSpineHitList	the shower spine hit list
isEndDownstream	whether the shower direction is downstream (in Z) of the neutrino vertex
showerStartPosition	the position at which the shower cascade looks to originate
showerStartDirection	the initial direction of the shower cascade

Definition at line 182 of file ShowerStartFinderTool.cc.

References ConvertLongitudinalProjectionToGlobal(), FindShowerStartLongitudinalCoordinate(), and m_longitudinalCoordinateBinSize.

Referenced by Run().

 {
     // Search for shower start at significant energy deviations
     int longitudinalStartBin(0);
 
     if (isEndDownstream)
     {
         longitudinalStartBin = this->FindShowerStartLongitudinalCoordinate(pShowerPfo, hitType, spineTwoDSlidingFit, energySpectrumMap,
             showerSpineHitList, isEndDownstream, energySpectrumMap.begin(), std::prev(energySpectrumMap.end()));
     }
     else
     {
         longitudinalStartBin = this->FindShowerStartLongitudinalCoordinate(pShowerPfo, hitType, spineTwoDSlidingFit, energySpectrumMap,
             showerSpineHitList, isEndDownstream, energySpectrumMap.rbegin(), std::prev(energySpectrumMap.rend()));
     }
 
     const float longitudinalStartCoordinate(longitudinalStartBin * m_longitudinalCoordinateBinSize);
 
     this->ConvertLongitudinalProjectionToGlobal(spineTwoDSlidingFit, longitudinalStartCoordinate, showerStartPosition, showerStartDirection);
 
     showerStartDirection = isEndDownstream ? showerStartDirection : showerStartDirection * (-1.f);
 }

template<typename T >

int lar_content::ShowerStartFinderTool::FindShowerStartLongitudinalCoordinate	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::HitType	hitType,
		const TwoDSlidingFitResult &	spineTwoDSlidingFit,
		const EnergySpectrumMap &	energySpectrumMap,
		const pandora::CaloHitList &	showerSpineHitList,
		const bool	isEndDownstream,
		const T	startIter,
		const T	endIter
	)		const

private

Find the longitudinal bin which corresponds to the start position of the shower cascade.

Parameters

pShowerPfo	the shower pfo
hitType	the 2D view
spineTwoDSlidingFit	the shower spine fit
energySpectrumMap	the [longitudial projection bin -> contained energy] map
showerSpineHitList	the shower spine hit list
isEndDownstream	whether the shower direction is downstream (in Z) of the neutrino vertex
startIter	the start iterator of energySpectrumMap
endIter	the end iterator of energySpectrumMap

Referenced by FindShowerStartAndDirection().

template<typename T >

int lar_content::ShowerStartFinderTool::FindShowerStartLongitudinalCoordinate	(	const ParticleFlowObject *const	pShowerPfo,
		const HitType	hitType,
		const TwoDSlidingFitResult &	spineTwoDSlidingFit,
		const EnergySpectrumMap &	energySpectrumMap,
		const CaloHitList &	showerSpineHitList,
		const bool	isEndDownstream,
		const T	startIter,
		const T	endIter
	)		const

Definition at line 210 of file ShowerStartFinderTool.cc.

References CharacteriseInitialEnergy(), f, IsShowerTopology(), m_longitudinalCoordinateBinSize, m_minSigmaDeviation, and m_nInitialEnergyBins.

 {
     // Characterise initial energy
     float meanEnergy(0.f), energySigma(0.f);
 
     if (energySpectrumMap.size() > m_nInitialEnergyBins)
         this->CharacteriseInitialEnergy(energySpectrumMap, isEndDownstream, meanEnergy, energySigma);
 
     // Now loop through energySpectrumMap
     T iter(startIter);
 
     std::advance(iter, (energySpectrumMap.size() > m_nInitialEnergyBins) ? m_nInitialEnergyBins : (energySpectrumMap.size() - 1));
 
     for (; iter != endIter; iter++)
     {
         const float longitudinalCoordinate(iter->first * m_longitudinalCoordinateBinSize);
         const float energyDeviation((iter->second - meanEnergy) / energySigma);
 
         try
         {
             // Use energy and local topology to assess whether we are at the shower start
             if ((energyDeviation > m_minSigmaDeviation) &&
                 this->IsShowerTopology(pShowerPfo, hitType, spineTwoDSlidingFit, longitudinalCoordinate, showerSpineHitList, isEndDownstream))
             {
                 break;
             }
         }
         catch (...)
         {
             continue;
         }
     }
 
     return iter->first;
 }

StatusCode lar_content::ShowerStartFinderTool::GetBoundaryExtremalPoints	(	const TwoDSlidingShowerFitResult &	showerTwoDSlidingFit,
		const LayerFitResultMap &	layerFitResultMap,
		const pandora::CartesianVector &	showerStartPosition,
		const int	showerStartLayer,
		const int	showerEndLayer,
		pandora::CartesianVector &	boundaryEdgeStart,
		pandora::CartesianVector &	boundaryEdgeEnd
	)		const

private

Determine the start and end positions of a shower boundary.

Parameters

showerTwoDSlidingFit	the shower fit
layerFitResultMap	the layer fit result map of the shower boundary fit
showerStartPosition	the shower start position
showerStartLayer	the shower start layer wrt the shower region fit
showerEndLayer	the shower end layer wrt the shower region fit
boundaryEdgeStart	the output boundary start position
boundaryEdgeEnd	the output boundary end position

Returns: whether suitable positions could be found

Definition at line 613 of file ShowerStartFinderTool.cc.

References util::abs(), lar_content::TwoDSlidingFitResult::GetGlobalPosition(), lar_content::TwoDSlidingShowerFitResult::GetShowerFitResult(), and m_maxLayerSeparation.

Referenced by CharacteriseShowerTopology().

 {
     int boundaryStartLayer(std::numeric_limits<int>::max());
     int boundaryEndLayer(std::numeric_limits<int>::max());
 
     for (auto &entry : layerFitResultMap)
     {
         const int bestStartSeparation(std::abs(showerStartLayer - boundaryStartLayer));
         const int thisStartSeparation(std::abs(showerStartLayer - entry.first));
 
         if (((bestStartSeparation - thisStartSeparation) > 0) && (thisStartSeparation < bestStartSeparation))
             boundaryStartLayer = entry.first;
 
         const int bestEndSeparation(std::abs(showerEndLayer - boundaryEndLayer));
         const int thisEndSeparation(std::abs(showerEndLayer - entry.first));
 
         if (((bestEndSeparation - thisEndSeparation) > 0) && (thisEndSeparation < bestEndSeparation))
             boundaryEndLayer = entry.first;
     }
 
     if (std::abs(showerStartLayer - boundaryStartLayer) > m_maxLayerSeparation)
         return STATUS_CODE_FAILURE;
 
     const float showerStartBoundaryLocalL(layerFitResultMap.at(boundaryStartLayer).GetL()),
         showerStartBoundaryLocalT(layerFitResultMap.at(boundaryStartLayer).GetFitT());
     const float showerEndBoundaryLocalL(layerFitResultMap.at(boundaryEndLayer).GetL()),
         showerEndBoundaryLocalT(layerFitResultMap.at(boundaryEndLayer).GetFitT());
 
     showerTwoDSlidingFit.GetShowerFitResult().GetGlobalPosition(showerStartBoundaryLocalL, showerStartBoundaryLocalT, boundaryEdgeStart);
     showerTwoDSlidingFit.GetShowerFitResult().GetGlobalPosition(showerEndBoundaryLocalL, showerEndBoundaryLocalT, boundaryEdgeEnd);
 
     // Swap start and end if needs be
     if ((showerStartPosition - boundaryEdgeEnd).GetMagnitudeSquared() < (showerStartPosition - boundaryEdgeStart).GetMagnitude())
     {
         const CartesianVector startTemp(boundaryEdgeStart), endTemp(boundaryEdgeEnd);
 
         boundaryEdgeStart = endTemp;
         boundaryEdgeEnd = startTemp;
     }
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ShowerStartFinderTool::GetEnergyDistribution	(	const pandora::CaloHitList &	showerSpineHitList,
		const LongitudinalPositionMap &	longitudinalPositionMap,
		EnergySpectrumMap &	energySpectrumMap
	)		const

private

Create the longituidnal energy distribution.

Parameters

showerSpineHitList	the shower spine hit list
longitudinalPositionMap	the shower spine longitudinal projection map
energySpectrumMap	the output [longitudial projection bin -> contained energy] map

Definition at line 159 of file ShowerStartFinderTool.cc.

References f, and m_longitudinalCoordinateBinSize.

Referenced by Run().

 {
     float e0(0.f);
 
     for (const CaloHit *pCaloHit : showerSpineHitList)
         e0 += pCaloHit->GetElectromagneticEnergy();
 
     for (const CaloHit *pCaloHit : showerSpineHitList)
     {
         const float fractionalEnergy(pCaloHit->GetElectromagneticEnergy() / e0);
         const float projection(longitudinalPositionMap.at(pCaloHit));
         const int longitudinalIndex = std::floor(projection / m_longitudinalCoordinateBinSize);
 
         if (energySpectrumMap.find(longitudinalIndex) == energySpectrumMap.end())
             energySpectrumMap[longitudinalIndex] = fractionalEnergy;
         else
             energySpectrumMap[longitudinalIndex] += fractionalEnergy;
     }
 }

bool lar_content::ShowerStartFinderTool::IsClockwiseRotation	(	const pandora::CartesianVector &	showerStartDirection,
		const pandora::CartesianVector &	displacementVector
	)		const

private

Determine whether a point lies on the RHS or LHS (wrt +ve Z) of the shower core.

Parameters

showerStartDirection	the shower start direction
displacementVector	the input position wrt the shower start position

Returns: whether a point lies on the RHS or LHS (wrt +ve Z) of the shower core

Definition at line 591 of file ShowerStartFinderTool.cc.

References f.

Referenced by CharacteriseShowerTopology().

 {
     // Clockwise with respect to +ve Z
     const float openingAngleFromCore(showerStartDirection.GetOpeningAngle(displacementVector));
 
     const CartesianVector clockwiseRotation(
         displacementVector.GetZ() * std::sin(openingAngleFromCore) + displacementVector.GetX() * std::cos(openingAngleFromCore), 0.f,
         displacementVector.GetZ() * std::cos(openingAngleFromCore) - displacementVector.GetX() * std::sin(openingAngleFromCore));
 
     const CartesianVector anticlockwiseRotation(
         displacementVector.GetZ() * std::sin(-1.f * openingAngleFromCore) + displacementVector.GetX() * std::cos(-1.f * openingAngleFromCore), 0.f,
         displacementVector.GetZ() * std::cos(-1.f * openingAngleFromCore) - displacementVector.GetX() * std::sin(-1.f * openingAngleFromCore));
 
     const float clockwiseT((clockwiseRotation - showerStartDirection).GetMagnitude());
     const float anticlockwiseT((anticlockwiseRotation - showerStartDirection).GetMagnitude());
     const bool isClockwise(clockwiseT < anticlockwiseT);
 
     return isClockwise;
 }

bool lar_content::ShowerStartFinderTool::IsShowerTopology	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::HitType	hitType,
		const TwoDSlidingFitResult &	spineTwoDSlidingFit,
		const float	longitudinalDistance,
		const pandora::CaloHitList &	showerSpineHitList,
		const bool	isEndDownstream
	)		const

private

Whether a sensible shower cascade looks to originate at a given position.

Parameters

pShowerPfo	the shower pfo
hitType	the 2D view
spineTwoDSlidingFit	the shower spine fit
longitudinalDistance	the longitudinal projection of the candidate shower start position
showerSpineHitList	the shower spine hit list
isEndDownstream	whether the shower direction is downstream (in Z) of the neutrino vertex

Returns: whether a sensible shower cascade looks to originate at the given position

Definition at line 276 of file ShowerStartFinderTool.cc.

References BuildShowerRegion(), CharacteriseShowerTopology(), ConvertLongitudinalProjectionToGlobal(), f, and m_minShowerOpeningAngle.

Referenced by FindShowerStartLongitudinalCoordinate().

 {
     CartesianVector showerStartPosition(0.f, 0.f, 0.f), showerStartDirection(0.f, 0.f, 0.f);
     this->ConvertLongitudinalProjectionToGlobal(spineTwoDSlidingFit, longitudinalDistance, showerStartPosition, showerStartDirection);
 
     // Build shower
     CartesianPointVector showerRegionPositionVector;
     if (this->BuildShowerRegion(pShowerPfo, hitType, showerSpineHitList, showerStartPosition, showerStartDirection, isEndDownstream,
             showerRegionPositionVector) != STATUS_CODE_SUCCESS)
     {
         return false;
     }
 
     // Characterise the shower
     bool isBetween(false);
     CartesianVector positiveEdgeStart(0.f, 0.f, 0.f), positiveEdgeEnd(0.f, 0.f, 0.f), positiveEdgeDirection(0.f, 0.f, 0.f);
     CartesianVector negativeEdgeStart(0.f, 0.f, 0.f), negativeEdgeEnd(0.f, 0.f, 0.f), negativeEdgeDirection(0.f, 0.f, 0.f);
 
     if (this->CharacteriseShowerTopology(showerRegionPositionVector, showerStartPosition, hitType, isEndDownstream, showerStartDirection,
             positiveEdgeStart, positiveEdgeEnd, negativeEdgeStart, negativeEdgeEnd, isBetween) != STATUS_CODE_SUCCESS)
     {
         return false;
     }
 
     if (!isBetween)
         return false;
 
     positiveEdgeStart = showerStartPosition;
     negativeEdgeStart = showerStartPosition;
     positiveEdgeDirection = positiveEdgeEnd - positiveEdgeStart;
     negativeEdgeDirection = negativeEdgeEnd - negativeEdgeStart;
 
     const float showerOpeningAngle(positiveEdgeDirection.GetOpeningAngle(negativeEdgeDirection) * 180.f / 3.14);
 
     if (showerOpeningAngle < m_minShowerOpeningAngle)
         return false;
 
     return true;
 }

void lar_content::ShowerStartFinderTool::ObtainLongitudinalDecomposition	(	const TwoDSlidingFitResult &	spineTwoDSlidingFit,
		const pandora::CaloHitList &	showerSpineHitList,
		LongitudinalPositionMap &	longitudinalPositionMap
	)		const

private

Create the [shower spine hit -> shower spine fit longitudinal projection] map.

Parameters

spineTwoDSlidingFit	the shower spine fit
showerSpineHitList	the shower spine hit list
longitudinalPositionMap	the output shower spine longitudinal projection map

Definition at line 79 of file ShowerStartFinderTool.cc.

References f, lar_content::TwoDSlidingFitResult::GetGlobalPosition(), lar_content::TwoDSlidingFitResult::GetLayer(), lar_content::TwoDSlidingFitResult::GetLayerFitResultMap(), and lar_content::TwoDSlidingFitResult::GetLocalPosition().

Referenced by Run().

 {
     // Find hits in each layer
     LayerToHitMap layerToHitMap;
 
     for (const CaloHit *const pCaloHit : showerSpineHitList)
     {
         float hitL(0.f), hitT(0.f);
         const CartesianVector hitPosition(pCaloHit->GetPositionVector());
 
         spineTwoDSlidingFit.GetLocalPosition(hitPosition, hitL, hitT);
         layerToHitMap[spineTwoDSlidingFit.GetLayer(hitL)].push_back(pCaloHit);
     }
 
     // Walk through layers and store the longitudinal distance of each hit
     // IMPORTANT: layer positions correspond to the middle of the layer
     // IMPORTANT: the longitudinal distance is measured relative to the first layer position (where l = 0)
     // IMPORTANT: at any point, the running distance is that at the lowest neighbour central position
     float runningDistance(0);
     const LayerFitResultMap &layerFitResultMap(spineTwoDSlidingFit.GetLayerFitResultMap());
 
     for (auto iter = layerToHitMap.begin(); iter != layerToHitMap.end(); ++iter)
     {
         const int layer(iter->first);
         const float layerL(layerFitResultMap.at(layer).GetL());
 
         // Get global positions of layer and its neighbours
         const int higherLayer(std::next(iter) == layerToHitMap.end() ? layer : std::next(iter)->first);
         const int middleLayer(layer);
         const int lowerLayer(iter == layerToHitMap.begin() ? layer : std::prev(iter)->first);
         CartesianVector lowerLayerPosition(0.f, 0.f, 0.f), middleLayerPosition(0.f, 0.f, 0.f), higherLayerPosition(0.f, 0.f, 0.f);
 
         spineTwoDSlidingFit.GetGlobalPosition(layerFitResultMap.at(lowerLayer).GetL(), layerFitResultMap.at(lowerLayer).GetFitT(), lowerLayerPosition);
         spineTwoDSlidingFit.GetGlobalPosition(layerFitResultMap.at(middleLayer).GetL(), layerFitResultMap.at(middleLayer).GetFitT(), middleLayerPosition);
         spineTwoDSlidingFit.GetGlobalPosition(layerFitResultMap.at(higherLayer).GetL(), layerFitResultMap.at(higherLayer).GetFitT(), higherLayerPosition);
 
         const float layerLength = std::next(iter) == layerToHitMap.end() ? 0.f
             : iter == layerToHitMap.begin()                              ? 0.f
                                                                          : (middleLayerPosition - lowerLayerPosition).GetMagnitude();
 
         for (const CaloHit *const pCaloHit : iter->second)
         {
             const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
 
             float hitL(0.f), hitT(0.f);
             spineTwoDSlidingFit.GetLocalPosition(hitPosition, hitL, hitT);
 
             // Is the hit below or above the middle of the layer?
             // Therefore, determine which layer positions the hit is between
             CartesianVector localLowerLayerPosition(0.f, 0.f, 0.f), localHigherLayerPosition(0.f, 0.f, 0.f);
 
             if (hitL < layerL)
             {
                 localLowerLayerPosition = lowerLayerPosition;
                 localHigherLayerPosition = iter == layerToHitMap.begin() ? higherLayerPosition : middleLayerPosition;
             }
             else
             {
                 localLowerLayerPosition = std::next(iter) == layerToHitMap.end() ? lowerLayerPosition : middleLayerPosition;
                 localHigherLayerPosition = higherLayerPosition;
             }
 
             // Determine the axis to project onto
             // Calculate the distance of axis between its two nearest neighbours
             const CartesianVector displacement((higherLayerPosition - lowerLayerPosition).GetUnitVector());
             float longitudinalDisplacement = (displacement.GetDotProduct(hitPosition - lowerLayerPosition) + runningDistance);
 
             // If we've passed the central position, we need to add on the layer length
             longitudinalDisplacement += (hitL > layerL ? layerLength : 0.f);
 
             longitudinalPositionMap[pCaloHit] = longitudinalDisplacement;
         }
 
         runningDistance += layerLength;
     }
 }

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

private

Definition at line 660 of file ShowerStartFinderTool.cc.

References m_longitudinalCoordinateBinSize, m_longitudinalShowerFraction, m_maxEdgeGap, m_maxLayerSeparation, m_minShowerOpeningAngle, m_minSigmaDeviation, m_molliereRadius, m_nInitialEnergyBins, m_showerSlidingFitWindow, and m_spineSlidingFitWindow.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SpineSlidingFitWindow", m_spineSlidingFitWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LongitudinalCoordinateBinSize", m_longitudinalCoordinateBinSize));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "nInitialEnergyBins", m_nInitialEnergyBins));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinSigmaDeviation", m_minSigmaDeviation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxEdgeGap", m_maxEdgeGap));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "LongitudinalShowerFraction", m_longitudinalShowerFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinShowerOpeningAngle", m_minShowerOpeningAngle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MolliereRadius", m_molliereRadius));
 
     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, "MaxLayerSeparation", m_maxLayerSeparation));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ShowerStartFinderTool::Run	(	const pandora::ParticleFlowObject *const	pShowerPfo,
		const pandora::CartesianVector &	peakDirection,
		const pandora::HitType	hitType,
		const pandora::CaloHitList &	showerSpineHitList,
		pandora::CartesianVector &	showerStartPosition,
		pandora::CartesianVector &	showerStartDirection
	)

Definition at line 42 of file ShowerStartFinderTool.cc.

References FindShowerStartAndDirection(), GetEnergyDistribution(), lar_content::LArGeometryHelper::GetWirePitch(), m_spineSlidingFitWindow, and ObtainLongitudinalDecomposition().

Referenced by lar_content::ElectronInitialRegionRefinementAlgorithm::BuildViewProtoShowers().

 {
     try
     {
         // Fit the shower spine
         CartesianPointVector hitPositions;
         for (const CaloHit *const pCaloHit : showerSpineHitList)
             hitPositions.push_back(pCaloHit->GetPositionVector());
 
         const TwoDSlidingFitResult spineTwoDSlidingFit(
             &hitPositions, m_spineSlidingFitWindow, LArGeometryHelper::GetWirePitch(this->GetPandora(), hitType));
 
         // First obtain the longitudinal position of spine hits
         LongitudinalPositionMap longitudinalPositionMap;
         this->ObtainLongitudinalDecomposition(spineTwoDSlidingFit, showerSpineHitList, longitudinalPositionMap);
 
         // Obtain spine energy profile
         EnergySpectrumMap energySpectrumMap;
         this->GetEnergyDistribution(showerSpineHitList, longitudinalPositionMap, energySpectrumMap);
 
         // Now find the shower start position/direction
         const bool isEndDownstream(peakDirection.GetZ() > 0.f);
 
         this->FindShowerStartAndDirection(pShowerPfo, hitType, spineTwoDSlidingFit, energySpectrumMap, showerSpineHitList, isEndDownstream,
             showerStartPosition, showerStartDirection);
     }
     catch (...)
     {
         return STATUS_CODE_FAILURE;
     }
 
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

float lar_content::ShowerStartFinderTool::m_longitudinalCoordinateBinSize

private

The longitudinal coordinate bin size.

Definition at line 195 of file ShowerStartFinderTool.h.

Referenced by FindShowerStartAndDirection(), FindShowerStartLongitudinalCoordinate(), GetEnergyDistribution(), and ReadSettings().

float lar_content::ShowerStartFinderTool::m_longitudinalShowerFraction

private

The shower region fraction considered.

Definition at line 199 of file ShowerStartFinderTool.h.

Referenced by BuildShowerRegion(), and ReadSettings().

float lar_content::ShowerStartFinderTool::m_maxEdgeGap

private

The max. allowed layer gap in a shower boundary.

Definition at line 198 of file ShowerStartFinderTool.h.

Referenced by BuildShowerRegion(), and ReadSettings().

int lar_content::ShowerStartFinderTool::m_maxLayerSeparation

private

The max. allowed separation between the shower start and boundary start layers.

Definition at line 203 of file ShowerStartFinderTool.h.

Referenced by GetBoundaryExtremalPoints(), and ReadSettings().

float lar_content::ShowerStartFinderTool::m_minShowerOpeningAngle

private

The min. opening angle of a sensible shower.

Definition at line 200 of file ShowerStartFinderTool.h.

Referenced by IsShowerTopology(), and ReadSettings().

float lar_content::ShowerStartFinderTool::m_minSigmaDeviation

private

The min. average energy deviation of a candidate shower start.

Definition at line 197 of file ShowerStartFinderTool.h.

Referenced by FindShowerStartLongitudinalCoordinate(), and ReadSettings().

float lar_content::ShowerStartFinderTool::m_molliereRadius

private

The max. distance from the shower core of a collected shower region hit.

Definition at line 201 of file ShowerStartFinderTool.h.

Referenced by BuildShowerRegion(), and ReadSettings().

unsigned int lar_content::ShowerStartFinderTool::m_nInitialEnergyBins

private

The number of longitudinal bins that define the initial region.

Definition at line 196 of file ShowerStartFinderTool.h.

Referenced by CharacteriseInitialEnergy(), FindShowerStartLongitudinalCoordinate(), and ReadSettings().

unsigned int lar_content::ShowerStartFinderTool::m_showerSlidingFitWindow

private

The sliding window used to fit the shower region.

Definition at line 202 of file ShowerStartFinderTool.h.

Referenced by BuildShowerRegion(), CharacteriseShowerTopology(), and ReadSettings().

unsigned int lar_content::ShowerStartFinderTool::m_spineSlidingFitWindow

private

The sliding window used to fit the shower spine.

Definition at line 194 of file ShowerStartFinderTool.h.

Referenced by ReadSettings(), and Run().

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

larpandoracontent/v04_14_00/source/larpandoracontent/LArShowerRefinement/ShowerStartFinderTool.h
larpandoracontent/v04_14_00/source/larpandoracontent/LArShowerRefinement/ShowerStartFinderTool.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