TrackRefinementBaseAlgorithm.h

Go to the documentation of this file.

 
#ifndef LAR_TRACK_REFINEMENT_BASE_ALGORITHM_H
#define LAR_TRACK_REFINEMENT_BASE_ALGORITHM_H 1
 
#include "Pandora/Algorithm.h"
 
#include "larpandoracontent/LArObjects/LArTwoDSlidingFitResult.h"
#include "larpandoracontent/LArTwoDReco/LArCosmicRay/ClusterAssociation.h"
 
namespace lar_content
{
class TrackRefinementBaseAlgorithm : public pandora::Algorithm
{
public:
    TrackRefinementBaseAlgorithm();
 
protected:
    typedef std::pair<TwoDSlidingFitResultMap *, TwoDSlidingFitResultMap *> SlidingFitResultMapPair;
    typedef std::unordered_map<const pandora::Cluster *, pandora::CaloHitList> ClusterToCaloHitListMap;
 
    class SortByDistanceAlongLine
    {
    public:
        SortByDistanceAlongLine(const pandora::CartesianVector &startPoint, const pandora::CartesianVector &lineDirection, const bool hitWidthMode);
 
        bool operator()(const pandora::CaloHit *const pLhs, const pandora::CaloHit *const pRhs) const;
 
    private:
        pandora::CartesianVector m_startPoint;    
        pandora::CartesianVector m_lineDirection; 
        bool m_hitWidthMode;                      
    };
 
    virtual pandora::StatusCode Run() = 0;
    virtual pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle) = 0;
 
    template <typename T>
    void InitialiseContainers(const pandora::ClusterList *pClusterList, const T sortFunction, pandora::ClusterVector &clusterVector,
        SlidingFitResultMapPair &slidingFitResultMapPair) const;
 
    bool GetClusterMergingCoordinates(const TwoDSlidingFitResult &clusterMicroFitResult, const TwoDSlidingFitResult &clusterMacroFitResult,
        const TwoDSlidingFitResult &associatedMacroFitResult, const bool isEndUpstream, pandora::CartesianVector &clusterMergePosition,
        pandora::CartesianVector &clusterMergeDirection) const;
 
    void GetHitsInBoundingBox(const pandora::CartesianVector &firstCorner, const pandora::CartesianVector &secondCorner,
        const pandora::ClusterList *const pClusterList, ClusterToCaloHitListMap &clusterToCaloHitListMap,
        const pandora::ClusterList &unavailableProtectedClusters = pandora::ClusterList(), const float distanceToLine = -1.f) const;
 
    bool IsInBoundingBox(const float minX, const float maxX, const float minZ, const float maxZ, const pandora::CartesianVector &hitPosition) const;
 
    bool IsCloseToLine(const pandora::CartesianVector &hitPosition, const pandora::CartesianVector &lineStart,
        const pandora::CartesianVector &lineDirection, const float distanceToLine) const;
 
    bool AreExtrapolatedHitsGood(const ClusterToCaloHitListMap &clusterToCaloHitListMap, ClusterAssociation &clusterAssociation) const;
 
    virtual bool AreExtrapolatedHitsNearBoundaries(const pandora::CaloHitVector &extrapolatedHitVector, ClusterAssociation &clusterAssociation) const = 0;
 
    bool IsNearBoundary(const pandora::CaloHit *const pCaloHit, const pandora::CartesianVector &boundaryPosition2D, const float boundaryTolerance) const;
 
    bool IsTrackContinuous(const ClusterAssociation &clusterAssociation, const pandora::CaloHitVector &extrapolatedCaloHitVector) const;
 
    void GetTrackSegmentBoundaries(const ClusterAssociation &clusterAssociation, pandora::CartesianPointVector &trackSegmentBoundaries) const;
 
    void RepositionIfInGap(const pandora::CartesianVector &mergeDirection, pandora::CartesianVector &trackPoint) const;
 
    float DistanceInGap(const pandora::CartesianVector &upstreamPoint, const pandora::CartesianVector &downstreamPoint,
        const pandora::CartesianVector &connectingLine, pandora::DetectorGapList &consideredGaps) const;
 
    bool IsInLineSegment(const pandora::CartesianVector &lowerBoundary, const pandora::CartesianVector &upperBoundary,
        const pandora::CartesianVector &point) const;
 
    const pandora::Cluster *RemoveOffAxisHitsFromTrack(const pandora::Cluster *const pCluster, const pandora::CartesianVector &splitPosition,
        const bool isEndUpstream, const ClusterToCaloHitListMap &clusterToCaloHitListMap, pandora::ClusterList &remnantClusterList,
        TwoDSlidingFitResultMap &microSlidingFitResultMap, TwoDSlidingFitResultMap &macroSlidingFitResultMap) const;
 
    void AddHitsToMainTrack(const pandora::Cluster *const pMainTrackCluster, const pandora::Cluster *const pShowerTrackCluster,
        const pandora::CaloHitList &caloHitsToMerge, const ClusterAssociation &clusterAssociation, pandora::ClusterList &remnantClusterList) const;
 
    void ProcessRemnantClusters(const pandora::ClusterList &remnantClusterList, const pandora::Cluster *const pMainTrackCluster,
        const pandora::ClusterList *const pClusterList, pandora::ClusterList &createdClusters) const;
 
    bool AddToNearestCluster(const pandora::Cluster *const pClusterToMerge, const pandora::Cluster *const pMainTrackCluster,
        const pandora::ClusterList *const pClusterList) const;
 
    bool IsClusterRemnantDisconnected(const pandora::Cluster *const pRemnantCluster) const;
 
    void FragmentRemnantCluster(const pandora::Cluster *const pRemnantCluster, pandora::ClusterList &fragmentedClusterList) const;
 
    template <typename T>
    void UpdateContainers(const pandora::ClusterList &clustersToAdd, const pandora::ClusterList &clustersToDelete, const T sortFunction,
        pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const;
 
    void RemoveClusterFromContainers(const pandora::Cluster *const pClustertoRemove, pandora::ClusterVector &clusterVector,
        SlidingFitResultMapPair &slidingFitResultMapPair) const;
 
    float m_minClusterLength;               
    unsigned int m_microSlidingFitWindow;   
    unsigned int m_macroSlidingFitWindow;   
    float m_stableRegionClusterFraction;    
    float m_mergePointMinCosAngleDeviation; 
    float m_minHitFractionForHitRemoval;    
    float m_maxDistanceFromMainTrack;       
    float m_maxHitDistanceFromCluster; 
    float m_maxHitSeparationForConnectedCluster; 
    unsigned int m_maxTrackGaps;                 
    float m_lineSegmentLength;                   
    bool m_hitWidthMode;                         
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline TrackRefinementBaseAlgorithm::SortByDistanceAlongLine::SortByDistanceAlongLine(
    const pandora::CartesianVector &startPoint, const pandora::CartesianVector &lineDirection, const bool hitWidthMode) :
    m_startPoint(startPoint),
    m_lineDirection(lineDirection.GetUnitVector()),
    m_hitWidthMode(hitWidthMode)
{
}
 
} // namespace lar_content
 
#endif // #ifndef TRACK_REFINEMENT_BASE_ALGORITHM_H