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