lar_content::ThreeDSlidingConeFitResult Class Reference

ThreeDSlidingConeFitResult class. More...

#include <LArThreeDSlidingConeFitResult.h>

Public Member Functions
template<typename T >
	ThreeDSlidingConeFitResult (const T *const pT, const unsigned int slidingFitWindow, const float slidingFitLayerPitch)
	Constructor. More...
const ThreeDSlidingFitResult &	GetSlidingFitResult () const
	Get the sliding fit result for the full cluster. More...
const TrackStateMap &	GetTrackStateMap () const
	Get the track state map, which caches results from the sliding fit result. More...
void	GetSimpleConeList (const unsigned int nLayersForConeFit, const unsigned int nCones, const ConeSelection coneSelection, SimpleConeList &simpleConeList) const
	Get the list of simple cones fitted to the three dimensional cluster. More...

Private Types
typedef std::list < pandora::TrackState >	TrackStateLinkedList
	The track state linked list typedef. More...

Private Attributes
const ThreeDSlidingFitResult	m_slidingFitResult
	The sliding fit result for the full cluster. More...
TrackStateMap	m_trackStateMap
	The track state map. More...

Detailed Description

ThreeDSlidingConeFitResult class.

Definition at line 122 of file LArThreeDSlidingConeFitResult.h.

Member Typedef Documentation

typedef std::list<pandora::TrackState> lar_content::ThreeDSlidingConeFitResult::TrackStateLinkedList

private

The track state linked list typedef.

Definition at line 161 of file LArThreeDSlidingConeFitResult.h.

Constructor & Destructor Documentation

template<typename T >

template lar_content::ThreeDSlidingConeFitResult::ThreeDSlidingConeFitResult	(	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 pitch, units cm

Definition at line 71 of file LArThreeDSlidingConeFitResult.cc.

                                                                                                                                               :
    m_slidingFitResult(ThreeDSlidingFitResult(pT, slidingFitWindow, slidingFitLayerPitch))
{
    const CartesianVector &minLayerPosition3D(m_slidingFitResult.GetGlobalMinLayerPosition());
    const CartesianVector &maxLayerPosition3D(m_slidingFitResult.GetGlobalMaxLayerPosition());

    const TwoDSlidingFitResult &fitResult1(m_slidingFitResult.GetFirstFitResult());
    const TwoDSlidingFitResult &fitResult2(m_slidingFitResult.GetSecondFitResult());

    const LayerFitContributionMap &contributionMap1(fitResult1.GetLayerFitContributionMap());
    const LayerFitContributionMap &contributionMap2(fitResult2.GetLayerFitContributionMap());

    const int nSteps(static_cast<int>((maxLayerPosition3D - minLayerPosition3D).GetMagnitude() / slidingFitLayerPitch));

    for (int iStep = 0; iStep <= nSteps; ++iStep)
    {
        try
        {
            const float rL((static_cast<float>(iStep) + 0.5f) * slidingFitLayerPitch);
            CartesianVector fitPosition3D(0.f, 0.f, 0.f), fitDirection3D(0.f, 0.f, 0.f);

            if ((STATUS_CODE_SUCCESS != m_slidingFitResult.GetGlobalFitPosition(rL, fitPosition3D)) ||
                (STATUS_CODE_SUCCESS != m_slidingFitResult.GetGlobalFitDirection(rL, fitDirection3D)))
            {
                continue;
            }

            // ATTN Do not include layers without contributions in track state map (contain only interpolations)
            if (!contributionMap1.count(fitResult1.GetLayer(rL)) && !contributionMap2.count(fitResult2.GetLayer(rL)))
                continue;

            (void)m_trackStateMap.insert(TrackStateMap::value_type(iStep, TrackState(fitPosition3D, fitDirection3D)));
        }
        catch (const StatusCodeException &)
        {
            /* Deliberately empty */
        }
    }
}

Member Function Documentation

void lar_content::ThreeDSlidingConeFitResult::GetSimpleConeList	(	const unsigned int	nLayersForConeFit,
		const unsigned int	nCones,
		const ConeSelection	coneSelection,
		SimpleConeList &	simpleConeList
	)		const

Get the list of simple cones fitted to the three dimensional cluster.

Parameters

nLayersForConeFit	the number of layer to use to extract the cone direction
nCones	the number of cones to extract from the cluster (spaced uniformly along the cluster)
coneSelection	whether to receive forwards or backwards (or both) cones
simpleConeList	to receive the simple cone list

Definition at line 113 of file LArThreeDSlidingConeFitResult.cc.

{
    const TrackStateMap &trackStateMap(this->GetTrackStateMap());
    const unsigned int nLayers(trackStateMap.size());

    if (nLayers + 1 < nLayersForConeFit + nCones)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    // Calculate intervals and offsets such that cones are evenly spaced along sliding fit and are equidistant from the extremal layers
    const unsigned int coneInterval((nCones > 1) ? (nLayers - nLayersForConeFit) / (nCones - 1) : 1);
    const ThreeDSlidingFitResult &slidingFitResult(this->GetSlidingFitResult());
    const CartesianVector coneDisplacement(slidingFitResult.GetGlobalMaxLayerPosition() - slidingFitResult.GetGlobalMinLayerPosition());
    const bool isForward(coneDisplacement.GetZ() > std::numeric_limits<float>::epsilon());
    const unsigned int coneOffset1((nLayers - nLayersForConeFit - (nCones - 1) * coneInterval) / 2);
    const unsigned int coneOffset2((1 == nLayers % 2) && isForward ? 1 : 0);
    const unsigned int coneOffset(coneOffset1 + coneOffset2);

    TrackStateLinkedList trackStateList;
    CartesianVector directionSum(0.f, 0.f, 0.f);
    const float clusterLength((trackStateMap.begin()->second.GetPosition() - trackStateMap.rbegin()->second.GetPosition()).GetMagnitude());

    unsigned int nConeSamplingSteps(0);

    for (TrackStateMap::const_iterator iter = trackStateMap.begin(), iterEnd = trackStateMap.end(); iter != iterEnd; ++iter)
    {
        if (nConeSamplingSteps >= nCones)
            return;

        trackStateList.push_back(iter->second);
        directionSum += iter->second.GetMomentum();

        const unsigned int beginDistance(static_cast<unsigned int>(std::distance(trackStateMap.begin(), iter)));

        if (beginDistance + 1 < nLayersForConeFit)
            continue;

        const TrackState &maxLayerTrackState(trackStateList.back());
        const TrackState &minLayerTrackState(trackStateList.front());

        if ((beginDistance + 1 >= nLayersForConeFit + coneOffset) && (beginDistance + 1 - nLayersForConeFit - coneOffset) % coneInterval == 0)
        {
            const CartesianVector &minLayerApex(minLayerTrackState.GetPosition());
            const CartesianVector &maxLayerApex(maxLayerTrackState.GetPosition());

            const CartesianVector minLayerDirection(directionSum.GetUnitVector());
            const CartesianVector maxLayerDirection(directionSum.GetUnitVector() * -1.f);

            // TODO Estimate cone length and angle here too, maybe by projecting positions onto direction and looking at rT distribution?
            ++nConeSamplingSteps;
            const float placeHolderTanHalfAngle(0.5f);

            if ((CONE_FORWARD_ONLY == coneSelection) || (CONE_BOTH_DIRECTIONS == coneSelection))
                simpleConeList.push_back(SimpleCone(minLayerApex, minLayerDirection, clusterLength, placeHolderTanHalfAngle));

            if ((CONE_BACKWARD_ONLY == coneSelection) || (CONE_BOTH_DIRECTIONS == coneSelection))
                simpleConeList.push_back(SimpleCone(maxLayerApex, maxLayerDirection, clusterLength, placeHolderTanHalfAngle));
        }

        directionSum -= minLayerTrackState.GetMomentum();
        trackStateList.pop_front();
    }
}

const ThreeDSlidingFitResult & lar_content::ThreeDSlidingConeFitResult::GetSlidingFitResult ( ) const

inline

Get the sliding fit result for the full cluster.

Returns

the sliding fit result for the full cluster

Definition at line 220 of file LArThreeDSlidingConeFitResult.h.

{
    return m_slidingFitResult;
}

const TrackStateMap & lar_content::ThreeDSlidingConeFitResult::GetTrackStateMap ( ) const

inline

Get the track state map, which caches results from the sliding fit result.

Returns

the track state map

Definition at line 227 of file LArThreeDSlidingConeFitResult.h.

{
    return m_trackStateMap;
}

Member Data Documentation

const ThreeDSlidingFitResult lar_content::ThreeDSlidingConeFitResult::m_slidingFitResult

private

The sliding fit result for the full cluster.

Definition at line 163 of file LArThreeDSlidingConeFitResult.h.

TrackStateMap lar_content::ThreeDSlidingConeFitResult::m_trackStateMap

private

The track state map.

Definition at line 164 of file LArThreeDSlidingConeFitResult.h.

---

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

• LArThreeDSlidingConeFitResult.h
• LArThreeDSlidingConeFitResult.cc