connection_manager.h

Go to the documentation of this file.

/*
 *  connection_manager.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 CONNECTION_MANAGER_H
#define CONNECTION_MANAGER_H

#include <vector>
#include <limits>

#include "nest.h"
#include "model.h"
#include "dictutils.h"
#include "nest_time.h"
#include "nest_timeconverter.h"
#include "arraydatum.h"
#include "sparsetable.h"
#include "../models/volume_transmitter.h"
#include <cmath>

namespace nest
{
  class ConnectorBase;
  class ConnectorModel;
  class Network;

class ConnectionManager
{

  typedef google::sparsetable< ConnectorBase* > tSConnector; // for all neurons having targets
  typedef std::vector< tSConnector > tVSConnector; // for all threads

public:
  ConnectionManager(Network& net);
  ~ConnectionManager();

  void init(Dictionary*);
  void reset();
  
  synindex register_synapse_prototype(ConnectorModel * cf);

  bool synapse_prototype_in_use(synindex syn_id);

  void get_status(DictionaryDatum& d) const;

  // aka SetDefaults for synapse models
  void set_prototype_status(synindex syn_id, const DictionaryDatum& d);
  // aka GetDefaults for synapse models
  DictionaryDatum get_prototype_status(synindex syn_id) const;

  // aka conndatum GetStatus
  DictionaryDatum get_synapse_status(index gid, synindex syn_id, port p, thread tid);
  // aka conndatum SetStatus
  void set_synapse_status(index gid, synindex syn_id, port p, thread tid, const DictionaryDatum& d);

  ArrayDatum get_connections(DictionaryDatum params) const;

  void get_connections(ArrayDatum& connectome, TokenArray const *source, TokenArray const *target, size_t syn_id) const;

  // aka CopyModel for synapse models
  synindex copy_synapse_prototype(synindex old_id, std::string new_name);

  bool has_user_prototypes() const;

  bool get_user_set_delay_extrema() const;

  const Time get_min_delay() const;
  const Time get_max_delay() const;

  size_t get_num_connections() const;

  void connect(Node& s, Node& r, index s_gid, thread tid, index syn, double_t d=NAN, double_t w=NAN);
  void connect(Node& s, Node& r, index s_gid, thread tid, index syn, DictionaryDatum& p, double_t d=NAN, double_t w=NAN);
  

  bool connect(ArrayDatum &d);

  void trigger_update_weight(const long_t vt_gid, const vector<spikecounter>& dopa_spikes, const double_t t_trig);

  void send(thread t, index sgid, Event& e);

  void calibrate(const TimeConverter &);

private:

  std::vector<ConnectorModel*> pristine_prototypes_; 
  std::vector < std::vector<ConnectorModel*> > prototypes_;          

  Network& net_;            
  Dictionary* synapsedict_; 

  tVSConnector connections_;
  
  mutable size_t num_connections_;              

  void init_();
  void delete_connections_();
  void clear_prototypes_();
  
  ConnectorBase* validate_source_entry(thread tid, index s_gid, synindex syn_id);

  const ConnectorModel& get_synapse_prototype(synindex syn_id, thread t=0) const;

  void assert_valid_syn_id(synindex syn_id, thread t=0) const;

};

inline
  const ConnectorModel& ConnectionManager::get_synapse_prototype(synindex syn_id, thread t) const
{
  assert_valid_syn_id(syn_id);
  return *(prototypes_[t][syn_id]);
}

inline
  void ConnectionManager::assert_valid_syn_id(synindex syn_id, thread t) const
{
  if (syn_id >= prototypes_[t].size() || prototypes_[t][syn_id] == 0)
    throw UnknownSynapseType(syn_id);
}

inline
bool ConnectionManager::has_user_prototypes() const
{
  return prototypes_[0].size() > pristine_prototypes_.size();
}


} // namespace




#endif /* #ifndef CONNECTION_MANAGER_H */