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