PndSomNode.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* ********************************
 * Self Organizing Map node class *
 * Author: M.Babai@rug.nl         *
 * Version:                       *
 * LICENSE:                       *
 * ********************************
 */
//#pragma once
#ifndef PND_SOM_NODE_H
#define PND_SOM_NODE_H

//________________________
#include <vector>
#include <string>
#include <map>

//________________________
#define PRINT_PND_SOM_NODE_DEBUG 0

class PndSomNode {
 public:
  PndSomNode();

  explicit PndSomNode(size_t WeightsDim);

  explicit PndSomNode(std::vector<float> const &weight);

  PndSomNode(std::string const &label, std::vector<float> const &weight);

  PndSomNode(int lft, int top, int rgt, int bot, size_t WeightsDim = 0);

  PndSomNode(int lft, int top, int rgt, int bot, size_t WeightsDim, std::string const &label);

  PndSomNode(int lft, int top, int rgt, int bot, std::string const &label, std::vector<float> const &weight);

  // Copy Constructor
  PndSomNode(PndSomNode const &oth);

  // Destructor
  virtual ~PndSomNode();

  // Operators
  // Assignment
  PndSomNode &operator=(PndSomNode const &oth);

  /*
   * Init the node.
   * Currently only on a rectangular grid.
   */
  virtual void InitNode();

  // Modifiers:
  inline int GetLeft() const;
  inline void SetLeft(int val);

  inline int GetRight() const;
  inline void SetRight(int val);

  inline int GetTop() const;
  inline void SetTop(int val);

  inline int GetBottom() const;
  inline void SetBottom(int val);

  inline size_t GetNodeDimension() const;
  inline void SetNodeDimension(size_t val);

  inline std::string const &GetLabel() const;
  inline void SetLabel(std::string const &val);

  inline std::vector<float> const &GetWeight() const;

  void SetWeight(std::vector<float> const &val);

  void SetNeighbours(std::vector<std::pair<size_t, double>> const &val);

  inline std::vector<std::pair<size_t, double>> const &GetNeighbours() const;

  inline double GetXPos() const;
  inline void SetXPos(double xp);

  inline double GetYPos() const;
  inline void SetYPos(double yp);

  void ResetRespList();

  void AddToRespList(size_t idx);
  void SetRespList(std::vector<size_t> const &val);
  std::vector<size_t> const &GetRespoList() const;

  void SetLabelMap(std::map<std::string, size_t> const &val);
  std::map<std::string, size_t> const &GetLabelMap() const;

#if (PRINT_PND_SOM_NODE_DEBUG > 0)
  void PrintNode() const;
#endif

 protected:
 private:
  //_______________ Functions ____________________
  // Clear the internal data structure (reset).
  void ClearInternalStructures();

  /*
   * Adjust the weights for the current node (not used in the batch
   * mode).
   */
  void AdjustWeights(std::vector<double> const &target, double LearningRate, double Influence);

  //___________________ Variables ___________________
  // Neighbour indices (2D for visualization)
  int m_iLeft;
  int m_iTop;
  int m_iRight;
  int m_iBottom;

  // Position of the node in the grid cell
  double m_xPos;
  double m_yPos;

  // Dimension of the weights
  size_t m_weightDim;

  // Label of the current node.
  std::string m_label;

  // Weight vector of the current node.
  std::vector<float> m_Weights;

  /*
   * Indices of the actual data point which are under the
   * responsibility of the current node.
   */
  std::vector<size_t> m_RespNodeIndex;

  // <Index, distance> of the neighbours for the current map node.
  std::vector<std::pair<size_t, double>> m_NeighbourList;

  // Map holding counts per label
  std::map<std::string, size_t> m_labelCnts;
}; // End of class definition

//______________ Inline functions ____________________
inline int PndSomNode::GetLeft() const
{
  return this->m_iLeft;
};

inline void PndSomNode::SetLeft(int val)
{
  this->m_iLeft = val;
};

inline int PndSomNode::GetRight() const
{
  return this->m_iRight;
};

inline void PndSomNode::SetRight(int val)
{
  this->m_iRight = val;
};

inline int PndSomNode::GetTop() const
{
  return this->m_iTop;
};

inline void PndSomNode::SetTop(int val)
{
  this->m_iTop = val;
};

inline int PndSomNode::GetBottom() const
{
  return this->m_iBottom;
};

inline void PndSomNode::SetBottom(int val)
{
  this->m_iBottom = val;
};

inline size_t PndSomNode::GetNodeDimension() const
{
  return this->m_weightDim;
};

inline void PndSomNode::SetNodeDimension(size_t val)
{
  this->m_weightDim = val;
};

inline std::string const &PndSomNode::GetLabel() const
{
  return this->m_label;
};

inline void PndSomNode::SetLabel(std::string const &val)
{
  this->m_label = val;
};

inline std::vector<float> const &PndSomNode::GetWeight() const
{
  return this->m_Weights;
};

inline double PndSomNode::GetXPos() const
{
  return this->m_xPos;
};

inline void PndSomNode::SetXPos(double xp)
{
  this->m_xPos = xp;
};

inline double PndSomNode::GetYPos() const
{
  return this->m_yPos;
};

inline void PndSomNode::SetYPos(double yp)
{
  this->m_yPos = yp;
};

inline std::vector<std::pair<size_t, double>> const &PndSomNode::GetNeighbours() const
{
  return this->m_NeighbourList;
};
#endif // End of interface