node.h

Go to the documentation of this file.

/*
 *  node.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef NODE_H
#define NODE_H
#include <bitset>
#include <string>
#include <sstream>
#include <vector>
#include <deque>
#include <utility>
#include "nest.h"
#include "nest_time.h"
#include "nest_names.h"
#include "dictdatum.h"
#include "histentry.h"
#include "event.h"

namespace nest {

  class Scheduler;
  class Model;

  class Subnet;
  class Network;
  class Archiving_Node;
  class histentry;


  /* BeginDocumentation
     Name: Node - General properties of all nodes.
     Parameters:
     frozen     booltype    - Whether the node is updated during simulation
     global_id  integertype - The global id of the node (cf. local_id)
     local      booltype    - Whether the node is available on the local process
     local_id   integertype - The id of the node in the current  (cf. global_id)
     model      literaltype - The model type the node was created from 
     parent     integertype - The global id of the parent subnet
     state      integertype - The state of the node (see the help on elementstates for details)
     thread     integertype - The id of the thread the node is assigned to (valid locally)
     vp         integertype - The id of the virtual process the node is assigned to (valid globally)
     SeeAlso: GetStatus, SetStatus, elementstates
   */
  
  
  class Node
  {
    friend class Network;
    friend class Scheduler;
    friend class Subnet;
    friend class proxynode;
    friend class Synapse;
    friend class Model;
    
    Node& operator=(const Node&); 

  public:

    Node();
    Node(Node const &);
    virtual ~Node();

    virtual Node *clone() const{ return 0; }

    virtual bool has_proxies() const;
    
    virtual bool potential_global_receiver() const;
    
    virtual void set_has_proxies(const bool);

    virtual void set_local_receiver(const bool);
    
    virtual bool local_receiver() const;

    virtual bool one_node_per_process() const;

    virtual bool is_off_grid() const;


    virtual bool is_proxy() const;

    std::string get_name() const;

    index get_gid() const;

    index get_lid() const;

    index get_subnet_index() const;

    int get_model_id() const;

    Subnet* get_parent() const;

    virtual
    std::string print_network(int , int, std::string = "") {return std::string();}

    bool is_frozen() const;

    static Network* network();

    bool is_local() const;

    void init_state();

     void init_buffers();

    virtual void calibrate()=0;
  
    virtual void finalize() {}
    
    virtual 
    void update(Time const &, const long_t, const long_t)=0;


    virtual 
    void set_status(const DictionaryDatum&)=0;

    virtual 
    void get_status(DictionaryDatum&) const=0;

  public:
    virtual port send_test_event(Node& receiving_node, rport receptor_type, synindex syn_id, bool dummy_target);

    virtual port handles_test_event(SpikeEvent&, rport receptor_type);
    virtual port handles_test_event(RateEvent&, rport receptor_type);
    virtual port handles_test_event(DataLoggingRequest&, rport receptor_type);
    virtual port handles_test_event(CurrentEvent&, rport receptor_type);
    virtual port handles_test_event(ConductanceEvent&, rport receptor_type);
    virtual port handles_test_event(DoubleDataEvent&, rport receptor_type);
    virtual port handles_test_event(DSSpikeEvent&, rport receptor_type);
    virtual port handles_test_event(DSCurrentEvent&, rport receptor_type);

    virtual
    void register_stdp_connection(double_t);

    virtual
    void unregister_stdp_connection(double_t);

    virtual
    void handle(SpikeEvent& e);

    virtual
    void handle(RateEvent& e);

    virtual
    void handle(DataLoggingRequest& e);

    virtual
    void handle(DataLoggingReply& e);

    virtual
    void handle(CurrentEvent& e);

    virtual
    void handle(ConductanceEvent& e);

    virtual
    void handle(DoubleDataEvent& e);

     virtual
     double_t get_K_value(double_t t); 

     virtual
     void get_K_values(double_t t, double_t& Kminus, double_t& triplet_Kminus); 

     virtual
     void get_history(double_t t1, double_t t2, 
                   std::deque<histentry>::iterator* start,
           std::deque<histentry>::iterator* finish);

    virtual
    void event_hook(DSSpikeEvent&);

    virtual
    void event_hook(DSCurrentEvent&);

    void set_thread(thread);

    thread get_thread() const;

    void set_vp(thread);

    thread get_vp() const;

    void  set_model_id(int);

    virtual bool is_subnet() const;

     DictionaryDatum get_status_base(); 

     void set_status_base(const DictionaryDatum&);

     bool is_model_prototype() const;

     void set_thread_lid(const index);

     index get_thread_lid() const;

     bool buffers_initialized() const { return buffers_initialized_; }

     void set_buffers_initialized(bool initialized) { buffers_initialized_ = initialized; }

  private:

    void  set_lid_(index);         
    void  set_parent_(Subnet *);   
    void  set_gid_(index);         
    void  set_subnet_index_(index);

    virtual
    DictionaryDatum get_status_dict_();

  protected:

    virtual
    size_t num_thread_siblings_() const { return 0;}

    virtual
    Node* get_thread_sibling_(index) const { assert(false); return 0; }

    virtual
    Node* get_thread_sibling_safe_(index) const { assert(false); return 0; }

     virtual void init_state_(Node const&) =0;
     
     virtual void init_buffers_() =0;

    Model & get_model_() const;

    void set_frozen_(bool frozen) { frozen_ = frozen; }

    template <typename ConcreteNode>
    const ConcreteNode& downcast(const Node&);

   private:
    index    gid_;           
    index    lid_;           
    index    subnet_index_;  

    index    thread_lid_;
    
    int      model_id_;      
    Subnet *parent_;              
    thread   thread_;        
    thread   vp_;            
    bool     frozen_;   
    bool     buffers_initialized_;   

  protected:
    static Network* net_;    
  };

  inline
  bool Node::is_frozen() const
  {
    return frozen_;
  }

  inline
  bool Node::has_proxies() const
  {
    return true;
  }

  inline
  bool Node::potential_global_receiver() const
  {
    return false;
  }
  
  inline
  bool Node::local_receiver() const
  {
    return false;
  }

  inline
  bool Node::one_node_per_process() const
  {
    return false;
  }

  inline
  bool Node::is_off_grid() const
  {
    return false;
  }

  inline
  bool Node::is_proxy() const
  {
    return false;
  }

  inline
  index Node::get_lid() const
  {
    return lid_;
  }

  inline
  index Node::get_gid() const
  {
    return gid_;
  }

  inline
  index Node::get_subnet_index() const
  {
    return subnet_index_;
  }

  inline
  void Node::set_gid_(index i)
  {
    gid_=i;
  }

  inline
  void Node::set_lid_(index i)
  {
    lid_=i;
  }

  inline
  void Node::set_subnet_index_(index i)
  {
    subnet_index_ = i;
  }

  inline
  int Node::get_model_id() const
  {
    return model_id_;
  }

  inline
  void Node::set_model_id(int i)
  {
    model_id_ = i;
  }

  inline
  bool Node::is_model_prototype() const
  {
    return vp_ == invalid_thread_;
  }

  inline
  Subnet * Node::get_parent() const
  {
    return parent_;
  }

  inline
  void Node::set_parent_(Subnet *c)
  {
    parent_=c;
  }

  inline
  Network* Node::network()
  {
    return net_;
  }

  inline
  void Node::set_thread(thread t)
  {
    thread_ = t;
  }

  inline
  thread Node::get_thread() const
  {
    return thread_;
  }

  inline
  void Node::set_vp(thread vp)
  {
    vp_ = vp;
  }

  inline
  thread Node::get_vp() const
  {
    return vp_;
  }

  template <typename ConcreteNode>
  const ConcreteNode& Node::downcast(const Node& n)
  {
    ConcreteNode const* tp = dynamic_cast<ConcreteNode const*>(&n);
    assert(tp != 0);
    return *tp;
  }

  inline
  void Node::set_thread_lid(const index tlid)
  {
    thread_lid_ = tlid;
  }

  inline
  index Node::get_thread_lid() const
  {
    return thread_lid_;
  }
  
} // namespace

#endif