LArAdaBoostDecisionTree.h

Go to the documentation of this file.

#ifndef LAR_ADABOOST_DECISION_TREE_H
#define LAR_ADABOOST_DECISION_TREE_H 1

#include "larpandoracontent/LArHelpers/LArMvaHelper.h"

#include "larpandoracontent/LArObjects/LArMvaInterface.h"

#include "Pandora/StatusCodes.h"

#include <functional>
#include <map>
#include <vector>

namespace lar_content
{

class AdaBoostDecisionTree : public MvaInterface
{
public:
    AdaBoostDecisionTree();

    AdaBoostDecisionTree(const AdaBoostDecisionTree &rhs);

    AdaBoostDecisionTree &operator=(const AdaBoostDecisionTree &rhs);

    ~AdaBoostDecisionTree();

    pandora::StatusCode Initialize(const std::string &parameterLocation, const std::string &bdtName);

    bool Classify(const LArMvaHelper::MvaFeatureVector &features) const;

    double CalculateClassificationScore(const LArMvaHelper::MvaFeatureVector &features) const;

    double CalculateProbability(const LArMvaHelper::MvaFeatureVector &features) const;

private:
    class Node
    {
    public:
        Node(const pandora::TiXmlHandle *const pXmlHandle);

        Node(const Node &rhs);

        Node &operator=(const Node &rhs);

        ~Node();

        int GetNodeId() const;

        int GetParentNodeId() const;

        int GetLeftChildNodeId() const;

        int GetRightChildNodeId() const;

        bool IsLeaf() const;

        double GetThreshold() const;

        int GetVariableId() const;

        bool GetOutcome() const;

    private:
        int       m_nodeId;               
        int       m_parentNodeId;         
        int       m_leftChildNodeId;      
        int       m_rightChildNodeId;     
        bool      m_isLeaf;               
        double    m_threshold;            
        int       m_variableId;           
        bool      m_outcome;              
    };

    typedef std::map<int, const Node*> IdToNodeMap;

    class WeakClassifier
    {
    public:
        WeakClassifier(const pandora::TiXmlHandle *const pXmlHandle);

        WeakClassifier(const WeakClassifier &rhs);

        WeakClassifier &operator=(const WeakClassifier &rhs);

        ~WeakClassifier();

        bool Predict(const LArMvaHelper::MvaFeatureVector &features) const;

        bool EvaluateNode(const int nodeId, const LArMvaHelper::MvaFeatureVector &features) const;

        double GetWeight() const;

        int GetTreeId() const;

    private:
        IdToNodeMap     m_idToNodeMap; 
        double          m_weight;      
        int             m_treeId;      
    };

    typedef std::vector<const WeakClassifier*> WeakClassifiers;

    class StrongClassifier
    {
    public:
        StrongClassifier(const pandora::TiXmlHandle *const pXmlHandle);

        StrongClassifier(const StrongClassifier &rhs);

        StrongClassifier &operator=(const StrongClassifier &rhs);

        ~StrongClassifier();

        double Predict(const LArMvaHelper::MvaFeatureVector &features) const;

    private:
        pandora::StatusCode ReadComponent(pandora::TiXmlElement *pCurrentXmlElement);

        WeakClassifiers     m_weakClassifiers;     
    };

    double CalculateScore(const LArMvaHelper::MvaFeatureVector &features) const;

    StrongClassifier     *m_pStrongClassifier;           
};

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

inline int AdaBoostDecisionTree::Node::GetNodeId() const
{
    return m_nodeId;
}

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

inline int AdaBoostDecisionTree::Node::GetParentNodeId() const
{
    return m_parentNodeId;
}

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

inline int AdaBoostDecisionTree::Node::GetLeftChildNodeId() const
{
    return m_leftChildNodeId;
}

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

inline int AdaBoostDecisionTree::Node::GetRightChildNodeId() const
{
    return m_rightChildNodeId;
}

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

inline bool AdaBoostDecisionTree::Node::IsLeaf() const
{
    return m_isLeaf;
}

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

inline double AdaBoostDecisionTree::Node::GetThreshold() const
{
    return m_threshold;
}

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

inline int AdaBoostDecisionTree::Node::GetVariableId() const
{
    return m_variableId;
}

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

inline bool AdaBoostDecisionTree::Node::GetOutcome() const
{
    return m_outcome;
}

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

inline double AdaBoostDecisionTree::WeakClassifier::GetWeight() const
{
    return m_weight;
}

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

inline int AdaBoostDecisionTree::WeakClassifier::GetTreeId() const
{
    return m_treeId;
}

} // namespace lar_content

#endif // #ifndef LAR_ADABOOST_DECISION_TREE_H