ThreeDBaseAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_THREE_D_BASE_ALGORITHM_H
#define LAR_THREE_D_BASE_ALGORITHM_H 1

#include "Api/PandoraContentApi.h"

#include "Pandora/Algorithm.h"

#include "larpandoracontent/LArObjects/LArOverlapTensor.h"

#include <unordered_map>

namespace lar_content
{

class ProtoParticle
{
public:
    pandora::ClusterList    m_clusterListU;                 
    pandora::ClusterList    m_clusterListV;                 
    pandora::ClusterList    m_clusterListW;                 
};

typedef std::vector<ProtoParticle> ProtoParticleVector;
typedef std::unordered_map<const pandora::Cluster*, pandora::ClusterList> ClusterMergeMap;

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

template<typename T>
class ThreeDBaseAlgorithm : public pandora::Algorithm
{
public:
    typedef OverlapTensor<T> TensorType;

    ThreeDBaseAlgorithm();

    virtual ~ThreeDBaseAlgorithm();

    virtual bool CreateThreeDParticles(const ProtoParticleVector &protoParticleVector);

    virtual void SetPfoParameters(const ProtoParticle &protoParticle, PandoraContentApi::ParticleFlowObject::Parameters &pfoParameters) const = 0;

    virtual bool MakeClusterMerges(const ClusterMergeMap &clusterMergeMap);

    virtual void UpdateForNewCluster(const pandora::Cluster *const pNewCluster);

    virtual void UpdateUponDeletion(const pandora::Cluster *const pDeletedCluster);

    virtual void RemoveUnavailableTensorElements();

    const pandora::ClusterList &GetInputClusterListU() const;

    const pandora::ClusterList &GetInputClusterListV() const;

    const pandora::ClusterList &GetInputClusterListW() const;

    const pandora::ClusterList &GetSelectedClusterListU() const;

    const pandora::ClusterList &GetSelectedClusterListV() const;

    const pandora::ClusterList &GetSelectedClusterListW() const;

    const std::string &GetClusterListNameU() const;

    const std::string &GetClusterListNameV() const;

    const std::string &GetClusterListNameW() const;

    virtual void SelectInputClusters(const pandora::ClusterList *const pInputClusterList, pandora::ClusterList &selectedClusterList) const = 0;

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

    virtual void SelectAllInputClusters();

    virtual void PreparationStep();

    virtual void PerformMainLoop();

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

    virtual void ExamineTensor() = 0;

    virtual void TidyUp();

    const pandora::ClusterList *m_pInputClusterListU;           
    const pandora::ClusterList *m_pInputClusterListV;           
    const pandora::ClusterList *m_pInputClusterListW;           

    pandora::ClusterList        m_clusterListU;                 
    pandora::ClusterList        m_clusterListV;                 
    pandora::ClusterList        m_clusterListW;                 

    TensorType                  m_overlapTensor;                

private:
    pandora::StatusCode Run();

    std::string                 m_inputClusterListNameU;        
    std::string                 m_inputClusterListNameV;        
    std::string                 m_inputClusterListNameW;        
    std::string                 m_outputPfoListName;            
};

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

template<typename T>
inline const pandora::ClusterList &ThreeDBaseAlgorithm<T>::GetInputClusterListU() const
{
    if (NULL == m_pInputClusterListU)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return (*m_pInputClusterListU);
}

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

template<typename T>
inline const pandora::ClusterList &ThreeDBaseAlgorithm<T>::GetInputClusterListV() const
{
    if (NULL == m_pInputClusterListV)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return (*m_pInputClusterListV);
}

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

template<typename T>
inline const pandora::ClusterList &ThreeDBaseAlgorithm<T>::GetInputClusterListW() const
{
    if (NULL == m_pInputClusterListW)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return (*m_pInputClusterListW);
}

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

template<typename T>
inline const pandora::ClusterList &ThreeDBaseAlgorithm<T>::GetSelectedClusterListU() const
{
    return m_clusterListU;
}

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

template<typename T>
inline const pandora::ClusterList &ThreeDBaseAlgorithm<T>::GetSelectedClusterListV() const
{
    return m_clusterListV;
}

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

template<typename T>
inline const pandora::ClusterList &ThreeDBaseAlgorithm<T>::GetSelectedClusterListW() const
{
    return m_clusterListW;
}

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

template<typename T>
inline const std::string &ThreeDBaseAlgorithm<T>::GetClusterListNameU() const
{
    return m_inputClusterListNameU;
}

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

template<typename T>
inline const std::string &ThreeDBaseAlgorithm<T>::GetClusterListNameV() const
{
    return m_inputClusterListNameV;
}

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

template<typename T>
inline const std::string &ThreeDBaseAlgorithm<T>::GetClusterListNameW() const
{
    return m_inputClusterListNameW;
}

} // namespace lar_content

#endif // #ifndef LAR_THREE_D_BASE_ALGORITHM_H