BinDT.h

Go to the documentation of this file.

#ifndef AMPGEN_BINDT_H
#define AMPGEN_BINDT_H
#include <memory.h>
#include <stddef.h>
#include <array>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <string>
#include <utility>
#include <vector>
 
#include "AmpGen/ArgumentPack.h"
#include "AmpGen/MsgService.h"
#include "AmpGen/Types.h"
#include "AmpGen/EventList.h"
 
namespace AmpGen
{
  class Event;
 
  DECLARE_ARGUMENT(MaxDepth, size_t );
  DECLARE_ARGUMENT(MinEvents, size_t );
  DECLARE_ARGUMENT(Dim, size_t );
  DECLARE_ARGUMENT(Functor, std::function<std::vector<real_t>( const Event& )>);
  DECLARE_ARGUMENT(File, std::string);
 
  class BinDT
  {
    public:
      class EndNode;
 
      class INode
      {
        public:
          INode() = default;
          virtual ~INode() = default;
          virtual const EndNode* operator()( const double* evt ) const = 0;
          virtual void serialize( std::ostream& stream ) const         = 0;
          virtual void visit( const std::function<void( INode* )>& visit_function ) = 0; 
          INode* m_parent = {nullptr};
      };
      class EndNode : public INode
    {
      public:
        EndNode( const unsigned int& no, const unsigned int& binNumber = 999 );
        const EndNode* operator()( const double* evt ) const override ;
        void serialize( std::ostream& stream ) const override;
        unsigned int voxNumber() const { return m_voxNumber; }
        unsigned int binNumber() const { return m_binNumber; }
        void setBinNumber( const unsigned int& binNumber ) { m_binNumber = binNumber; }
        void visit( const std::function<void(INode*)>& visit_function ) override { visit_function( this ); }
        friend class BinDT;
      private:
        unsigned int m_voxNumber;
        unsigned int m_binNumber;
    };
 
    class Decision : public INode
    {
      public:
        Decision( const unsigned int& index, const double& value, std::shared_ptr<INode> left = nullptr,
            std::shared_ptr<INode> right = nullptr );
        const EndNode* operator()( const double* evt ) const override;
        void serialize( std::ostream& stream ) const override;
        void setChildren( std::shared_ptr<INode> l, std::shared_ptr<INode> r );
        void visit( const std::function<void(INode*)>& visit_function ) override;
      
        friend class BinDT;
      
      private :
        std::shared_ptr<INode> m_left;
        std::shared_ptr<INode> m_right;
        unsigned int m_index;
        double m_value;
    };
 
    public:
      template <class... ARGS>
        BinDT( const ARGS&... args ) : BinDT( ArgumentPack( args... ) )
      {
      }
      template <class... ARGS>
        BinDT( const std::vector<double*>& addr, const ARGS&... args ) : BinDT( ArgumentPack( args... ) )
      {
        m_top = makeNodes( addr );
      }
      template <class... ARGS> BinDT( const EventList& events, const ARGS&... args ) : BinDT(ArgumentPack(args...) )
    {
      m_top = makeNodes( events.begin(), events.end() ); 
    }
      template <class iterator_type, 
                class... ARGS> BinDT( const iterator_type& begin,
                                      const iterator_type& end, const ARGS&... args ) : BinDT(ArgumentPack( args... ) )
      {
        m_top = makeNodes(begin, end );
      }
      explicit BinDT( const ArgumentPack& args );
      BinDT( const EventList& events, const ArgumentPack& args );
      BinDT() = default;
 
      std::shared_ptr<INode> top() { return m_top; }
      unsigned int getBinNumber( const Event& evt ) const;
      unsigned int getBinNumber( const double* evt ) const;
      unsigned int getBin( const Event& evt ) const;
      unsigned int getBin( const double* evt ) const;
      unsigned int size() const;
      void readFromStream( std::istream& stream );
      void serialize( std::ofstream& output );
      void serialize( const std::string& filename );
      void setQueueOrdering( const std::vector<unsigned>& queueOrdering ){ m_queueOrdering = queueOrdering ; }
      std::vector<std::shared_ptr<EndNode>>& nodes() { return m_endNodes; }
      const std::vector<std::shared_ptr<EndNode>>& const_nodes() const { return m_endNodes; }
      std::vector<std::shared_ptr<EndNode>>::iterator begin() { return m_endNodes.begin(); }
      std::vector<std::shared_ptr<EndNode>>::iterator end() { return m_endNodes.end(); }
 
      std::function<std::vector<double>( const Event& )> makeDefaultFunctors();
      void refreshQueue(const std::vector<double*>&, std::queue<unsigned>&, const unsigned&);
      template <class iterator_type> 
      std::shared_ptr<INode> makeNodes(const iterator_type& begin, const iterator_type& end)
      {    
        std::vector<double> data( m_dim * (end-begin) );
        std::vector<double*> addresses( end-begin );
        size_t counter = 0;
        for ( auto evt = begin; evt != end; ++evt ) 
        {
          auto val = m_functors( *evt );
          for ( unsigned int i = 0; i < m_dim; ++i ) data[m_dim * counter + i] = val[i];
          addresses[counter]                                                   = &( data[m_dim * counter] );
          counter++;
        }
        return makeNodes( addresses );
      } 
      std::shared_ptr<INode> makeNodes(const std::vector<double*>&, std::queue<unsigned>, const unsigned&);
      std::shared_ptr<INode> makeNodes(const std::vector<double*>&);
      std::shared_ptr<INode> makeNodes(const std::vector<double*>&, const std::vector<double*>&);
      std::shared_ptr<INode> makeNodes(std::vector<double*>, std::vector<double*>, std::queue<unsigned>, const unsigned&);
      void setFunctor(const std::function<std::vector<double>( const Event& )>& functors) { m_functors = functors; }
    private:
      std::shared_ptr<INode> m_top                     = {nullptr};
      unsigned m_dim                                   = {0};
      unsigned m_minEvents                             = {0};
      unsigned m_maxDepth                              = {0};
      std::vector<unsigned>                            m_queueOrdering = {}; 
      std::vector<std::shared_ptr<EndNode>>            m_endNodes = {};
      std::function<std::vector<double>(const Event&)> m_functors = {};
      double getBestPost(const std::vector<double*>& source, const std::vector<double*>& target, int index, bool verbose = false );
  };
 
} // namespace AmpGen
#endif