ParticleRecoveryAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_PARTICLE_RECOVERY_ALGORITHM_H
#define LAR_PARTICLE_RECOVERY_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include <unordered_map>

namespace lar_content
{

class ParticleRecoveryAlgorithm : public pandora::Algorithm
{
public:
    ParticleRecoveryAlgorithm();

private:
    class SimpleOverlapTensor
    {
    public:
        void AddAssociation(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2);

        void GetConnectedElements(const pandora::Cluster *const pCluster, const bool ignoreUnavailable, pandora::ClusterList &clusterListU,
            pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const;

        const pandora::ClusterList &GetKeyClusters() const;

    private:
        typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterList> ClusterNavigationMap;

        pandora::ClusterList m_keyClusters;            
        ClusterNavigationMap m_clusterNavigationMapUV; 
        ClusterNavigationMap m_clusterNavigationMapVW; 
        ClusterNavigationMap m_clusterNavigationMapWU; 
    };

    pandora::StatusCode Run();

    void GetInputClusters(pandora::ClusterList &inputClusterListU, pandora::ClusterList &inputClusterListV, pandora::ClusterList &inputClusterListW) const;

    void SelectInputClusters(const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const;

    void StandardClusterSelection(const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const;

    void VertexClusterSelection(const pandora::ClusterList &inputClusterList, pandora::ClusterList &selectedClusterList) const;

    void FindOverlaps(const pandora::ClusterList &clusterList1, const pandora::ClusterList &clusterList2, SimpleOverlapTensor &overlapTensor) const;

    bool IsOverlap(const pandora::Cluster *const pCluster1, const pandora::Cluster *const pCluster2) const;

    void CalculateEffectiveOverlapFractions(const pandora::Cluster *const pCluster1, const float xMin1, const float xMax1,
        const pandora::Cluster *const pCluster2, const float xMin2, const float xMax2, float &xOverlapFraction1, float &xOverlapFraction2) const;

    void CalculateEffectiveSpan(const pandora::Cluster *const pCluster, const float xMin, const float xMax, float &xMinEff, float &xMaxEff) const;

    void ExamineTensor(const SimpleOverlapTensor &overlapTensor) const;

    bool CheckConsistency(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW) const;

    void CreateTrackParticle(const pandora::ClusterList &clusterList) const;

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

    pandora::StringVector m_inputClusterListNames; 
    std::string m_outputPfoListName;               

    bool m_checkGaps; 

    unsigned int m_minClusterCaloHits; 
    float m_minClusterLengthSquared;   
    float m_minClusterXSpan;           

    bool m_vertexClusterMode;              
    float m_minVertexLongitudinalDistance; 
    float m_maxVertexTransverseDistance;   

    float m_minXOverlapFraction;         
    float m_minXOverlapFractionGaps;     
    float m_sampleStepSize;              
    unsigned int m_slidingFitHalfWindow; 
    float m_pseudoChi2Cut;               
};

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

inline const pandora::ClusterList &ParticleRecoveryAlgorithm::SimpleOverlapTensor::GetKeyClusters() const
{
    return m_keyClusters;
}

} // namespace lar_content

#endif // #ifndef LAR_PARTICLE_RECOVERY_ALGORITHM_H