synaptic_element.h

Go to the documentation of this file.

/*
 *  synaptic_element.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 SYNAPTIC_ELEMENT_H
#define SYNAPTIC_ELEMENT_H
 
// C++ includes:
#include <cmath>
 
// Includes from nestkernel:
#include "growth_curve.h"
 
// Includes from libnestutil:
#include "dictionary.h"
 
 
namespace nest
{
 
class SynapticElement
{
 
public:
  SynapticElement();
 
  SynapticElement( const SynapticElement& se );
 
  SynapticElement& operator=( const SynapticElement& other );
 
  ~SynapticElement()
  {
    delete growth_curve_;
  }
 
  void get( Dictionary& d ) const;
 
  void set( const Dictionary& d );
 
 
  void update( double t, double t_minus, double Ca_minus, double tau_Ca );
 
  int
  get_z_vacant() const
  {
    return std::floor( z_ ) - z_connected_;
  }
  int
  get_z_connected() const
  {
    return z_connected_;
  }
  double
  get_tau_vacant() const
  {
    return tau_vacant_;
  }
  void
  connect( int n )
  {
    z_connected_ += n;
    if ( z_connected_ > floor( z_ ) )
    {
      z_ = z_connected_ + ( z_ - floor( z_ ) );
    }
  }
 
  void
  set_growth_curve( GrowthCurve& g )
  {
    if ( growth_curve_ != &g )
    {
      delete growth_curve_;
      growth_curve_ = &g;
    }
  }
 
  double
  get_growth_rate() const
  {
    return growth_rate_;
  }
 
  void
  set_z( const double z_new )
  {
    z_ = z_new;
  }
  double
  get_z() const
  {
    return z_;
  }
  void
  decay_z_vacant()
  {
    if ( get_z_vacant() > 0 )
    {
      z_ -= get_z_vacant() * tau_vacant_;
    }
  }
 
  bool
  continuous() const
  {
    return continuous_;
  }
 
private:
  // The current number of synaptic elements at t = z_t_
  double z_;
  // Last time stamp when the number of synaptic elements was updated
  double z_t_;
  // Number of synaptic elements bound to a synapse
  int z_connected_;
  // Variable which defines if the number of synaptic elements should be treated
  // as a continous double number or as an integer value
  bool continuous_;
  // The maximum amount by which the synaptic elements will change between time
  // steps.
  double growth_rate_;
  // Rate at which vacant synaptic elements will decay
  double tau_vacant_;
  // Growth curve which defines the dynamics of this synaptic element.
  GrowthCurve* growth_curve_;
};
 
}  // of namespace
 
#endif /* #ifndef SYNAPTIC_ELEMENT_H */