connection.h

Go to the documentation of this file.

/*
 *  connection.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_H
#define CONNECTION_H

#include "nest_time.h"
#include "nest_timeconverter.h"
#include "nest.h"
#include "node.h"
#include "event.h"
#include "dict.h"
#include "dictutils.h"
#include "arraydatum.h"
#include "doubledatum.h"
#include "common_synapse_properties.h"
#include "nest_names.h"
#include "spikecounter.h"
#include "syn_id_delay.h"

namespace nest
{

class ConnectorModel;

 class ConnTestDummyNodeBase: public Node
 {
   void calibrate() {}
   void update(const nest::Time&, nest::long_t, nest::long_t) {}
   void set_status(const DictionaryDatum&) {}
   void get_status(DictionaryDatum&) const {}
   void init_node_(const nest::Node&) {}
   void init_state_(const nest::Node&) {}
   void init_buffers_() {}
 };



template<typename targetidentifierT>
class Connection
{

 public:

  Connection() :
    target_(),
    syn_id_delay_(1.0)
  { }
    
  Connection(const Connection<targetidentifierT> &rhs) :
    target_(rhs.target_),
    syn_id_delay_(rhs.syn_id_delay_)
  { }
  

  void get_status(DictionaryDatum & d) const;

  void set_status(const DictionaryDatum & d, ConnectorModel& cm);

  void calibrate(const TimeConverter &);

  double_t get_delay() const { return syn_id_delay_.get_delay_ms(); }

  long_t get_delay_steps() const { return syn_id_delay_.delay; }

  void set_delay(const double_t delay) { syn_id_delay_.set_delay_ms(delay); }

  void set_delay_steps(const long_t delay) { syn_id_delay_.delay = delay; }

  void set_syn_id(synindex syn_id) {  syn_id_delay_.syn_id = syn_id; }

  synindex get_syn_id() const {  return syn_id_delay_.syn_id; }


  void trigger_update_weight(const thread, const std::vector<spikecounter> &, const double_t, const CommonSynapseProperties &);

  Node *get_target(thread t) const { return target_.get_target_ptr(t); }
  rport get_rport() const { return target_.get_rport(); }

protected:

  void check_connection_(Node& dummy_target, Node& source, Node& target, rport receptor_type);

  /* the order of the members below is critical
     as it influcences the size of the object. Please leave unchanged
     as
     targetidentifierT target_;
     SynIdDelay syn_id_delay_;        //!< syn_id (char) and delay (24 bit) in timesteps of this connection
  */
     targetidentifierT target_;
     SynIdDelay syn_id_delay_;        
};


template<typename targetidentifierT>
inline
void Connection<targetidentifierT>::check_connection_(Node& dummy_target, Node& source, Node& target, rport receptor_type)
{
  // 1. does this connection support the event type sent by source
  // try to send event from source to dummy_target
  // this line might throw an exception
  source.send_test_event(dummy_target, receptor_type, get_syn_id(), true);

  // 2. does the target accept the event type sent by sourc
  // try to send event from source to target
  // this returns the port of the incoming connection      
  // p must be stored in the base class connection            
  // this line might throw an exception
  target_.set_rport(source.send_test_event(target, receptor_type, get_syn_id(), false));

  target_.set_target(&target);
}

template<typename targetidentifierT>
inline
void Connection<targetidentifierT>::get_status(DictionaryDatum & d) const
{
  def<double_t>(d, names::delay, syn_id_delay_.get_delay_ms());
  target_.get_status(d);
}

template<typename targetidentifierT>
inline
void Connection<targetidentifierT>::set_status(const DictionaryDatum & d, ConnectorModel& cm)
{
  double_t delay;
  if (updateValue<double_t>(d, names::delay, delay))
  {
    cm.assert_valid_delay_ms(delay);
    syn_id_delay_.set_delay_ms(delay);
  }
  // no call to target_.set_status() because target and rport cannot be changed
}

template<typename targetidentifierT>
inline
void Connection<targetidentifierT>::calibrate(const TimeConverter &tc)
{
  Time t = tc.from_old_steps(syn_id_delay_.delay);
  syn_id_delay_.delay = t.get_steps();

  if (syn_id_delay_.delay == 0)
    syn_id_delay_.delay = 1;
}

template<typename targetidentifierT>
inline
void Connection<targetidentifierT>::trigger_update_weight(const thread, const std::vector<spikecounter>&, const double_t, const CommonSynapseProperties&)
{
  throw IllegalConnection("Connection::trigger_update_weight: "
              "Connection does not support updates that are triggered by the volume transmitter.");
}

} // namespace nest

#endif // CONNECTION_H