static_connection.h

Go to the documentation of this file.

/*
 *  static_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/>.
 *
 */


/* BeginDocumentation
  Name: static_synapse - Synapse type for static connections.

  Description:
   static_synapse does not support any kind of plasticity. It simply stores
   the parameters target, weight, delay and receiver port for each connection.

  FirstVersion: October 2005
  Author: Jochen Martin Eppler, Moritz Helias

  Transmits: SpikeEvent, RateEvent, CurrentEvent, ConductanceEvent, DoubleDataEvent, DataLoggingRequest
  
  Remarks: Refactored for new connection system design, March 2007

  SeeAlso: synapsedict, tsodyks_synapse, stdp_synapse
*/

#ifndef STATICCONNECTION_H
#define STATICCONNECTION_H

#include "connection.h"

namespace nest
{

template<typename targetidentifierT>
class StaticConnection : public Connection<targetidentifierT>
{
  double_t weight_;

 public:

  // this line determines which common properties to use
  typedef CommonSynapseProperties CommonPropertiesType;

  typedef Connection<targetidentifierT> ConnectionBase;

  StaticConnection() : ConnectionBase(), weight_(1.0)
  { }

  StaticConnection(const StaticConnection& rhs) : ConnectionBase(rhs), weight_(rhs.weight_)
  { }

  // Explicitly declare all methods inherited from the dependent base ConnectionBase.
  // This avoids explicit name prefixes in all places these functions are used.
  // Since ConnectionBase depends on the template parameter, they are not automatically
  // found in the base class.
  using ConnectionBase::get_delay_steps;
  using ConnectionBase::get_rport;
  using ConnectionBase::get_target;


  class ConnTestDummyNode: public ConnTestDummyNodeBase
  {
  public:
    // Ensure proper overriding of overloaded virtual functions.
    // Return values from functions are ignored.
    using ConnTestDummyNodeBase::handles_test_event;
    port handles_test_event(SpikeEvent&, rport) { return invalid_port_; }
    port handles_test_event(RateEvent&, rport) { return invalid_port_; }
    port handles_test_event(DataLoggingRequest&, rport) { return invalid_port_; }
    port handles_test_event(CurrentEvent&, rport) { return invalid_port_; }
    port handles_test_event(ConductanceEvent&, rport) { return invalid_port_; }
    port handles_test_event(DoubleDataEvent&, rport) { return invalid_port_; }
    port handles_test_event(DSSpikeEvent&, rport) { return invalid_port_; }
    port handles_test_event(DSCurrentEvent&, rport) { return invalid_port_; }
  };

  void check_connection(Node & s, Node & t, rport receptor_type, double_t, const CommonPropertiesType &)
  {
    ConnTestDummyNode dummy_target;
    ConnectionBase::check_connection_(dummy_target, s, t, receptor_type);
  }

  void send(Event& e, thread t, double_t, const CommonSynapseProperties &)
  {
    e.set_weight(weight_);
    e.set_delay(get_delay_steps());
    e.set_receiver(*get_target(t));
    e.set_rport(get_rport());
    e();
  }

  void get_status(DictionaryDatum & d) const;

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

  void set_weight (double_t w) { weight_ = w; }
};

template<typename targetidentifierT>
void StaticConnection<targetidentifierT>::get_status(DictionaryDatum & d) const
{

  ConnectionBase::get_status(d);
  def<double_t>(d, names::weight, weight_);
  def<long_t>(d, names::size_of, sizeof(*this));
}

template<typename targetidentifierT>
void StaticConnection<targetidentifierT>::set_status(const DictionaryDatum & d, ConnectorModel& cm)
{
  ConnectionBase::set_status(d, cm);
  updateValue<double_t>(d, names::weight, weight_);
}

} // namespace

#endif /* #ifndef STATICCONNECTION_H */