ThreeDSlidingFitResult class. More...

#include <LArThreeDSlidingFitResult.h>

Public Member Functions
template<typename T >
	ThreeDSlidingFitResult (const T *const pT, const unsigned int slidingFitWindow, const float slidingFitLayerPitch)
	Constructor. More...

const pandora::Cluster *	GetCluster () const
	Get the address of the cluster. More...

const pandora::CartesianVector &	GetAxisIntercept () const
	Get the axis intercept position. More...

const pandora::CartesianVector &	GetAxisDirection () const
	Get the axis direction vector. More...

const TwoDSlidingFitResult &	GetFirstFitResult () const
	Get the first sliding fit result for this cluster. More...

const TwoDSlidingFitResult &	GetSecondFitResult () const
	Get the second sliding fit result for this cluster. More...

const pandora::CartesianVector &	GetGlobalMinLayerPosition () const
	Get global position corresponding to the fit result in minimum fit layer. More...

const pandora::CartesianVector &	GetGlobalMaxLayerPosition () const
	Get global position corresponding to the fit result in maximum fit layer. More...

const pandora::CartesianVector &	GetGlobalMinLayerDirection () const
	Get global direction corresponding to the fit result in minimum fit layer. More...

const pandora::CartesianVector &	GetGlobalMaxLayerDirection () const
	Get global direction corresponding to the fit result in maximum fit layer. More...

int	GetMinLayer () const
	Get the minimum occupied layer in the sliding fit. More...

int	GetMaxLayer () const
	Get the maximum occupied layer in the sliding fit. More...

float	GetMinLayerRms () const
	Get rms at minimum layer. More...

float	GetMaxLayerRms () const
	Get rms at maximum layer. More...

float	GetFitRms (const float rL) const
	Get fit rms for a given longitudinal coordinate. More...

float	GetLongitudinalDisplacement (const pandora::CartesianVector &position) const
	Get longitudinal projection onto primary axis. More...

pandora::StatusCode	GetGlobalFitPosition (const float rL, pandora::CartesianVector &position) const
	Get global fit position for a given longitudinal coordinate. More...

pandora::StatusCode	GetGlobalFitDirection (const float rL, pandora::CartesianVector &direction) const
	Get global fit direction for a given longitudinal coordinate. More...

Private Member Functions
void	GetGlobalPosition (const float rL, const float rT1, const float rT2, pandora::CartesianVector &position) const
	Get global coordinates for a given pair of sliding linear fit coordinates. More...

void	GetGlobalDirection (const float dTdL1, const float dTdL2, pandora::CartesianVector &direction) const
	Get global direction coordinates for a given pair of sliding linear fit gradients. More...

Static Private Member Functions
static pandora::TrackState	GetPrimaryAxis (const pandora::Cluster *const pCluster, const float slidingFitLayerPitch)
	Calculate the position and direction of the primary axis. More...

static pandora::TrackState	GetPrimaryAxis (const pandora::CartesianPointVector *const pPointVector, const float slidingFitLayerPitch)
	Calculate the position and direction of the primary axis. More...

static pandora::CartesianVector	GetSeedDirection (const pandora::CartesianVector &axisDirection)
	Generate a seed vector to be used in calculating the orthogonal axes. More...

Private Attributes
const pandora::TrackState	m_primaryAxis
	The primary axis position and direction. More...

const pandora::CartesianVector	m_axisIntercept
	The axis intercept position. More...

const pandora::CartesianVector	m_axisDirection
	The axis direction vector. More...

const pandora::CartesianVector	m_firstOrthoDirection
	The orthogonal direction vector. More...

const pandora::CartesianVector	m_secondOrthoDirection
	The orthogonal direction vector. More...

const TwoDSlidingFitResult	m_firstFitResult
	The first sliding fit result. More...

const TwoDSlidingFitResult	m_secondFitResult
	The second sliding fit result. More...

const int	m_minLayer
	The minimum combined layer. More...

const int	m_maxLayer
	The maximum combined layer. More...

pandora::CartesianVector	m_minLayerPosition
	The global position at the minimum combined layer. More...

pandora::CartesianVector	m_maxLayerPosition
	The global position at the maximum combined layer. More...

pandora::CartesianVector	m_minLayerDirection
	The global direction at the minimum combined layer. More...

pandora::CartesianVector	m_maxLayerDirection
	The global direction at the maximum combined layer. More...

Detailed Description

ThreeDSlidingFitResult class.

Definition at line 23 of file LArThreeDSlidingFitResult.h.

Constructor & Destructor Documentation

template<typename T >

template lar_content::ThreeDSlidingFitResult::ThreeDSlidingFitResult	(	const T *const	pT,
		const unsigned int	slidingFitWindow,
		const float	slidingFitLayerPitch
	)

Constructor.

Parameters

pT	describing the positions to be fitted
slidingFitWindow	the sliding fit window
slidingFitLayerPitch	the sliding fit z pitch, units cm

Definition at line 28 of file LArThreeDSlidingFitResult.cc.

                                                                                                                         :
     m_primaryAxis(ThreeDSlidingFitResult::GetPrimaryAxis(pT, layerPitch)),
     m_axisIntercept(m_primaryAxis.GetPosition()),
     m_axisDirection(m_primaryAxis.GetMomentum()),
     m_firstOrthoDirection(ThreeDSlidingFitResult::GetSeedDirection(m_axisDirection).GetCrossProduct(m_axisDirection).GetUnitVector()),
     m_secondOrthoDirection(m_axisDirection.GetCrossProduct(m_firstOrthoDirection).GetUnitVector()),
     m_firstFitResult(TwoDSlidingFitResult(pT, layerWindow, layerPitch, m_axisIntercept, m_axisDirection, m_firstOrthoDirection)),
     m_secondFitResult(TwoDSlidingFitResult(pT, layerWindow, layerPitch, m_axisIntercept, m_axisDirection, m_secondOrthoDirection)),
     m_minLayer(std::max(m_firstFitResult.GetMinLayer(), m_secondFitResult.GetMinLayer())),
     m_maxLayer(std::min(m_firstFitResult.GetMaxLayer(), m_secondFitResult.GetMaxLayer())),
     m_minLayerPosition(0.f, 0.f, 0.f),
     m_maxLayerPosition(0.f, 0.f, 0.f),
     m_minLayerDirection(0.f, 0.f, 0.f),
     m_maxLayerDirection(0.f, 0.f, 0.f)
 {
     if (m_minLayer > m_maxLayer)
         throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
     const float minL(m_firstFitResult.GetL(m_minLayer));
     const float maxL(m_firstFitResult.GetL(m_maxLayer));
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetGlobalFitPosition(minL, m_minLayerPosition));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetGlobalFitPosition(maxL, m_maxLayerPosition));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetGlobalFitDirection(minL, m_minLayerDirection));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetGlobalFitDirection(maxL, m_maxLayerDirection));
 }

Member Function Documentation

const pandora::CartesianVector & lar_content::ThreeDSlidingFitResult::GetAxisDirection ( ) const

inline

Get the axis direction vector.

Returns: the axis direction vector

Definition at line 243 of file LArThreeDSlidingFitResult.h.

 {
     return m_axisDirection;
 }

const pandora::CartesianVector & lar_content::ThreeDSlidingFitResult::GetAxisIntercept ( ) const

inline

Get the axis intercept position.

Returns: the axis intercept position

Definition at line 236 of file LArThreeDSlidingFitResult.h.

 {
     return m_axisIntercept;
 }

const pandora::Cluster * lar_content::ThreeDSlidingFitResult::GetCluster ( ) const

Get the address of the cluster.

Returns: the address of the cluster

Definition at line 57 of file LArThreeDSlidingFitResult.cc.

 {
     return m_firstFitResult.GetCluster();
 }

const TwoDSlidingFitResult & lar_content::ThreeDSlidingFitResult::GetFirstFitResult ( ) const

inline

Get the first sliding fit result for this cluster.

Returns: the first sliding fit result for this cluster

Definition at line 250 of file LArThreeDSlidingFitResult.h.

 {
     return m_firstFitResult;
 }

float lar_content::ThreeDSlidingFitResult::GetFitRms ( const float rL ) const

Get fit rms for a given longitudinal coordinate.

Parameters

rL	the longitudinal coordinate

Returns: the fit rms

Definition at line 104 of file LArThreeDSlidingFitResult.cc.

 {
     const float firstRms(m_firstFitResult.GetFitRms(rL));
     const float secondRms(m_secondFitResult.GetFitRms(rL));
 
     return std::sqrt(firstRms * firstRms + secondRms * secondRms);
 }

void lar_content::ThreeDSlidingFitResult::GetGlobalDirection	(	const float	dTdL1,
		const float	dTdL2,
		pandora::CartesianVector &	direction
	)		const

private

Get global direction coordinates for a given pair of sliding linear fit gradients.

Parameters

dTdL1	the first transverse coordinate
dTdL2	the second transverse coordinate
direction	to receive the direction cartesian vector

Definition at line 194 of file LArThreeDSlidingFitResult.cc.

 {
     const float pL(1.f / std::sqrt(1.f + dTdL1 * dTdL1 + dTdL2 * dTdL2));
     const float pT1(dTdL1 / std::sqrt(1.f + dTdL1 * dTdL1 + dTdL2 * dTdL2));
     const float pT2(dTdL2 / std::sqrt(1.f + dTdL1 * dTdL1 + dTdL2 * dTdL2));
 
     CartesianVector globalCoordinates(0.f, 0.f, 0.f);
     this->GetGlobalPosition(pL, pT1, pT2, globalCoordinates);
     direction = (globalCoordinates - m_axisIntercept).GetUnitVector();
 }

StatusCode lar_content::ThreeDSlidingFitResult::GetGlobalFitDirection	(	const float	rL,
		pandora::CartesianVector &	direction
	)		const

Get global fit direction for a given longitudinal coordinate.

Parameters

rL	the longitudinal coordinate
direction	the fitted direction at these coordinates

Returns: status code, faster than throwing in regular use-cases

Definition at line 154 of file LArThreeDSlidingFitResult.cc.

 {
     // Check that input coordinates are between first and last layers
     const int layer1(m_firstFitResult.GetLayer(rL));
     const int layer2(m_secondFitResult.GetLayer(rL));
 
     if (std::min(layer1, layer2) < m_minLayer || std::max(layer1, layer2) > m_maxLayer)
         return STATUS_CODE_INVALID_PARAMETER;
 
     // Get local directions from each sliding fit (TODO: Make this more efficient)
     CartesianVector firstDirection(0.f, 0.f, 0.f), secondDirection(0.f, 0.f, 0.f);
     const StatusCode statusCode1(m_firstFitResult.GetGlobalFitDirection(rL, firstDirection));
 
     if (STATUS_CODE_SUCCESS != statusCode1)
         return statusCode1;
 
     const StatusCode statusCode2(m_secondFitResult.GetGlobalFitDirection(rL, secondDirection));
 
     if (STATUS_CODE_SUCCESS != statusCode2)
         return statusCode2;
 
     float dTdL1(0.f), dTdL2(0.f);
     m_firstFitResult.GetLocalDirection(firstDirection, dTdL1);
     m_secondFitResult.GetLocalDirection(secondDirection, dTdL2);
 
     // Combine local directions to give an overall global direction
     this->GetGlobalDirection(dTdL1, dTdL2, direction);
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::ThreeDSlidingFitResult::GetGlobalFitPosition	(	const float	rL,
		pandora::CartesianVector &	position
	)		const

Get global fit position for a given longitudinal coordinate.

Parameters

rL	the longitudinal coordinate
position	the fitted position at these coordinates

Returns: status code, faster than throwing in regular use-cases

Definition at line 121 of file LArThreeDSlidingFitResult.cc.

 {
     // Check that input coordinates are between first and last layers
     const int layer1(m_firstFitResult.GetLayer(rL));
     const int layer2(m_secondFitResult.GetLayer(rL));
 
     if (std::min(layer1, layer2) < m_minLayer || std::max(layer1, layer2) > m_maxLayer)
         return STATUS_CODE_INVALID_PARAMETER;
 
     // Get local positions from each sliding fit (TODO: Make this more efficient)
     CartesianVector firstPosition(0.f, 0.f, 0.f), secondPosition(0.f, 0.f, 0.f);
     const StatusCode statusCode1(m_firstFitResult.GetGlobalFitPosition(rL, firstPosition));
 
     if (STATUS_CODE_SUCCESS != statusCode1)
         return statusCode1;
 
     const StatusCode statusCode2(m_secondFitResult.GetGlobalFitPosition(rL, secondPosition));
 
     if (STATUS_CODE_SUCCESS != statusCode2)
         return statusCode2;
 
     float rL1(0.f), rT1(0.f), rL2(0.f), rT2(0.f);
     m_firstFitResult.GetLocalPosition(firstPosition, rL1, rT1);
     m_secondFitResult.GetLocalPosition(secondPosition, rL2, rT2);
 
     // Combine local positions to give an overall global direction
     this->GetGlobalPosition(rL, rT1, rT2, position);
 
     return STATUS_CODE_SUCCESS;
 }

const pandora::CartesianVector & lar_content::ThreeDSlidingFitResult::GetGlobalMaxLayerDirection ( ) const

inline

Get global direction corresponding to the fit result in maximum fit layer.

Returns: the position

Definition at line 285 of file LArThreeDSlidingFitResult.h.

 {
     return m_maxLayerDirection;
 }

const pandora::CartesianVector & lar_content::ThreeDSlidingFitResult::GetGlobalMaxLayerPosition ( ) const

inline

Get global position corresponding to the fit result in maximum fit layer.

Returns: the position

Definition at line 271 of file LArThreeDSlidingFitResult.h.

 {
     return m_maxLayerPosition;
 }

const pandora::CartesianVector & lar_content::ThreeDSlidingFitResult::GetGlobalMinLayerDirection ( ) const

inline

Get global direction corresponding to the fit result in minimum fit layer.

Returns: the position

Definition at line 278 of file LArThreeDSlidingFitResult.h.

 {
     return m_minLayerDirection;
 }

const pandora::CartesianVector & lar_content::ThreeDSlidingFitResult::GetGlobalMinLayerPosition ( ) const

inline

Get global position corresponding to the fit result in minimum fit layer.

Returns: the position

Definition at line 264 of file LArThreeDSlidingFitResult.h.

 {
     return m_minLayerPosition;
 }

void lar_content::ThreeDSlidingFitResult::GetGlobalPosition	(	const float	rL,
		const float	rT1,
		const float	rT2,
		pandora::CartesianVector &	position
	)		const

private

Get global coordinates for a given pair of sliding linear fit coordinates.

Parameters

rL	the longitudinal coordinate
rT1	the first transverse coordinate
rT2	the second transverse coordinate
position	to receive the position cartesian vector

Definition at line 187 of file LArThreeDSlidingFitResult.cc.

 {
     position = m_axisIntercept + m_axisDirection * rL + m_firstOrthoDirection * rT1 + m_secondOrthoDirection * rT2;
 }

float lar_content::ThreeDSlidingFitResult::GetLongitudinalDisplacement ( const pandora::CartesianVector & position ) const

Get longitudinal projection onto primary axis.

Parameters

position the input coordinates

Returns: the longitudinal distance along the axis direction from the axis intercept

Definition at line 114 of file LArThreeDSlidingFitResult.cc.

 {
     return m_axisDirection.GetDotProduct(position - m_axisIntercept);
 }

int lar_content::ThreeDSlidingFitResult::GetMaxLayer ( ) const

Get the maximum occupied layer in the sliding fit.

Parameters

the	maximum occupied layer in the sliding fit

Definition at line 74 of file LArThreeDSlidingFitResult.cc.

 {
     const int firstLayer(m_firstFitResult.GetMaxLayer());
     const int secondLayer(m_secondFitResult.GetMaxLayer());
 
     return std::max(firstLayer, secondLayer);
 }

float lar_content::ThreeDSlidingFitResult::GetMaxLayerRms ( ) const

Get rms at maximum layer.

Returns: the rms

Definition at line 94 of file LArThreeDSlidingFitResult.cc.

 {
     const float firstRms(m_firstFitResult.GetMaxLayerRms());
     const float secondRms(m_secondFitResult.GetMaxLayerRms());
 
     return std::sqrt(firstRms * firstRms + secondRms * secondRms);
 }

int lar_content::ThreeDSlidingFitResult::GetMinLayer ( ) const

Get the minimum occupied layer in the sliding fit.

Parameters

the	minimum occupied layer in the sliding fit

Definition at line 64 of file LArThreeDSlidingFitResult.cc.

 {
     const int firstLayer(m_firstFitResult.GetMinLayer());
     const int secondLayer(m_secondFitResult.GetMinLayer());
 
     return std::min(firstLayer, secondLayer);
 }

float lar_content::ThreeDSlidingFitResult::GetMinLayerRms ( ) const

Get rms at minimum layer.

Returns: the rms

Definition at line 84 of file LArThreeDSlidingFitResult.cc.

 {
     const float firstRms(m_firstFitResult.GetMinLayerRms());
     const float secondRms(m_secondFitResult.GetMinLayerRms());
 
     return std::sqrt(firstRms * firstRms + secondRms * secondRms);
 }

static pandora::TrackState lar_content::ThreeDSlidingFitResult::GetPrimaryAxis	(	const pandora::Cluster *const	pCluster,
		const float	slidingFitLayerPitch
	)

staticprivate

Calculate the position and direction of the primary axis.

Parameters

pCluster	the address of the input cluster
slidingFitLayerPitch	the sliding fit z pitch, units cm

Returns: pandora::TrackState object containing the position and direction

static pandora::TrackState lar_content::ThreeDSlidingFitResult::GetPrimaryAxis	(	const pandora::CartesianPointVector *const	pPointVector,
		const float	slidingFitLayerPitch
	)

staticprivate

Calculate the position and direction of the primary axis.

Parameters

pPointVector	the address of the input point vector
slidingFitLayerPitch	the sliding fit z pitch, units cm

Returns: pandora::TrackState object containing the position and direction

const TwoDSlidingFitResult & lar_content::ThreeDSlidingFitResult::GetSecondFitResult ( ) const

inline

Get the second sliding fit result for this cluster.

Returns: the second sliding fit result for this cluster

Definition at line 257 of file LArThreeDSlidingFitResult.h.

 {
     return m_secondFitResult;
 }

CartesianVector lar_content::ThreeDSlidingFitResult::GetSeedDirection ( const pandora::CartesianVector & axisDirection )

staticprivate

Generate a seed vector to be used in calculating the orthogonal axes.

Parameters

axisDirection the primary axis

Returns: the seed direction vector

Definition at line 245 of file LArThreeDSlidingFitResult.cc.

 {
     const float px(std::fabs(axisDirection.GetX()));
     const float py(std::fabs(axisDirection.GetY()));
     const float pz(std::fabs(axisDirection.GetZ()));
 
     if (px < std::min(py, pz) + std::numeric_limits<float>::epsilon())
     {
         return CartesianVector(1.f, 0.f, 0.f);
     }
 
     if (py < std::min(pz, px) + std::numeric_limits<float>::epsilon())
     {
         return CartesianVector(0.f, 1.f, 0.f);
     }
 
     if (pz < std::min(px, py) + std::numeric_limits<float>::epsilon())
     {
         return CartesianVector(0.f, 0.f, 1.f);
     }
 
     throw StatusCodeException(STATUS_CODE_FAILURE);
 }

Member Data Documentation

const pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_axisDirection

private

The axis direction vector.

Definition at line 216 of file LArThreeDSlidingFitResult.h.

const pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_axisIntercept

private

The axis intercept position.

Definition at line 215 of file LArThreeDSlidingFitResult.h.

const TwoDSlidingFitResult lar_content::ThreeDSlidingFitResult::m_firstFitResult

private

The first sliding fit result.

Definition at line 219 of file LArThreeDSlidingFitResult.h.

const pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_firstOrthoDirection

private

The orthogonal direction vector.

Definition at line 217 of file LArThreeDSlidingFitResult.h.

const int lar_content::ThreeDSlidingFitResult::m_maxLayer

private

The maximum combined layer.

Definition at line 222 of file LArThreeDSlidingFitResult.h.

pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_maxLayerDirection

private

The global direction at the maximum combined layer.

Definition at line 227 of file LArThreeDSlidingFitResult.h.

pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_maxLayerPosition

private

The global position at the maximum combined layer.

Definition at line 225 of file LArThreeDSlidingFitResult.h.

const int lar_content::ThreeDSlidingFitResult::m_minLayer

private

The minimum combined layer.

Definition at line 221 of file LArThreeDSlidingFitResult.h.

pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_minLayerDirection

private

The global direction at the minimum combined layer.

Definition at line 226 of file LArThreeDSlidingFitResult.h.

pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_minLayerPosition

private

The global position at the minimum combined layer.

Definition at line 224 of file LArThreeDSlidingFitResult.h.

const pandora::TrackState lar_content::ThreeDSlidingFitResult::m_primaryAxis

private

The primary axis position and direction.

Definition at line 214 of file LArThreeDSlidingFitResult.h.

const TwoDSlidingFitResult lar_content::ThreeDSlidingFitResult::m_secondFitResult

private

The second sliding fit result.

Definition at line 220 of file LArThreeDSlidingFitResult.h.

const pandora::CartesianVector lar_content::ThreeDSlidingFitResult::m_secondOrthoDirection

private

The orthogonal direction vector.

Definition at line 218 of file LArThreeDSlidingFitResult.h.

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation