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