ThreeDShowersAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_THREE_D_SHOWERS_ALGORITHM_H
#define LAR_THREE_D_SHOWERS_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

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

#include "larpandoracontent/LArThreeDReco/LArThreeDBase/ThreeDBaseAlgorithm.h"

namespace lar_content
{

class ShowerTensorTool;

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

class ThreeDShowersAlgorithm : public ThreeDBaseAlgorithm<ShowerOverlapResult>
{
public:
    ThreeDShowersAlgorithm();

    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 SetPfoParameters(const ProtoParticle &protoParticle, PandoraContentApi::ParticleFlowObject::Parameters &pfoParameters) const;

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 PreparationStep();

    void PreparationStep(pandora::ClusterList &clusterList);

    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 ExamineTensor();
    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;       
};

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

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

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

} // namespace lar_content

#endif // #ifndef LAR_THREE_D_SHOWERS_ALGORITHM_H