ThreeViewShowersAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_THREE_VIEW_SHOWERS_ALGORITHM_H
#define LAR_THREE_VIEW_SHOWERS_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include "larpandoracontent/LArObjects/LArShowerOverlapResult.h"
#include "larpandoracontent/LArObjects/LArTwoDSlidingShowerFitResult.h"

#include "larpandoracontent/LArThreeDReco/LArThreeDBase/NViewMatchingAlgorithm.h"
#include "larpandoracontent/LArThreeDReco/LArThreeDBase/ThreeViewMatchingControl.h"

namespace lar_content
{

class ShowerTensorTool;

//------------------------------------------------------------------------------------------------------------------------------------------

class ThreeViewShowersAlgorithm : public NViewMatchingAlgorithm<ThreeViewMatchingControl<ShowerOverlapResult>>
{
public:
    typedef NViewMatchingAlgorithm<ThreeViewMatchingControl<ShowerOverlapResult>> BaseAlgorithm;

    ThreeViewShowersAlgorithm();

    const TwoDSlidingShowerFitResult &GetCachedSlidingFitResult(const pandora::Cluster *const pCluster) const;

    void UpdateForNewCluster(const pandora::Cluster *const pNewCluster);
    void UpdateUponDeletion(const pandora::Cluster *const pDeletedCluster);
    void SelectInputClusters(const pandora::ClusterList *const pInputClusterList, pandora::ClusterList &selectedClusterList) const;
    void PrepareInputClusters(pandora::ClusterList &preparedClusterList);

private:
    class XSampling
    {
    public:
        XSampling(const TwoDSlidingFitResult &fitResultU, const TwoDSlidingFitResult &fitResultV, const TwoDSlidingFitResult &fitResultW);

        pandora::StatusCode GetBin(const float x, int &xBin) const;

        float m_uMinX;        
        float m_uMaxX;        
        float m_vMinX;        
        float m_vMaxX;        
        float m_wMinX;        
        float m_wMaxX;        
        float m_minX;         
        float m_maxX;         
        float m_xOverlapSpan; 
        float m_nPoints;      
    };

    void TidyUp();

    void AddToSlidingFitCache(const pandora::Cluster *const pCluster);

    void RemoveFromSlidingFitCache(const pandora::Cluster *const pCluster);

    void CalculateOverlapResult(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW);

    pandora::StatusCode CalculateOverlapResult(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV,
        const pandora::Cluster *const pClusterW, ShowerOverlapResult &overlapResult);

    typedef std::pair<ShowerPositionMap, ShowerPositionMap> ShowerPositionMapPair;

    void GetShowerPositionMaps(const TwoDSlidingShowerFitResult &fitResultU, const TwoDSlidingShowerFitResult &fitResultV,
        const TwoDSlidingShowerFitResult &fitResultW, const XSampling &xSampling, ShowerPositionMapPair &positionMapsU,
        ShowerPositionMapPair &positionMapsV, ShowerPositionMapPair &positionMapsW) const;

    void GetBestHitOverlapFraction(const pandora::Cluster *const pCluster, const XSampling &xSampling,
        const ShowerPositionMapPair &positionMaps, unsigned int &nSampledHits, unsigned int &nMatchedHits) const;

    void ExamineOverlapContainer();
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);

    typedef std::vector<ShowerTensorTool *> TensorToolVector;
    TensorToolVector m_algorithmToolVector; 
    unsigned int m_nMaxTensorToolRepeats;   

    unsigned int m_slidingFitWindow;                     
    TwoDSlidingShowerFitResultMap m_slidingFitResultMap; 

    bool m_ignoreUnavailableClusters;  
    unsigned int m_minClusterCaloHits; 
    float m_minClusterLengthSquared;   

    float m_minShowerMatchedFraction;      
    unsigned int m_minShowerMatchedPoints; 
    bool m_visualize;                      
};

//------------------------------------------------------------------------------------------------------------------------------------------

class ShowerTensorTool : public pandora::AlgorithmTool
{
public:
    typedef ThreeViewShowersAlgorithm::MatchingType::TensorType TensorType;
    typedef std::vector<TensorType::ElementList::const_iterator> IteratorList;

    virtual bool Run(ThreeViewShowersAlgorithm *const pAlgorithm, TensorType &overlapTensor) = 0;
};

} // namespace lar_content

#endif // #ifndef LAR_THREE_VIEW_SHOWERS_ALGORITHM_H