TwoDSlidingShowerFitResult class. More...

#include <LArTwoDSlidingShowerFitResult.h>

Public Member Functions
template<typename T >
	TwoDSlidingShowerFitResult (const T *const pT, const unsigned int slidingFitWindow, const float slidingFitLayerPitch, const float showerEdgeMultiplier=1.f)
	Constructor. More...

const TwoDSlidingFitResult &	GetShowerFitResult () const
	Get the sliding fit result for the full shower cluster. More...

const TwoDSlidingFitResult &	GetNegativeEdgeFitResult () const
	Get the sliding fit result for the negative shower edge. More...

const TwoDSlidingFitResult &	GetPositiveEdgeFitResult () const
	Get the sliding fit result for the positive shower edge. More...

void	GetShowerEdges (const float x, const bool widenIfAmbiguity, pandora::FloatVector &edgePositions) const
	Get the most appropriate shower edges at a given x coordinate. More...

Private Types
typedef std::pair< float, float >	FitCoordinate

typedef std::vector< FitCoordinate >	FitCoordinateList

typedef std::map< int, FitCoordinateList >	FitCoordinateMap

Static Private Member Functions
static TwoDSlidingFitResult	LArTwoDShowerEdgeFit (const pandora::Cluster *const pCluster, const TwoDSlidingFitResult &fullShowerFit, const ShowerEdge showerEdge, const float showerEdgeMultiplier)
	Perform two dimensional sliding fit to shower edge, using specified primary axis. More...

static TwoDSlidingFitResult	LArTwoDShowerEdgeFit (const pandora::CartesianPointVector *const pPointVector, const TwoDSlidingFitResult &fullShowerFit, const ShowerEdge showerEdge, const float showerEdgeMultiplier)
	Perform two dimensional sliding fit to shower edge, using specified primary axis. More...

Private Attributes
TwoDSlidingFitResult	m_showerFitResult
	The sliding fit result for the full shower cluster. More...

TwoDSlidingFitResult	m_negativeEdgeFitResult
	The sliding fit result for the negative shower edge. More...

TwoDSlidingFitResult	m_positiveEdgeFitResult
	The sliding fit result for the positive shower edge. More...

Detailed Description

TwoDSlidingShowerFitResult class.

Definition at line 34 of file LArTwoDSlidingShowerFitResult.h.

Member Typedef Documentation

typedef std::pair<float, float> lar_content::TwoDSlidingShowerFitResult::FitCoordinate

private

Definition at line 106 of file LArTwoDSlidingShowerFitResult.h.

typedef std::vector<FitCoordinate> lar_content::TwoDSlidingShowerFitResult::FitCoordinateList

private

Definition at line 107 of file LArTwoDSlidingShowerFitResult.h.

typedef std::map<int, FitCoordinateList> lar_content::TwoDSlidingShowerFitResult::FitCoordinateMap

private

Definition at line 108 of file LArTwoDSlidingShowerFitResult.h.

Constructor & Destructor Documentation

template<typename T >

template lar_content::TwoDSlidingShowerFitResult::TwoDSlidingShowerFitResult	(	const T *const	pT,
		const unsigned int	slidingFitWindow,
		const float	slidingFitLayerPitch,
		const float	showerEdgeMultiplier = `1.f`
	)

Constructor.

Parameters

pT	describing the positions to be fitted
slidingFitWindow	the sliding fit window
slidingFitLayerPitch	the sliding fit z pitch, units cm
showerEdgeMultiplier	artificially tune width of shower envelope so as to make it more/less inclusive

Definition at line 25 of file LArTwoDSlidingShowerFitResult.cc.

                                                                                                                                 :
     m_showerFitResult(TwoDSlidingFitResult(pT, slidingFitWindow, slidingFitLayerPitch)),
     m_negativeEdgeFitResult(TwoDSlidingShowerFitResult::LArTwoDShowerEdgeFit(pT, m_showerFitResult, NEGATIVE_SHOWER_EDGE, showerEdgeMultiplier)),
     m_positiveEdgeFitResult(TwoDSlidingShowerFitResult::LArTwoDShowerEdgeFit(pT, m_showerFitResult, POSITIVE_SHOWER_EDGE, showerEdgeMultiplier))
 {
 }

Member Function Documentation

const TwoDSlidingFitResult & lar_content::TwoDSlidingShowerFitResult::GetNegativeEdgeFitResult ( ) const

inline

Get the sliding fit result for the negative shower edge.

Returns: the sliding fit result for the negative shower edge

Definition at line 174 of file LArTwoDSlidingShowerFitResult.h.

 {
     return m_negativeEdgeFitResult;
 }

const TwoDSlidingFitResult & lar_content::TwoDSlidingShowerFitResult::GetPositiveEdgeFitResult ( ) const

inline

Get the sliding fit result for the positive shower edge.

Returns: the sliding fit result for the positive shower edge

Definition at line 181 of file LArTwoDSlidingShowerFitResult.h.

 {
     return m_positiveEdgeFitResult;
 }

void lar_content::TwoDSlidingShowerFitResult::GetShowerEdges	(	const float	x,
		const bool	widenIfAmbiguity,
		pandora::FloatVector &	edgePositions
	)		const

Get the most appropriate shower edges at a given x coordinate.

Parameters

x	the x coordinate
widenIfAmbiguity	whether to widen the shower edges in cases of ambiguities (i.e. be generous)
edgePositions	to receive the list of intersections of the shower fit at the given x coordinate

Definition at line 35 of file LArTwoDSlidingShowerFitResult.cc.

 {
     edgePositions.clear();
     CartesianPointVector fitPositionVector;
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, this->GetNegativeEdgeFitResult().GetGlobalFitPositionListAtX(x, fitPositionVector));
     PANDORA_THROW_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, this->GetPositiveEdgeFitResult().GetGlobalFitPositionListAtX(x, fitPositionVector));
 
     if (fitPositionVector.size() < 2)
     {
         float minXn(0.f), maxXn(0.f), minXp(0.f), maxXp(0.f);
         this->GetNegativeEdgeFitResult().GetMinAndMaxX(minXn, maxXn);
         this->GetPositiveEdgeFitResult().GetMinAndMaxX(minXp, maxXp);
         const float minX(std::min(minXn, minXp)), maxX(std::max(maxXn, maxXp));
 
         if ((x < minX) || (x > maxX))
             return;
 
         float minZn(0.f), maxZn(0.f), minZp(0.f), maxZp(0.f);
         this->GetNegativeEdgeFitResult().GetMinAndMaxZ(minZn, maxZn);
         this->GetPositiveEdgeFitResult().GetMinAndMaxZ(minZp, maxZp);
         const float minZ(std::min(minZn, minZp)), maxZ(std::max(maxZn, maxZp));
 
         if (!widenIfAmbiguity)
         {
             return;
         }
         else if (fitPositionVector.empty())
         {
             fitPositionVector.push_back(CartesianVector(x, 0.f, minZ));
             fitPositionVector.push_back(CartesianVector(x, 0.f, maxZ));
         }
         else if (1 == fitPositionVector.size())
         {
             // ATTN Could improve sophistication of choice of second bounding edge
             const float existingEdge(fitPositionVector.front().GetZ());
             const float secondEdge((std::fabs(existingEdge - minZ) < std::fabs(existingEdge - maxZ)) ? minZ : maxZ);
             fitPositionVector.push_back(CartesianVector(x, 0.f, secondEdge));
         }
     }
 
     FloatVector localEdgePositions;
     for (const CartesianVector &fitPosition : fitPositionVector)
         localEdgePositions.push_back(fitPosition.GetZ());
 
     if (localEdgePositions.size() < 2)
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     std::sort(localEdgePositions.begin(), localEdgePositions.end());
     edgePositions.push_back(localEdgePositions.front());
     edgePositions.push_back(localEdgePositions.back());
 }

const TwoDSlidingFitResult & lar_content::TwoDSlidingShowerFitResult::GetShowerFitResult ( ) const

inline

Get the sliding fit result for the full shower cluster.

Returns: the sliding fit result for the full shower cluster

Definition at line 167 of file LArTwoDSlidingShowerFitResult.h.

 {
     return m_showerFitResult;
 }

static TwoDSlidingFitResult lar_content::TwoDSlidingShowerFitResult::LArTwoDShowerEdgeFit	(	const pandora::Cluster *const	pCluster,
		const TwoDSlidingFitResult &	fullShowerFit,
		const ShowerEdge	showerEdge,
		const float	showerEdgeMultiplier
	)

staticprivate

Perform two dimensional sliding fit to shower edge, using specified primary axis.

Parameters

pCluster	the address of the input cluster
fullShowerFit	the result of fitting the full shower
showerEdge	the shower edge
showerEdgeMultiplier	artificially tune width of shower envelope so as to make it more/less inclusive

Returns: the shower edge fit result

static TwoDSlidingFitResult lar_content::TwoDSlidingShowerFitResult::LArTwoDShowerEdgeFit	(	const pandora::CartesianPointVector *const	pPointVector,
		const TwoDSlidingFitResult &	fullShowerFit,
		const ShowerEdge	showerEdge,
		const float	showerEdgeMultiplier
	)

staticprivate

Perform two dimensional sliding fit to shower edge, using specified primary axis.

Parameters

pPointVector	the address of the input point vector
fullShowerFit	the result of fitting the full shower
showerEdge	the shower edge
showerEdgeMultiplier	artificially tune width of shower envelope so as to make it more/less inclusive