lar_content::TwoDSlidingFitResult Class Reference

TwoDSlidingFitResult class. More...

#include <LArTwoDSlidingFitResult.h>

Public Member Functions
template<typename T >
	TwoDSlidingFitResult (const T *const pT, const unsigned int layerFitHalfWindow, const float layerPitch, const float axisDeviationLimitForHitDivision=0.95f)
	Constructor using internal definition of primary axis. More...
template<typename T >
	TwoDSlidingFitResult (const T *const pT, const unsigned int layerFitHalfWindow, const float layerPitch, const pandora::CartesianVector &axisIntercept, const pandora::CartesianVector &axisDirection, const pandora::CartesianVector &orthoDirection, const float axisDeviationLimitForHitDivision=0.95f)
	Constructor using specified primary axis. The orthogonal axis must be perpendicular to the primary axis. More...
	TwoDSlidingFitResult (const unsigned int layerFitHalfWindow, const float layerPitch, const pandora::CartesianVector &axisIntercept, const pandora::CartesianVector &axisDirection, const pandora::CartesianVector &orthoDirection, const LayerFitContributionMap &layerFitContributionMap)
	Constructor using specified primary axis and layer fit contribution map. User is responsible for ensuring that z-pitch, axis intercept and axis direction agree with calculations used to fill the layer fit contribution map. The orthogonal axis must be perpendicular to the primary axis. More...
const pandora::Cluster *	GetCluster () const
	Get the address of the cluster, if originally provided. More...
unsigned int	GetLayerFitHalfWindow () const
	Get the layer fit half window. More...
float	GetLayerPitch () const
	Get the layer pitch, units cm. More...
const pandora::CartesianVector &	GetAxisIntercept () const
	Get the axis intercept position. More...
const pandora::CartesianVector &	GetAxisDirection () const
	Get the axis direction vector. More...
const pandora::CartesianVector &	GetOrthoDirection () const
	Get the orthogonal direction vector. More...
const LayerFitResultMap &	GetLayerFitResultMap () const
	Get the layer fit result map. More...
const LayerFitContributionMap &	GetLayerFitContributionMap () const
	Get the layer fit contribution map. More...
const FitSegmentList &	GetFitSegmentList () const
	Get the fit segment list. More...
float	GetLayerFitHalfWindowLength () const
	Get the layer fit half window length. 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...
void	GetMinAndMaxX (float &minX, float &maxX) const
	Get the minimum and maximum x coordinates associated with the sliding fit. More...
void	GetMinAndMaxZ (float &minZ, float &maxZ) const
	Get the minimum and maximum z coordinates associated with the sliding fit. More...
int	GetLayer (const float rL) const
	Get layer number for given sliding linear fit longitudinal coordinate. More...
float	GetL (const int layer) const
	Get longitudinal coordinate for a given sliding linear fit layer number. More...
void	GetLocalPosition (const pandora::CartesianVector &position, float &rL, float &rT) const
	Get local sliding fit coordinates for a given global position. More...
void	GetLocalDirection (const pandora::CartesianVector &direction, float &dTdL) const
	Get local sliding fit gradient for a given global direction. More...
void	GetGlobalPosition (const float rL, const float rT, pandora::CartesianVector &position) const
	Get global coordinates for given sliding linear fit coordinates. More...
void	GetGlobalDirection (const float dTdL, pandora::CartesianVector &direction) const
	Get global direction coordinates for given sliding linear fit gradient. More...
pandora::CartesianVector	GetGlobalMinLayerPosition () const
	Get global position corresponding to the fit result in minimum fit layer. More...
pandora::CartesianVector	GetGlobalMaxLayerPosition () const
	Get global position corresponding to the fit result in maximum fit layer. More...
pandora::CartesianVector	GetGlobalMinLayerDirection () const
	Get global direction corresponding to the fit result in minimum fit layer. More...
pandora::CartesianVector	GetGlobalMaxLayerDirection () const
	Get global direction corresponding to the fit result in maximum fit layer. 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	GetCosScatteringAngle (const float rL) const
	Get scattering angle for a given longitudinal coordinate. 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...
pandora::StatusCode	GetGlobalFitPositionAtX (const float x, pandora::CartesianVector &position) const
	Get global fit position for a given input x coordinate. More...
pandora::StatusCode	GetGlobalFitDirectionAtX (const float x, pandora::CartesianVector &direction) const
	Get global fit direction for a given input x coordinate. More...
pandora::StatusCode	GetGlobalFitProjection (const pandora::CartesianVector &inputPosition, pandora::CartesianVector &projectedPosition) const
	Get projected position on global fit for a given position vector. More...
pandora::StatusCode	GetGlobalFitPositionListAtX (const float x, pandora::CartesianPointVector &positionList) const
	Get a list of projected positions for a given input x coordinate. More...
pandora::StatusCode	GetTransverseProjection (const float x, const FitSegment &fitSegment, pandora::CartesianVector &position) const
	Get projected position for a given input x coordinate and fit segment. More...
pandora::StatusCode	GetTransverseProjection (const float x, const FitSegment &fitSegment, pandora::CartesianVector &position, pandora::CartesianVector &direction) const
	Get projected position and direction for a given input x coordinate and fit segment. More...
pandora::StatusCode	GetExtrapolatedPosition (const float rL, pandora::CartesianVector &position) const
	Get extrapolated position (beyond span) for a given input coordinate. More...
pandora::StatusCode	GetExtrapolatedDirection (const float rL, pandora::CartesianVector &direction) const
	Get extrapolated direction (beyond span) for a given input coordinate. More...
pandora::StatusCode	GetExtrapolatedPositionAtX (const float x, pandora::CartesianVector &position) const
	Get extrapolated position (beyond span) for a given input x coordinate. More...
const FitSegment &	GetFitSegment (const float rL) const
	Get fit segment for a given longitudinal coordinate. More...
template<>
	TwoDSlidingFitResult (const Cluster *const pCluster, const unsigned int layerFitHalfWindow, const float layerPitch, const float axisDeviationLimitForHitDivision)
template<>
	TwoDSlidingFitResult (const CartesianPointVector *const pPointVector, const unsigned int layerFitHalfWindow, const float layerPitch, const float)
template<>
	TwoDSlidingFitResult (const Cluster *const pCluster, const unsigned int layerFitHalfWindow, const float layerPitch, const CartesianVector &axisIntercept, const CartesianVector &axisDirection, const CartesianVector &orthoDirection, const float axisDeviationLimitForHitDivision)
template<>
	TwoDSlidingFitResult (const CartesianPointVector *const pPointVector, const unsigned int layerFitHalfWindow, const float layerPitch, const CartesianVector &axisIntercept, const CartesianVector &axisDirection, const CartesianVector &orthoDirection, const float)

Private Member Functions
void	CalculateAxes (const pandora::CartesianPointVector &coordinateVector, const float layerPitch)
	Calculate the longitudinal and transverse axes. More...
void	FillLayerFitContributionMap (const pandora::CartesianPointVector &coordinateVector)
	Fill the layer fit contribution map. More...
void	PerformSlidingLinearFit ()
	Perform the sliding linear fit. More...
void	FindSlidingFitSegments ()
	Find sliding fit segments; sections with tramsverse direction. More...
void	GetMinAndMaxCoordinate (const bool isX, float &min, float &max) const
	Get the minimum and maximum x or z coordinates associated with the sliding fit. More...
pandora::CartesianVector	GetGlobalFitPosition (const LayerInterpolation &layerInterpolation) const
	Interpolate a position between two layers. More...
pandora::CartesianVector	GetGlobalFitDirection (const LayerInterpolation &layerInterpolation) const
	Interpolate a direction between two layers. More...
float	GetFitRms (const LayerInterpolation &layerInterpolation) const
	Interpolate a rms between two layers. More...
pandora::StatusCode	LongitudinalInterpolation (const float rL, LayerInterpolation &layerInterpolation) const
	Get the pair of layers surrounding a specified longitudinal position. More...
pandora::StatusCode	TransverseInterpolation (const float x, const FitSegment &fitSegment, LayerInterpolation &layerInterpolation) const
	Get the surrounding pair of layers for a specified transverse position and fit segment. More...
pandora::StatusCode	TransverseInterpolation (const float x, LayerInterpolationList &layerInterpolationList) const
	Get the a list of surrounding layer pairs for a specified transverse position. More...
pandora::StatusCode	GetLongitudinalSurroundingLayers (const float rL, LayerFitResultMap::const_iterator &firstLayerIter, LayerFitResultMap::const_iterator &secondLayerIter) const
	Get iterators for layers surrounding the specified longitudinal position. More...
pandora::StatusCode	GetTransverseSurroundingLayers (const float x, const int minLayer, const int maxLayer, LayerFitResultMap::const_iterator &firstLayerIter, LayerFitResultMap::const_iterator &secondLayerIter) const
	Get iterators for layers surrounding a specified transverse position. More...
void	GetLongitudinalInterpolationWeights (const float rL, const LayerFitResultMap::const_iterator &firstLayerIter, const LayerFitResultMap::const_iterator &secondLayerIter, double &firstWeight, double &secondWeight) const
	Get interpolation weights for layers surrounding a specified longitudinal position. More...
void	GetTransverseInterpolationWeights (const float x, const LayerFitResultMap::const_iterator &firstLayerIter, const LayerFitResultMap::const_iterator &secondLayerIter, double &firstWeight, double &secondWeight) const
	Get interpolation weights for layers surrounding a specified transverse position. More...

Private Attributes
const pandora::Cluster *	m_pCluster
	The address of the cluster. More...
unsigned int	m_layerFitHalfWindow
	The layer fit half window. More...
float	m_layerPitch
	The layer pitch, units cm. More...
pandora::CartesianVector	m_axisIntercept
	The axis intercept position. More...
pandora::CartesianVector	m_axisDirection
	The axis direction vector. More...
pandora::CartesianVector	m_orthoDirection
	The orthogonal direction vector. More...
LayerFitResultMap	m_layerFitResultMap
	The layer fit result map. More...
LayerFitContributionMap	m_layerFitContributionMap
	The layer fit contribution map. More...
FitSegmentList	m_fitSegmentList
	The fit segment list. More...

Detailed Description

TwoDSlidingFitResult class.

Definition at line 23 of file LArTwoDSlidingFitResult.h.

Constructor & Destructor Documentation

template<typename T >

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const T *const	pT,
		const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const float	axisDeviationLimitForHitDivision = 0.95f
	)

Constructor using internal definition of primary axis.

Parameters

pT	describing the positions to be fitted
layerFitHalfWindow	the layer fit half window
layerPitch	the layer pitch, units cm
axisDeviationLimitForHitDivision	the value of the cosine of the opening angle between the principal axis and xAxis, above which cluster hits are broken into their constituent hits - only used with cluster input

template<typename T >

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const T *const	pT,
		const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const pandora::CartesianVector &	axisIntercept,
		const pandora::CartesianVector &	axisDirection,
		const pandora::CartesianVector &	orthoDirection,
		const float	axisDeviationLimitForHitDivision = 0.95f
	)

Constructor using specified primary axis. The orthogonal axis must be perpendicular to the primary axis.

Parameters

pT	describing the positions to be fitted
layerFitHalfWindow	the layer fit half window
layerPitch	the layer pitch, units cm
axisIntercept	the axis intercept position
axisDirection	the axis direction vector
orthoDirection	the orthogonal direction vector
axisDeviationLimitForHitDivision	the value of the cosine of the opening angle between the principal axis and xAxis, above which cluster hits are broken into their constituent hits - only used with cluster input

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const pandora::CartesianVector &	axisIntercept,
		const pandora::CartesianVector &	axisDirection,
		const pandora::CartesianVector &	orthoDirection,
		const LayerFitContributionMap &	layerFitContributionMap
	)

Constructor using specified primary axis and layer fit contribution map. User is responsible for ensuring that z-pitch, axis intercept and axis direction agree with calculations used to fill the layer fit contribution map. The orthogonal axis must be perpendicular to the primary axis.

Parameters

layerFitHalfWindow	the layer fit half window
layerPitch	the layer pitch, units cm
axisIntercept	the axis intercept position
axisDirection	the axis direction vector
orthoDirection	the orthogonal direction vector
layerFitContributionMap	the layer fit contribution map

template<>

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const Cluster *const	pCluster,
		const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const float	axisDeviationLimitForHitDivision
	)

Definition at line 26 of file LArTwoDSlidingFitResult.cc.

                                                  :
    m_pCluster(pCluster),
    m_layerFitHalfWindow(layerFitHalfWindow),
    m_layerPitch(layerPitch),
    m_axisIntercept(0.f, 0.f, 0.f),
    m_axisDirection(0.f, 0.f, 0.f),
    m_orthoDirection(0.f, 0.f, 0.f)
{
    CartesianPointVector pointVector;
    LArClusterHelper::GetCoordinateVector(pCluster, pointVector);

    this->CalculateAxes(pointVector, layerPitch);

    const CartesianVector xAxis(1.f, 0.f, 0.f);
    const float cosOpeningAngle(xAxis.GetCosOpeningAngle(m_axisDirection));

    if (std::fabs(cosOpeningAngle) < axisDeviationLimitForHitDivision)
    {
        this->FillLayerFitContributionMap(pointVector);
    }
    else
    {
        // TODO Refactor hit splitting and ensure all parameters configurable
        LArHitWidthHelper::ConstituentHitVector constituentHitVector(LArHitWidthHelper::GetConstituentHits(pCluster, 0.5f, 1.f, true));
        const CartesianPointVector constituentHitPointVector(LArHitWidthHelper::GetConstituentHitPositionVector(constituentHitVector));
        this->FillLayerFitContributionMap(constituentHitPointVector);
    }

    this->PerformSlidingLinearFit();
    this->FindSlidingFitSegments();
}

template<>

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const CartesianPointVector *const	pPointVector,
		const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const float
	)

Definition at line 60 of file LArTwoDSlidingFitResult.cc.

                                           :
    m_pCluster(nullptr),
    m_layerFitHalfWindow(layerFitHalfWindow),
    m_layerPitch(layerPitch),
    m_axisIntercept(0.f, 0.f, 0.f),
    m_axisDirection(0.f, 0.f, 0.f),
    m_orthoDirection(0.f, 0.f, 0.f)
{
    this->CalculateAxes(*pPointVector, layerPitch);
    this->FillLayerFitContributionMap(*pPointVector);
    this->PerformSlidingLinearFit();
    this->FindSlidingFitSegments();
}

template<>

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const Cluster *const	pCluster,
		const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const CartesianVector &	axisIntercept,
		const CartesianVector &	axisDirection,
		const CartesianVector &	orthoDirection,
		const float	axisDeviationLimitForHitDivision
	)

Definition at line 78 of file LArTwoDSlidingFitResult.cc.

                                                  :
    m_pCluster(pCluster),
    m_layerFitHalfWindow(layerFitHalfWindow),
    m_layerPitch(layerPitch),
    m_axisIntercept(axisIntercept),
    m_axisDirection(axisDirection),
    m_orthoDirection(orthoDirection)
{
    const CartesianVector xAxis(1.f, 0.f, 0.f);
    const float cosOpeningAngle(xAxis.GetCosOpeningAngle(m_axisDirection));

    if (std::fabs(cosOpeningAngle) < axisDeviationLimitForHitDivision)
    {
        CartesianPointVector pointVector;
        LArClusterHelper::GetCoordinateVector(pCluster, pointVector);
        this->FillLayerFitContributionMap(pointVector);
    }
    else
    {
        // TODO Refactor hit splitting and ensure all parameters configurable
        LArHitWidthHelper::ConstituentHitVector constituentHitVector(LArHitWidthHelper::GetConstituentHits(pCluster, 0.5f, 1.f, true));
        const CartesianPointVector constituentHitPointVector(LArHitWidthHelper::GetConstituentHitPositionVector(constituentHitVector));
        this->FillLayerFitContributionMap(constituentHitPointVector);
    }

    this->PerformSlidingLinearFit();
    this->FindSlidingFitSegments();
}

template<>

lar_content::TwoDSlidingFitResult::TwoDSlidingFitResult	(	const CartesianPointVector *const	pPointVector,
		const unsigned int	layerFitHalfWindow,
		const float	layerPitch,
		const CartesianVector &	axisIntercept,
		const CartesianVector &	axisDirection,
		const CartesianVector &	orthoDirection,
		const float
	)

Definition at line 110 of file LArTwoDSlidingFitResult.cc.

                                                          :
    m_pCluster(nullptr),
    m_layerFitHalfWindow(layerFitHalfWindow),
    m_layerPitch(layerPitch),
    m_axisIntercept(axisIntercept),
    m_axisDirection(axisDirection),
    m_orthoDirection(orthoDirection)
{
    this->FillLayerFitContributionMap(*pPointVector);
    this->PerformSlidingLinearFit();
    this->FindSlidingFitSegments();
}

Member Function Documentation

void lar_content::TwoDSlidingFitResult::CalculateAxes ( const pandora::CartesianPointVector &  coordinateVector, const float  layerPitch  )

private

Calculate the longitudinal and transverse axes.

Definition at line 588 of file LArTwoDSlidingFitResult.cc.

{
    if (coordinateVector.size() < 2)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    CartesianVector centroid(0.f, 0.f, 0.f);
    LArPcaHelper::EigenVectors eigenVecs;
    LArPcaHelper::EigenValues eigenValues(0.f, 0.f, 0.f);
    LArPcaHelper::RunPca(coordinateVector, centroid, eigenValues, eigenVecs);

    float minProjection(std::numeric_limits<float>::max());
    CartesianVector fitDirection(eigenVecs.at(0));

    // ATTN TwoDSlidingFitResult convention is to point in direction of increasing z
    if (fitDirection.GetZ() < 0.f)
        fitDirection *= -1.f;

    for (const CartesianVector &coordinate : coordinateVector)
        minProjection = std::min(minProjection, fitDirection.GetDotProduct(coordinate - centroid));

    // Define layers based on centroid rather than individual extremal hits
    const float fitProjection(layerPitch * std::floor(minProjection / layerPitch));

    m_axisIntercept = centroid + (fitDirection * fitProjection);
    m_axisDirection = fitDirection;

    // Use y-axis to generate an orthogonal axis (assuming that cluster occupies X-Z plane)
    CartesianVector yAxis(0.f, 1.f, 0.f);
    m_orthoDirection = yAxis.GetCrossProduct(m_axisDirection).GetUnitVector();
}

void lar_content::TwoDSlidingFitResult::FillLayerFitContributionMap ( const pandora::CartesianPointVector &  coordinateVector )

private

Fill the layer fit contribution map.

Definition at line 621 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerPitch < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    if ((m_axisDirection.GetMagnitudeSquared() < std::numeric_limits<float>::epsilon()) ||
        (m_orthoDirection.GetMagnitudeSquared() < std::numeric_limits<float>::epsilon()))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    if (!m_layerFitContributionMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    for (CartesianPointVector::const_iterator iter = coordinateVector.begin(), iterEnd = coordinateVector.end(); iter != iterEnd; ++iter)
    {
        float rL(0.f), rT(0.f);
        this->GetLocalPosition(*iter, rL, rT);
        m_layerFitContributionMap[this->GetLayer(rL)].AddPoint(rL, rT);
    }
}

void lar_content::TwoDSlidingFitResult::FindSlidingFitSegments ( )

private

Find sliding fit segments; sections with tramsverse direction.

Definition at line 744 of file LArTwoDSlidingFitResult.cc.

{
    if (!m_fitSegmentList.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    unsigned int nSustainedSteps(0);
    float sustainedDirectionStartX(0.f), sustainedDirectionEndX(0.f);

    CartesianVector previousPosition(0.f, 0.f, 0.f);
    TransverseDirection previousDirection(UNKNOWN), sustainedDirection(UNKNOWN);

    LayerFitResultMap::const_iterator sustainedDirectionStartIter, sustainedDirectionEndIter;
    const LayerFitResultMap &layerFitResultMap(this->GetLayerFitResultMap());

    for (LayerFitResultMap::const_iterator iter = layerFitResultMap.begin(), iterEnd = layerFitResultMap.end(); iter != iterEnd; ++iter)
    {
        CartesianVector position(0.f, 0.f, 0.f);
        this->GetGlobalPosition(iter->second.GetL(), iter->second.GetFitT(), position);

        // TODO currentDirection could also be UNCHANGED_IN_X
        const TransverseDirection currentDirection(((position - previousPosition).GetX() > 0.f) ? POSITIVE_IN_X : NEGATIVE_IN_X);

        if (previousDirection == currentDirection)
        {
            ++nSustainedSteps;

            if (nSustainedSteps > 2)
            {
                sustainedDirection = currentDirection;
                sustainedDirectionEndIter = iter;
                sustainedDirectionEndX = position.GetX();
            }
        }
        else
        {
            if ((POSITIVE_IN_X == sustainedDirection) || (NEGATIVE_IN_X == sustainedDirection))
                m_fitSegmentList.push_back(FitSegment(
                    sustainedDirectionStartIter->first, sustainedDirectionEndIter->first, sustainedDirectionStartX, sustainedDirectionEndX));

            nSustainedSteps = 0;
            sustainedDirection = UNKNOWN;
            sustainedDirectionStartIter = iter;
            sustainedDirectionStartX = position.GetX();
        }

        previousPosition = position;
        previousDirection = currentDirection;
    }

    if ((POSITIVE_IN_X == sustainedDirection) || (NEGATIVE_IN_X == sustainedDirection))
        m_fitSegmentList.push_back(
            FitSegment(sustainedDirectionStartIter->first, sustainedDirectionEndIter->first, sustainedDirectionStartX, sustainedDirectionEndX));
}

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

inline

Get the axis direction vector.

Returns

the axis direction vector

Definition at line 577 of file LArTwoDSlidingFitResult.h.

{
    return m_axisDirection;
}

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

inline

Get the axis intercept position.

Returns

the axis intercept position

Definition at line 570 of file LArTwoDSlidingFitResult.h.

{
    return m_axisIntercept;
}

const pandora::Cluster * lar_content::TwoDSlidingFitResult::GetCluster

(

)

const

Get the address of the cluster, if originally provided.

Returns

the address of the cluster

Exceptions

StatusCodeException

Definition at line 143 of file LArTwoDSlidingFitResult.cc.

{
    if (!m_pCluster)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    return m_pCluster;
}

float lar_content::TwoDSlidingFitResult::GetCosScatteringAngle

(

const float

rL

)

const

Get scattering angle for a given longitudinal coordinate.

Parameters

rL	the longitudinal coordinate

Definition at line 326 of file LArTwoDSlidingFitResult.cc.

{
    const float halfWindowLength(this->GetLayerFitHalfWindowLength());

    CartesianVector firstDirection(0.f, 0.f, 0.f);
    CartesianVector secondDirection(0.f, 0.f, 0.f);

    const StatusCode firstStatusCode(this->GetGlobalFitDirection(rL - halfWindowLength, firstDirection));
    const StatusCode secondStatusCode(this->GetGlobalFitDirection(rL + halfWindowLength, secondDirection));

    if (STATUS_CODE_SUCCESS != firstStatusCode)
        throw StatusCodeException(firstStatusCode);

    if (STATUS_CODE_SUCCESS != secondStatusCode)
        throw StatusCodeException(secondStatusCode);

    return firstDirection.GetDotProduct(secondDirection);
}

StatusCode lar_content::TwoDSlidingFitResult::GetExtrapolatedDirection	(	const float	rL,
		pandora::CartesianVector &	direction
	)		const

Get extrapolated direction (beyond span) for a given input coordinate.

Parameters

rL	the input coordinate
position	the extrapolated direction at these coordinates

Returns

status code, faster than throwing in regular use-cases

Definition at line 495 of file LArTwoDSlidingFitResult.cc.

{
    const StatusCode statusCode(this->GetGlobalFitDirection(rL, direction));

    if (STATUS_CODE_NOT_FOUND != statusCode)
        return statusCode;

    const int thisLayer(this->GetLayer(rL));
    const int minLayer(this->GetMinLayer());
    const int maxLayer(this->GetMaxLayer());

    if (thisLayer <= minLayer)
    {
        direction = this->GetGlobalMinLayerDirection();
    }
    else if (thisLayer >= maxLayer)
    {
        direction = this->GetGlobalMaxLayerDirection();
    }
    else
    {
        return STATUS_CODE_FAILURE;
    }

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitResult::GetExtrapolatedPosition	(	const float	rL,
		pandora::CartesianVector &	position
	)		const

Get extrapolated position (beyond span) for a given input coordinate.

Parameters

rL	the input coordinate
position	the extrapolated position at these coordinates

Returns

status code, faster than throwing in regular use-cases

Definition at line 466 of file LArTwoDSlidingFitResult.cc.

{
    const StatusCode statusCode(this->GetGlobalFitPosition(rL, position));

    if (STATUS_CODE_NOT_FOUND != statusCode)
        return statusCode;

    const int thisLayer(this->GetLayer(rL));
    const int minLayer(this->GetMinLayer());
    const int maxLayer(this->GetMaxLayer());

    if (thisLayer <= minLayer)
    {
        position = (this->GetGlobalMinLayerPosition() + this->GetGlobalMinLayerDirection() * (rL - this->GetL(minLayer)));
    }
    else if (thisLayer >= maxLayer)
    {
        position = (this->GetGlobalMaxLayerPosition() + this->GetGlobalMaxLayerDirection() * (rL - this->GetL(maxLayer)));
    }
    else
    {
        return STATUS_CODE_FAILURE;
    }

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitResult::GetExtrapolatedPositionAtX	(	const float	x,
		pandora::CartesianVector &	position
	)		const

Get extrapolated position (beyond span) for a given input x coordinate.

Parameters

x	the input coordinate
position	the extrapolated position at these coordinates

Returns

status code, faster than throwing in regular use-cases

Definition at line 524 of file LArTwoDSlidingFitResult.cc.

{
    const StatusCode statusCode(this->GetGlobalFitPositionAtX(x, position));

    if (STATUS_CODE_NOT_FOUND != statusCode)
        return statusCode;

    const float minLayerX(this->GetGlobalMinLayerPosition().GetX());
    const float maxLayerX(this->GetGlobalMaxLayerPosition().GetX());

    const int minLayer(this->GetMinLayer());
    const int maxLayer(this->GetMaxLayer());

    const int innerLayer((minLayerX < maxLayerX) ? minLayer : maxLayer);
    const int outerLayer((minLayerX < maxLayerX) ? maxLayer : minLayer);

    const CartesianVector innerVertex((innerLayer == minLayer) ? this->GetGlobalMinLayerPosition() : this->GetGlobalMaxLayerPosition());
    const CartesianVector innerDirection((innerLayer == minLayer) ? this->GetGlobalMinLayerDirection() * -1.f : this->GetGlobalMaxLayerDirection());

    const CartesianVector outerVertex((outerLayer == minLayer) ? this->GetGlobalMinLayerPosition() : this->GetGlobalMaxLayerPosition());
    const CartesianVector outerDirection((outerLayer == minLayer) ? this->GetGlobalMinLayerDirection() * -1.f : this->GetGlobalMaxLayerDirection());

    if (innerDirection.GetX() > -std::numeric_limits<float>::epsilon() || outerDirection.GetX() < +std::numeric_limits<float>::epsilon() ||
        outerVertex.GetX() - innerVertex.GetX() < +std::numeric_limits<float>::epsilon())
    {
        return STATUS_CODE_NOT_FOUND;
    }
    else if (x >= outerVertex.GetX())
    {
        position = outerVertex + outerDirection * ((x - outerVertex.GetX()) / outerDirection.GetX());
    }
    else if (x <= innerVertex.GetX())
    {
        position = innerVertex + innerDirection * ((x - innerVertex.GetX()) / innerDirection.GetX());
    }
    else
    {
        return STATUS_CODE_NOT_FOUND;
    }

    // TODO How to assign an uncertainty on the extrapolated position?
    return STATUS_CODE_SUCCESS;
}

float lar_content::TwoDSlidingFitResult::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 313 of file LArTwoDSlidingFitResult.cc.

{
    LayerInterpolation layerInterpolation;
    const StatusCode statusCode(this->LongitudinalInterpolation(rL, layerInterpolation));

    if (STATUS_CODE_SUCCESS != statusCode)
        throw StatusCodeException(statusCode);

    return this->GetFitRms(layerInterpolation);
}

float lar_content::TwoDSlidingFitResult::GetFitRms ( const LayerInterpolation &  layerInterpolation ) const

private

Interpolate a rms between two layers.

Parameters

layerInterpolation

the pair of surrounding layers

Returns

the interpolated rms

Definition at line 876 of file LArTwoDSlidingFitResult.cc.

{
    const LayerFitResultMap::const_iterator firstLayerIter(layerInterpolation.GetStartLayerIter());
    const LayerFitResultMap::const_iterator secondLayerIter(layerInterpolation.GetEndLayerIter());

    const float firstWeight(layerInterpolation.GetStartLayerWeight());
    const float secondWeight(layerInterpolation.GetEndLayerWeight());

    if (m_layerFitResultMap.end() == firstLayerIter || m_layerFitResultMap.end() == secondLayerIter)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    const float firstLayerRms(firstLayerIter->second.GetRms());

    if (firstLayerIter == secondLayerIter)
        return firstLayerRms;

    const float secondLayerRms(secondLayerIter->second.GetRms());

    if (firstWeight + secondWeight < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    return ((firstLayerRms * firstWeight + secondLayerRms * secondWeight) / (firstWeight + secondWeight));
}

const FitSegment & lar_content::TwoDSlidingFitResult::GetFitSegment

(

const float

rL

)

const

Get fit segment for a given longitudinal coordinate.

Parameters

rL	the longitudinal coordinate

Definition at line 570 of file LArTwoDSlidingFitResult.cc.

{
    int layer(this->GetLayer(rL));

    for (FitSegmentList::const_iterator iter = m_fitSegmentList.begin(), iterEnd = m_fitSegmentList.end(); iter != iterEnd; ++iter)
    {
        const FitSegment &fitSegment = *iter;

        if (layer >= fitSegment.GetStartLayer() && layer <= fitSegment.GetEndLayer())
            return fitSegment;
    }

    throw StatusCodeException(STATUS_CODE_NOT_FOUND);
}

const FitSegmentList & lar_content::TwoDSlidingFitResult::GetFitSegmentList ( ) const

inline

Get the fit segment list.

Returns

the fit segment list

Definition at line 605 of file LArTwoDSlidingFitResult.h.

{
    return m_fitSegmentList;
}

void lar_content::TwoDSlidingFitResult::GetGlobalDirection	(	const float	dTdL,
		pandora::CartesianVector &	direction
	)		const

Get global direction coordinates for given sliding linear fit gradient.

Parameters

dTdL	the transverse coordinate
direction	to receive the direction cartesian vector

Definition at line 227 of file LArTwoDSlidingFitResult.cc.

{
    const float pL(1.f / std::sqrt(1.f + dTdL * dTdL));
    const float pT(dTdL / std::sqrt(1.f + dTdL * dTdL));

    CartesianVector globalCoordinates(0.f, 0.f, 0.f);
    this->GetGlobalPosition(pL, pT, globalCoordinates);
    direction = (globalCoordinates - m_axisIntercept).GetUnitVector();
}

pandora::StatusCode lar_content::TwoDSlidingFitResult::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

CartesianVector lar_content::TwoDSlidingFitResult::GetGlobalFitDirection ( const LayerInterpolation &  layerInterpolation ) const

private

Interpolate a direction between two layers.

Parameters

layerInterpolation

the pair of surrounding layers

Returns

the interpolated direction

Definition at line 848 of file LArTwoDSlidingFitResult.cc.

{
    const LayerFitResultMap::const_iterator firstLayerIter(layerInterpolation.GetStartLayerIter());
    const LayerFitResultMap::const_iterator secondLayerIter(layerInterpolation.GetEndLayerIter());

    const float firstWeight(layerInterpolation.GetStartLayerWeight());
    const float secondWeight(layerInterpolation.GetEndLayerWeight());

    if (m_layerFitResultMap.end() == firstLayerIter || m_layerFitResultMap.end() == secondLayerIter)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    CartesianVector firstLayerDirection(0.f, 0.f, 0.f);
    this->GetGlobalDirection(firstLayerIter->second.GetGradient(), firstLayerDirection);

    if (firstLayerIter == secondLayerIter)
        return firstLayerDirection;

    CartesianVector secondLayerDirection(0.f, 0.f, 0.f);
    this->GetGlobalDirection(secondLayerIter->second.GetGradient(), secondLayerDirection);

    if (firstWeight + secondWeight < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    return ((firstLayerDirection * firstWeight + secondLayerDirection * secondWeight).GetUnitVector());
}

StatusCode lar_content::TwoDSlidingFitResult::GetGlobalFitDirectionAtX	(	const float	x,
		pandora::CartesianVector &	direction
	)		const

Get global fit direction for a given input x coordinate.

Parameters

x	the input coordinate
direction	the fitted direction at these coordinates

Returns

status code, faster than throwing in regular use-cases

Definition at line 392 of file LArTwoDSlidingFitResult.cc.

{
    LayerInterpolationList layerInterpolationList;
    const StatusCode statusCode(this->TransverseInterpolation(x, layerInterpolationList));

    if (STATUS_CODE_SUCCESS != statusCode)
        return statusCode;

    if (layerInterpolationList.size() != 1)
        return STATUS_CODE_NOT_FOUND;

    direction = this->GetGlobalFitDirection(layerInterpolationList.at(0));
    return STATUS_CODE_SUCCESS;
}

pandora::StatusCode lar_content::TwoDSlidingFitResult::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

CartesianVector lar_content::TwoDSlidingFitResult::GetGlobalFitPosition ( const LayerInterpolation &  layerInterpolation ) const

private

Interpolate a position between two layers.

Parameters

layerInterpolation

the pair of surrounding layers

Returns

the interpolated position

Definition at line 820 of file LArTwoDSlidingFitResult.cc.

{
    const LayerFitResultMap::const_iterator firstLayerIter(layerInterpolation.GetStartLayerIter());
    const LayerFitResultMap::const_iterator secondLayerIter(layerInterpolation.GetEndLayerIter());

    const float firstWeight(layerInterpolation.GetStartLayerWeight());
    const float secondWeight(layerInterpolation.GetEndLayerWeight());

    if (m_layerFitResultMap.end() == firstLayerIter || m_layerFitResultMap.end() == secondLayerIter)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    CartesianVector firstLayerPosition(0.f, 0.f, 0.f);
    this->GetGlobalPosition(firstLayerIter->second.GetL(), firstLayerIter->second.GetFitT(), firstLayerPosition);

    if (firstLayerIter == secondLayerIter)
        return firstLayerPosition;

    CartesianVector secondLayerPosition(0.f, 0.f, 0.f);
    this->GetGlobalPosition(secondLayerIter->second.GetL(), secondLayerIter->second.GetFitT(), secondLayerPosition);

    if (firstWeight + secondWeight < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    return ((firstLayerPosition * firstWeight + secondLayerPosition * secondWeight) * (1.f / (firstWeight + secondWeight)));
}

StatusCode lar_content::TwoDSlidingFitResult::GetGlobalFitPositionAtX	(	const float	x,
		pandora::CartesianVector &	position
	)		const

Get global fit position for a given input x coordinate.

Parameters

x	the input coordinate
position	the fitted position at these coordinates

Returns

status code, faster than throwing in regular use-cases

Definition at line 375 of file LArTwoDSlidingFitResult.cc.

{
    LayerInterpolationList layerInterpolationList;
    const StatusCode statusCode(this->TransverseInterpolation(x, layerInterpolationList));

    if (STATUS_CODE_SUCCESS != statusCode)
        return statusCode;

    if (layerInterpolationList.size() != 1)
        return STATUS_CODE_NOT_FOUND;

    position = this->GetGlobalFitPosition(layerInterpolationList.at(0));
    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitResult::GetGlobalFitPositionListAtX	(	const float	x,
		pandora::CartesianPointVector &	positionList
	)		const

Get a list of projected positions for a given input x coordinate.

Parameters

x	the input x coordinate
positionList	the output list of positions

Returns

status code, faster than throwing in regular use-cases

Definition at line 418 of file LArTwoDSlidingFitResult.cc.

{
    LayerInterpolationList layerInterpolationList;
    const StatusCode statusCode(this->TransverseInterpolation(x, layerInterpolationList));

    if (STATUS_CODE_SUCCESS != statusCode)
        return statusCode;

    for (LayerInterpolationList::const_iterator iter = layerInterpolationList.begin(), iterEnd = layerInterpolationList.end(); iter != iterEnd; ++iter)
    {
        positionList.push_back(this->GetGlobalFitPosition(*iter));
    }

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitResult::GetGlobalFitProjection	(	const pandora::CartesianVector &	inputPosition,
		pandora::CartesianVector &	projectedPosition
	)		const

Get projected position on global fit for a given position vector.

Parameters

inputPosition	the input coordinate
projectedPosition	the projected position on the global fit for these coordinates

Returns

status code, faster than throwing in regular use-cases

Definition at line 409 of file LArTwoDSlidingFitResult.cc.

{
    float rL(0.f), rT(0.f);
    this->GetLocalPosition(inputPosition, rL, rT);
    return this->GetGlobalFitPosition(rL, projectedPosition);
}

CartesianVector lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerDirection

(

)

const

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

Returns

the position

Definition at line 278 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_reverse_iterator iter = m_layerFitResultMap.rbegin();
    CartesianVector direction(0.f, 0.f, 0.f);
    this->GetGlobalDirection(iter->second.GetGradient(), direction);
    return direction;
}

CartesianVector lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition

(

)

const

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

Returns

the position

Definition at line 252 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_reverse_iterator iter = m_layerFitResultMap.rbegin();
    CartesianVector position(0.f, 0.f, 0.f);
    this->GetGlobalPosition(iter->second.GetL(), iter->second.GetFitT(), position);
    return position;
}

CartesianVector lar_content::TwoDSlidingFitResult::GetGlobalMinLayerDirection

(

)

const

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

Returns

the position

Definition at line 265 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_iterator iter = m_layerFitResultMap.begin();
    CartesianVector direction(0.f, 0.f, 0.f);
    this->GetGlobalDirection(iter->second.GetGradient(), direction);
    return direction;
}

CartesianVector lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition

(

)

const

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

Returns

the position

Definition at line 239 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_iterator iter = m_layerFitResultMap.begin();
    CartesianVector position(0.f, 0.f, 0.f);
    this->GetGlobalPosition(iter->second.GetL(), iter->second.GetFitT(), position);
    return position;
}

void lar_content::TwoDSlidingFitResult::GetGlobalPosition	(	const float	rL,
		const float	rT,
		pandora::CartesianVector &	position
	)		const

Get global coordinates for given sliding linear fit coordinates.

Parameters

rL	the longitudinal coordinate
rT	the transverse coordinate
position	to receive the position cartesian vector

Definition at line 220 of file LArTwoDSlidingFitResult.cc.

{
    position = m_axisIntercept + (m_axisDirection * rL) + (m_orthoDirection * rT);
}

float lar_content::TwoDSlidingFitResult::GetL

(

const int

layer

)

const

Get longitudinal coordinate for a given sliding linear fit layer number.

Parameters

layer

the layer number

Definition at line 190 of file LArTwoDSlidingFitResult.cc.

{
    return (static_cast<float>(layer) + 0.5f) * m_layerPitch;
}

int lar_content::TwoDSlidingFitResult::GetLayer

(

const float

rL

)

const

Get layer number for given sliding linear fit longitudinal coordinate.

Parameters

rL	the longitudinal coordinate

Definition at line 180 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerPitch < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    return static_cast<int>(std::floor(rL / m_layerPitch));
}

const LayerFitContributionMap & lar_content::TwoDSlidingFitResult::GetLayerFitContributionMap ( ) const

inline

Get the layer fit contribution map.

Returns

the layer fit contribution map

Definition at line 598 of file LArTwoDSlidingFitResult.h.

{
    return m_layerFitContributionMap;
}

unsigned int lar_content::TwoDSlidingFitResult::GetLayerFitHalfWindow ( ) const

inline

Get the layer fit half window.

Returns

the layer fit half window

Definition at line 556 of file LArTwoDSlidingFitResult.h.

{
    return m_layerFitHalfWindow;
}

float lar_content::TwoDSlidingFitResult::GetLayerFitHalfWindowLength

(

)

const

Get the layer fit half window length.

Returns

the layer fit half window length

Definition at line 153 of file LArTwoDSlidingFitResult.cc.

{
    return (static_cast<float>(m_layerFitHalfWindow)) * m_layerPitch;
}

const LayerFitResultMap & lar_content::TwoDSlidingFitResult::GetLayerFitResultMap ( ) const

inline

Get the layer fit result map.

Returns

the layer fit result map

Definition at line 591 of file LArTwoDSlidingFitResult.h.

{
    return m_layerFitResultMap;
}

float lar_content::TwoDSlidingFitResult::GetLayerPitch ( ) const

inline

Get the layer pitch, units cm.

Returns

the layer pitch

Definition at line 563 of file LArTwoDSlidingFitResult.h.

{
    return m_layerPitch;
}

void lar_content::TwoDSlidingFitResult::GetLocalDirection	(	const pandora::CartesianVector &	direction,
		float &	dTdL
	)		const

Get local sliding fit gradient for a given global direction.

Parameters

direction	the direction cartesian vector
dTdL	to receive the local gradient

Definition at line 207 of file LArTwoDSlidingFitResult.cc.

{
    float pL(0.f), pT(0.f);
    this->GetLocalPosition((direction + m_axisIntercept), pL, pT);

    if (std::fabs(pL) < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    dTdL = pT / pL;
}

void lar_content::TwoDSlidingFitResult::GetLocalPosition	(	const pandora::CartesianVector &	position,
		float &	rL,
		float &	rT
	)		const

Get local sliding fit coordinates for a given global position.

Parameters

position	the position cartesian vector
rL	to receive the longitudinal coordinate
rT	to receive the transverse coordinate

Definition at line 197 of file LArTwoDSlidingFitResult.cc.

{
    const CartesianVector displacement(position - m_axisIntercept);

    rL = displacement.GetDotProduct(m_axisDirection);
    rT = displacement.GetDotProduct(m_orthoDirection);
}

void lar_content::TwoDSlidingFitResult::GetLongitudinalInterpolationWeights ( const float  rL, const LayerFitResultMap::const_iterator &  firstLayerIter, const LayerFitResultMap::const_iterator &  secondLayerIter, double &  firstWeight, double &  secondWeight  ) const

private

Get interpolation weights for layers surrounding a specified longitudinal position.

Parameters

rL	the longitudinal coordinate
firstLayerIter	the iterator for the layer below the input coordinate
secondLayerIter	the iterator for the layer above the input coordinate
firstWeight	the weight assigned to the layer below the input coordinate
secondWeight	the weight assigned to the layer above the input coordinate

Definition at line 1102 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.end() == firstLayerIter || m_layerFitResultMap.end() == secondLayerIter)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    const double deltaL(rL - firstLayerIter->second.GetL());
    const double deltaLLayers(secondLayerIter->second.GetL() - firstLayerIter->second.GetL());

    if (std::fabs(deltaLLayers) > std::numeric_limits<float>::epsilon())
    {
        firstWeight = 1. - deltaL / deltaLLayers;
        secondWeight = deltaL / deltaLLayers;
    }
    else
    {
        firstWeight = 0.5;
        secondWeight = 0.5;
    }
}

StatusCode lar_content::TwoDSlidingFitResult::GetLongitudinalSurroundingLayers ( const float  rL, LayerFitResultMap::const_iterator &  firstLayerIter, LayerFitResultMap::const_iterator &  secondLayerIter  ) const

private

Get iterators for layers surrounding the specified longitudinal position.

Parameters

rL	the longitudinal coordinate
firstLayerIter	to receive the iterator for the layer just below the input coordinate
secondLayerIter	to receive the iterator for the layer just above the input coordinate

Returns

status code, faster than throwing in regular use-cases

Definition at line 961 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    // Get minimum, maximum and input layers
    const int minLayer(m_layerFitResultMap.begin()->first), maxLayer(m_layerFitResultMap.rbegin()->first);
    const int thisLayer(this->GetLayer(rL));

    // Allow special case of single-layer sliding fit result
    if (minLayer == thisLayer && thisLayer == maxLayer)
    {
        firstLayerIter = m_layerFitResultMap.find(minLayer);
        secondLayerIter = m_layerFitResultMap.find(maxLayer);
        return STATUS_CODE_SUCCESS;
    }

    // For multi-layer sliding fit result, set start layer and bail out if out of range
    const int startLayer((thisLayer >= maxLayer) ? thisLayer - 1 : thisLayer);

    if ((startLayer < minLayer) || (startLayer >= maxLayer))
        return STATUS_CODE_NOT_FOUND;

    // First layer iterator
    firstLayerIter = m_layerFitResultMap.end();

    for (int iLayer = startLayer; iLayer >= minLayer; --iLayer)
    {
        firstLayerIter = m_layerFitResultMap.find(iLayer);

        if (m_layerFitResultMap.end() != firstLayerIter)
            break;
    }

    if (m_layerFitResultMap.end() == firstLayerIter)
        return STATUS_CODE_NOT_FOUND;

    // Second layer iterator
    secondLayerIter = m_layerFitResultMap.end();

    for (int iLayer = startLayer + 1; iLayer <= maxLayer; ++iLayer)
    {
        secondLayerIter = m_layerFitResultMap.find(iLayer);

        if (m_layerFitResultMap.end() != secondLayerIter)
            break;
    }

    if (m_layerFitResultMap.end() == secondLayerIter)
        return STATUS_CODE_NOT_FOUND;

    return STATUS_CODE_SUCCESS;
}

int lar_content::TwoDSlidingFitResult::GetMaxLayer

(

)

const

Get the maximum occupied layer in the sliding fit.

Parameters

the	maximum occupied layer in the sliding fit

Definition at line 170 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    return m_layerFitResultMap.rbegin()->first;
}

float lar_content::TwoDSlidingFitResult::GetMaxLayerRms

(

)

const

Get rms at maximum layer.

Returns

the rms

Definition at line 302 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_reverse_iterator iter = m_layerFitResultMap.rbegin();
    return iter->second.GetRms();
}

void lar_content::TwoDSlidingFitResult::GetMinAndMaxCoordinate ( const bool  isX, float &  min, float &  max  ) const

private

Get the minimum and maximum x or z coordinates associated with the sliding fit.

Parameters

isX	whether to provide extremal x or z coordinates
to	receive the min coordinate value
to	receive the max coordinate value

Definition at line 800 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    min = std::numeric_limits<float>::max();
    max = -std::numeric_limits<float>::max();

    for (LayerFitResultMap::const_iterator iter = m_layerFitResultMap.begin(), iterEnd = m_layerFitResultMap.end(); iter != iterEnd; ++iter)
    {
        CartesianVector globalPosition(0.f, 0.f, 0.f);
        this->GetGlobalPosition(iter->second.GetL(), iter->second.GetFitT(), globalPosition);
        const float coordinate(isX ? globalPosition.GetX() : globalPosition.GetZ());
        min = std::min(min, coordinate);
        max = std::max(max, coordinate);
    }
}

void lar_content::TwoDSlidingFitResult::GetMinAndMaxX ( float &  minX, float &  maxX  ) const

inline

Get the minimum and maximum x coordinates associated with the sliding fit.

Parameters

to	receive the min x value
to	receive the max x value

Definition at line 612 of file LArTwoDSlidingFitResult.h.

{
    return this->GetMinAndMaxCoordinate(true, minX, maxX);
}

void lar_content::TwoDSlidingFitResult::GetMinAndMaxZ ( float &  minZ, float &  maxZ  ) const

inline

Get the minimum and maximum z coordinates associated with the sliding fit.

Parameters

to	receive the min z value
to	receive the max z value

Definition at line 619 of file LArTwoDSlidingFitResult.h.

{
    return this->GetMinAndMaxCoordinate(false, minZ, maxZ);
}

int lar_content::TwoDSlidingFitResult::GetMinLayer

(

)

const

Get the minimum occupied layer in the sliding fit.

Parameters

the	minimum occupied layer in the sliding fit

Definition at line 160 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    return m_layerFitResultMap.begin()->first;
}

float lar_content::TwoDSlidingFitResult::GetMinLayerRms

(

)

const

Get rms at minimum layer.

Returns

the rms

Definition at line 291 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_iterator iter = m_layerFitResultMap.begin();
    return iter->second.GetRms();
}

const pandora::CartesianVector & lar_content::TwoDSlidingFitResult::GetOrthoDirection ( ) const

inline

Get the orthogonal direction vector.

Returns

the orthogonal direction vector

Definition at line 584 of file LArTwoDSlidingFitResult.h.

{
    return m_orthoDirection;
}

void lar_content::TwoDSlidingFitResult::GetTransverseInterpolationWeights ( const float  x, const LayerFitResultMap::const_iterator &  firstLayerIter, const LayerFitResultMap::const_iterator &  secondLayerIter, double &  firstWeight, double &  secondWeight  ) const

private

Get interpolation weights for layers surrounding a specified transverse position.

Parameters

x	the transverse coordinate
firstLayerIter	the iterator for the layer below the input coordinate
secondLayerIter	the iterator for the layer above the input coordinate
firstWeight	the weight assigned to the layer below the input coordinate
firstWeight	the weight assigned to the layer above the input coordinate

Definition at line 1125 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.end() == firstLayerIter || m_layerFitResultMap.end() == secondLayerIter)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    CartesianVector firstLayerPosition(0.f, 0.f, 0.f);
    CartesianVector secondLayerPosition(0.f, 0.f, 0.f);

    this->GetGlobalPosition(firstLayerIter->second.GetL(), firstLayerIter->second.GetFitT(), firstLayerPosition);
    this->GetGlobalPosition(secondLayerIter->second.GetL(), secondLayerIter->second.GetFitT(), secondLayerPosition);

    const double deltaP(x - firstLayerPosition.GetX());
    const double deltaPLayers(secondLayerPosition.GetX() - firstLayerPosition.GetX());

    if (std::fabs(deltaPLayers) > std::numeric_limits<float>::epsilon())
    {
        firstWeight = 1. - deltaP / deltaPLayers;
        secondWeight = deltaP / deltaPLayers;
    }
    else
    {
        firstWeight = 0.5;
        secondWeight = 0.5;
    }
}

pandora::StatusCode lar_content::TwoDSlidingFitResult::GetTransverseProjection	(	const float	x,
		const FitSegment &	fitSegment,
		pandora::CartesianVector &	position
	)		const

Get projected position for a given input x coordinate and fit segment.

Parameters

x	the input x coordinate
fitSegment	the portion of sliding linear fit
position	the output position

Returns

status code, faster than throwing in regular use-cases

pandora::StatusCode lar_content::TwoDSlidingFitResult::GetTransverseProjection	(	const float	x,
		const FitSegment &	fitSegment,
		pandora::CartesianVector &	position,
		pandora::CartesianVector &	direction
	)		const

Get projected position and direction for a given input x coordinate and fit segment.

Parameters

x	the input x coordinate
fitSegment	the portion of sliding linear fit
position	the output position
position	the output direction

Returns

status code, faster than throwing in regular use-cases

StatusCode lar_content::TwoDSlidingFitResult::GetTransverseSurroundingLayers ( const float  x, const int  minLayer, const int  maxLayer, LayerFitResultMap::const_iterator &  firstLayerIter, LayerFitResultMap::const_iterator &  secondLayerIter  ) const

private

Get iterators for layers surrounding a specified transverse position.

Parameters

x	the transverse coordinate
minLayer	the minimum allowed layer
maxLayer	the maximum allowed layer
firstLayerIter	to receive the iterator for the layer just below the input coordinate
secondLayerIter	to receive the iterator for the layer just above the input coordinate

Returns

status code, faster than throwing in regular use-cases

Definition at line 1018 of file LArTwoDSlidingFitResult.cc.

{
    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    LayerFitResultMap::const_iterator minLayerIter = m_layerFitResultMap.find(minLayer);
    if (m_layerFitResultMap.end() == minLayerIter)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    LayerFitResultMap::const_iterator maxLayerIter = m_layerFitResultMap.find(maxLayer);
    if (m_layerFitResultMap.end() == maxLayerIter)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    CartesianVector minPosition(0.f, 0.f, 0.f), maxPosition(0.f, 0.f, 0.f);
    this->GetGlobalPosition(minLayerIter->second.GetL(), minLayerIter->second.GetFitT(), minPosition);
    this->GetGlobalPosition(maxLayerIter->second.GetL(), maxLayerIter->second.GetFitT(), maxPosition);

    if ((std::fabs(maxPosition.GetX() - minPosition.GetX()) < std::numeric_limits<float>::epsilon()))
        return STATUS_CODE_NOT_FOUND;

    // Find start layer
    const float minL(minLayerIter->second.GetL());
    const float maxL(maxLayerIter->second.GetL());
    const float startL(minL + (maxL - minL) * (x - minPosition.GetX()) / (maxPosition.GetX() - minPosition.GetX()));
    const int startLayer(std::max(minLayer, std::min(maxLayer, this->GetLayer(startL))));

    // Find nearest layer iterator to start layer
    LayerFitResultMap::const_iterator startLayerIter = m_layerFitResultMap.end();
    CartesianVector startLayerPosition(0.f, 0.f, 0.f);

    for (int iLayer = startLayer; iLayer <= maxLayer; ++iLayer)
    {
        startLayerIter = m_layerFitResultMap.find(iLayer);

        if (m_layerFitResultMap.end() != startLayerIter)
            break;
    }

    if (m_layerFitResultMap.end() == startLayerIter)
        return STATUS_CODE_NOT_FOUND;

    this->GetGlobalPosition(startLayerIter->second.GetL(), startLayerIter->second.GetFitT(), startLayerPosition);

    const bool startIsAhead((startLayerPosition.GetX() - x) > std::numeric_limits<float>::epsilon());
    const bool increasesWithLayers(maxPosition.GetX() > minPosition.GetX());
    const int increment = ((startIsAhead == increasesWithLayers) ? -1 : +1);

    // Find surrounding layer iterators
    // (Second layer iterator comes immediately after the fit has crossed the target X coordinate
    //  and first layer iterator comes immediately before the second layer iterator).
    firstLayerIter = m_layerFitResultMap.end();
    secondLayerIter = m_layerFitResultMap.end();

    CartesianVector firstLayerPosition(0.f, 0.f, 0.f);
    CartesianVector secondLayerPosition(0.f, 0.f, 0.f);

    for (int iLayer = startLayerIter->first; (iLayer >= minLayer) && (iLayer <= maxLayer); iLayer += increment)
    {
        LayerFitResultMap::const_iterator tempIter = m_layerFitResultMap.find(iLayer);
        if (m_layerFitResultMap.end() == tempIter)
            continue;

        firstLayerIter = secondLayerIter;
        firstLayerPosition = secondLayerPosition;
        secondLayerIter = tempIter;

        this->GetGlobalPosition(secondLayerIter->second.GetL(), secondLayerIter->second.GetFitT(), secondLayerPosition);
        const bool isAhead(secondLayerPosition.GetX() > x);

        if (startIsAhead != isAhead)
            break;

        firstLayerIter = m_layerFitResultMap.end();
    }

    if (m_layerFitResultMap.end() == firstLayerIter || m_layerFitResultMap.end() == secondLayerIter)
        return STATUS_CODE_NOT_FOUND;

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitResult::LongitudinalInterpolation ( const float  rL, LayerInterpolation &  layerInterpolation  ) const

private

Get the pair of layers surrounding a specified longitudinal position.

Parameters

rL	the longitudinal coordinate
layerInterpolation	to receive the populated layer interpolation object

Returns

status code, faster than throwing in regular use-cases

Definition at line 902 of file LArTwoDSlidingFitResult.cc.

{
    double firstWeight(0.), secondWeight(0.);
    LayerFitResultMap::const_iterator firstLayerIter, secondLayerIter;

    const StatusCode statusCode(this->GetLongitudinalSurroundingLayers(rL, firstLayerIter, secondLayerIter));

    if (STATUS_CODE_SUCCESS != statusCode)
        return statusCode;

    this->GetLongitudinalInterpolationWeights(rL, firstLayerIter, secondLayerIter, firstWeight, secondWeight);
    layerInterpolation = LayerInterpolation(firstLayerIter, secondLayerIter, firstWeight, secondWeight);

    return STATUS_CODE_SUCCESS;
}

void lar_content::TwoDSlidingFitResult::PerformSlidingLinearFit ( )

private

Perform the sliding linear fit.

Definition at line 643 of file LArTwoDSlidingFitResult.cc.

{
    if (!m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    if ((m_layerPitch < std::numeric_limits<float>::epsilon()) || (m_layerFitContributionMap.empty()))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    unsigned int slidingNPoints(0);
    double slidingSumT(0.), slidingSumL(0.), slidingSumTT(0.), slidingSumLT(0.), slidingSumLL(0.);

    const LayerFitContributionMap &layerFitContributionMap(this->GetLayerFitContributionMap());
    const int innerLayer(layerFitContributionMap.begin()->first);
    const int layerFitHalfWindow(static_cast<int>(this->GetLayerFitHalfWindow()));

    for (int iLayer = innerLayer; iLayer < innerLayer + layerFitHalfWindow; ++iLayer)
    {
        LayerFitContributionMap::const_iterator lyrIter = layerFitContributionMap.find(iLayer);

        if (layerFitContributionMap.end() != lyrIter)
        {
            slidingSumT += lyrIter->second.GetSumT();
            slidingSumL += lyrIter->second.GetSumL();
            slidingSumTT += lyrIter->second.GetSumTT();
            slidingSumLT += lyrIter->second.GetSumLT();
            slidingSumLL += lyrIter->second.GetSumLL();
            slidingNPoints += lyrIter->second.GetNPoints();
        }
    }

    const int outerLayer(layerFitContributionMap.rbegin()->first);

    for (int iLayer = innerLayer; iLayer <= outerLayer; ++iLayer)
    {
        const int fwdLayer(iLayer + layerFitHalfWindow);
        LayerFitContributionMap::const_iterator fwdIter = layerFitContributionMap.find(fwdLayer);

        if (layerFitContributionMap.end() != fwdIter)
        {
            slidingSumT += fwdIter->second.GetSumT();
            slidingSumL += fwdIter->second.GetSumL();
            slidingSumTT += fwdIter->second.GetSumTT();
            slidingSumLT += fwdIter->second.GetSumLT();
            slidingSumLL += fwdIter->second.GetSumLL();
            slidingNPoints += fwdIter->second.GetNPoints();
        }

        const int bwdLayer(iLayer - layerFitHalfWindow - 1);
        LayerFitContributionMap::const_iterator bwdIter = layerFitContributionMap.find(bwdLayer);

        if (layerFitContributionMap.end() != bwdIter)
        {
            slidingSumT -= bwdIter->second.GetSumT();
            slidingSumL -= bwdIter->second.GetSumL();
            slidingSumTT -= bwdIter->second.GetSumTT();
            slidingSumLT -= bwdIter->second.GetSumLT();
            slidingSumLL -= bwdIter->second.GetSumLL();
            slidingNPoints -= bwdIter->second.GetNPoints();
        }

        // require three points for meaningful results
        if (slidingNPoints <= 2)
            continue;

        // only fill the result map if there is an entry in the contribution map
        if (layerFitContributionMap.end() == layerFitContributionMap.find(iLayer))
            continue;

        const double denominator(slidingSumLL - slidingSumL * slidingSumL / static_cast<double>(slidingNPoints));

        if (std::fabs(denominator) < std::numeric_limits<float>::epsilon())
            continue;

        const double gradient((slidingSumLT - slidingSumL * slidingSumT / static_cast<double>(slidingNPoints)) / denominator);
        const double intercept(
            (slidingSumLL * slidingSumT / static_cast<double>(slidingNPoints) - slidingSumL * slidingSumLT / static_cast<double>(slidingNPoints)) / denominator);
        double variance((slidingSumTT - 2. * intercept * slidingSumT - 2. * gradient * slidingSumLT +
                            intercept * intercept * static_cast<double>(slidingNPoints) + 2. * gradient * intercept * slidingSumL +
                            gradient * gradient * slidingSumLL) /
                        (1. + gradient * gradient));

        if (variance < -std::numeric_limits<float>::epsilon())
            continue;

        if (variance < std::numeric_limits<float>::epsilon())
            variance = 0.;

        const double rms(std::sqrt(variance / static_cast<double>(slidingNPoints)));
        const double l(this->GetL(iLayer));
        const double fitT(intercept + gradient * l);

        const LayerFitResult layerFitResult(l, fitT, gradient, rms);
        (void)m_layerFitResultMap.insert(LayerFitResultMap::value_type(iLayer, layerFitResult));
    }

    if (m_layerFitResultMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
}

StatusCode lar_content::TwoDSlidingFitResult::TransverseInterpolation ( const float  x, const FitSegment &  fitSegment, LayerInterpolation &  layerInterpolation  ) const

private

Get the surrounding pair of layers for a specified transverse position and fit segment.

Parameters

x	the input coordinate
fitSegment	the fit segment
layerInterpolation	to receive the populated layer interpolation object

Returns

status code, faster than throwing in regular use-cases

Definition at line 920 of file LArTwoDSlidingFitResult.cc.

{
    double firstWeight(0.), secondWeight(0.);
    LayerFitResultMap::const_iterator firstLayerIter, secondLayerIter;

    const StatusCode statusCode(
        this->GetTransverseSurroundingLayers(x, fitSegment.GetStartLayer(), fitSegment.GetEndLayer(), firstLayerIter, secondLayerIter));

    if (STATUS_CODE_SUCCESS != statusCode)
        return statusCode;

    this->GetTransverseInterpolationWeights(x, firstLayerIter, secondLayerIter, firstWeight, secondWeight);
    layerInterpolation = LayerInterpolation(firstLayerIter, secondLayerIter, firstWeight, secondWeight);

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitResult::TransverseInterpolation ( const float  x, LayerInterpolationList &  layerInterpolationList  ) const

private

Get the a list of surrounding layer pairs for a specified transverse position.

Parameters

x	the input coordinate
layerInterpolationList	the output list of layer interpolation objects

Returns

status code, faster than throwing in regular use-cases

Definition at line 939 of file LArTwoDSlidingFitResult.cc.

{
    for (FitSegmentList::const_iterator iter = m_fitSegmentList.begin(), iterEnd = m_fitSegmentList.end(); iter != iterEnd; ++iter)
    {
        LayerInterpolation layerInterpolation;
        const StatusCode statusCode(this->TransverseInterpolation(x, *iter, layerInterpolation));

        if (STATUS_CODE_SUCCESS == statusCode)
        {
            layerInterpolationList.push_back(layerInterpolation);
        }
        else if (STATUS_CODE_NOT_FOUND != statusCode)
        {
            return statusCode;
        }
    }

    return STATUS_CODE_SUCCESS;
}

Member Data Documentation

pandora::CartesianVector lar_content::TwoDSlidingFitResult::m_axisDirection

private

The axis direction vector.

Definition at line 543 of file LArTwoDSlidingFitResult.h.

pandora::CartesianVector lar_content::TwoDSlidingFitResult::m_axisIntercept

private

The axis intercept position.

Definition at line 542 of file LArTwoDSlidingFitResult.h.

FitSegmentList lar_content::TwoDSlidingFitResult::m_fitSegmentList

private

The fit segment list.

Definition at line 547 of file LArTwoDSlidingFitResult.h.

LayerFitContributionMap lar_content::TwoDSlidingFitResult::m_layerFitContributionMap

private

The layer fit contribution map.

Definition at line 546 of file LArTwoDSlidingFitResult.h.

unsigned int lar_content::TwoDSlidingFitResult::m_layerFitHalfWindow

private

The layer fit half window.

Definition at line 540 of file LArTwoDSlidingFitResult.h.

LayerFitResultMap lar_content::TwoDSlidingFitResult::m_layerFitResultMap

private

The layer fit result map.

Definition at line 545 of file LArTwoDSlidingFitResult.h.

float lar_content::TwoDSlidingFitResult::m_layerPitch

private

The layer pitch, units cm.

Definition at line 541 of file LArTwoDSlidingFitResult.h.

pandora::CartesianVector lar_content::TwoDSlidingFitResult::m_orthoDirection

private

The orthogonal direction vector.

Definition at line 544 of file LArTwoDSlidingFitResult.h.

const pandora::Cluster* lar_content::TwoDSlidingFitResult::m_pCluster

private

The address of the cluster.

Definition at line 539 of file LArTwoDSlidingFitResult.h.

---

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

• larpandoracontent/larpandoracontent/LArObjects/LArTwoDSlidingFitResult.h
• larpandoracontent/larpandoracontent/LArObjects/LArTwoDSlidingFitResult.cc