subnet.h

Go to the documentation of this file.

/*
 *  subnet.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 SUBNET_H
#define SUBNET_H

#include <vector>
#include <string>
#include "node.h"
#include "dictdatum.h"
#include "multirange.h"

/* BeginDocumentation

Name: subnet - Root node for subnetworks.

Description:
A network node of type subnet serves as a root node for subnetworks

Parameters:
Parameters that can be accessed via the GetStatus and SetStatus functions:

customdict (dictionarytype) -
   A user-defined dictionary, which may be used to store additional
   data.
label (stringtype) -
  A user-defined string, which may be used to give a symbolic name to
  the node.
number_of_children (integertype) -
  The number of direct children of the subnet

  SeeAlso: modeldict, Node
*/

namespace nest{

  using std::vector;

  class Node;

  class Subnet: public Node
  {
  public:

    Subnet();   

    Subnet(const Subnet &);

    virtual ~Subnet(){}
   
    void set_status(const DictionaryDatum&);
    void get_status(DictionaryDatum&) const;

    bool has_proxies() const;
          
    size_t global_size() const;  
    size_t local_size() const; 
    bool   global_empty() const; 
    bool   local_empty() const; 

    void   reserve(size_t);

    index add_node(Node *);

    index add_remote_node(index gid, index mid);

    vector<Node*>::iterator local_begin();

    vector<Node*>::iterator local_end();

    vector<Node*>::const_iterator local_begin() const;

    vector<Node*>::const_iterator local_end() const;

    Node* at_lid(index) const;

    std::string get_label() const;
    
    void set_label(std::string const);

    DictionaryDatum get_customdict() const;
    
    void set_customdict(DictionaryDatum const dict);
    
    std::string print_network(int , int, std::string = "");

    bool is_subnet() const;

    bool is_homogeneous() const; 

  protected:
    void init_node_(const Node&) {}
    void init_state_(const Node&) {}
    void init_buffers_() {}

    void calibrate() {}
    void update(Time const &, const long_t, const long_t) {}
    
    vector<Node *> nodes_;

    Multirange gids_;

  private:
    void get_dimensions_(std::vector<int>&) const;

    std::string     label_;      
    DictionaryDatum customdict_; 
    // note that DictionaryDatum is a pointer and must be initialized in the constructor.
    bool homogeneous_;           
    index last_mid_;             
  };

  inline
  index Subnet::add_node(Node *n)
  {
    const index lid = gids_.size();
    const index mid = n->get_model_id();
    if ((homogeneous_) && (lid > 0))
      if (mid != last_mid_)
    homogeneous_ = false;
    n->set_lid_(lid);
    n->set_subnet_index_(nodes_.size());
    nodes_.push_back(n);
    n->set_parent_(this);
    gids_.push_back(n->get_gid());
    last_mid_ = mid;
    return lid;
  }

  inline
  index Subnet::add_remote_node(index gid, index mid)
  {
    const index lid = gids_.size();
    if((homogeneous_) && (lid > 0))
      if (mid != last_mid_)
    homogeneous_ = false;
    last_mid_ = mid;
    gids_.push_back(gid);
    return lid;
  }
  
  inline
  vector<Node*>::iterator Subnet::local_begin()
  {
    return nodes_.begin();
  }

  inline
  vector<Node*>::iterator Subnet::local_end()
  {
    return nodes_.end();
  }

  inline
  vector<Node*>::const_iterator Subnet::local_begin() const
  {
    return nodes_.begin();
  }

  inline
  vector<Node*>::const_iterator Subnet::local_end() const
  {
    return nodes_.end();
  }

  inline
  bool Subnet::local_empty() const
  {
    return nodes_.empty();
  }

  inline
  bool Subnet::global_empty() const
  {
    return gids_.empty();
  }

  inline
  size_t Subnet::global_size() const
  {
    return gids_.size();
  }

  inline
  size_t Subnet::local_size() const
  {
    return nodes_.size();
  }

  inline
  Node* Subnet::at_lid(index lid) const
  {
    // defined for "dense" subnets only
    assert(local_size() == global_size());

    if ( lid >= nodes_.size() )
      throw UnknownNode();

    return nodes_[lid];
  }

  inline 
  void Subnet::reserve(size_t n)
  {
    nodes_.reserve(n);
  }

  inline 
  std::string Subnet::get_label() const
  {
    return label_;
  }

  inline 
  DictionaryDatum Subnet::get_customdict() const
  {
    return customdict_;
  }
  
  inline 
  void Subnet::set_customdict(DictionaryDatum const d)
  {
    customdict_=d;
  }
  
  inline
  bool Subnet::has_proxies() const
  {
    return false;
  }

  inline
  bool Subnet::is_homogeneous() const
  {
    return homogeneous_;
  }
  
} // namespace

#endif