secondary_event.h

Go to the documentation of this file.

/*
 *  secondary_event.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 SECONDARY_EVENT_H
#define SECONDARY_EVENT_H
 
// Includes from nestkernel
#include "event.h"
 
// C++ includes
#include <set>
 
namespace nest
{
 
class SecondaryEvent : public Event
{
 
public:
  SecondaryEvent* clone() const override = 0;
 
  virtual void add_syn_id( const synindex synid ) = 0;
 
  virtual size_t size() = 0;
  virtual std::vector< unsigned int >::iterator& operator<<( std::vector< unsigned int >::iterator& pos ) = 0;
  virtual std::vector< unsigned int >::iterator& operator>>( std::vector< unsigned int >::iterator& pos ) = 0;
 
  virtual const std::set< synindex >& get_supported_syn_ids() const = 0;
 
  virtual void reset_supported_syn_ids() = 0;
};
 
template < typename T >
size_t
number_of_uints_covered()
{
  size_t num_uints = sizeof( T ) / sizeof( unsigned int );
  if ( num_uints * sizeof( unsigned int ) < sizeof( T ) )
  {
    num_uints += 1;
  }
  return num_uints;
}
 
template < typename T >
void
write_to_comm_buffer( T d, std::vector< unsigned int >::iterator& pos )
{
  // there is no aliasing problem here, since cast to char* invalidate strict
  // aliasing assumptions
  char* const c = reinterpret_cast< char* >( &d );
 
  const size_t num_uints = number_of_uints_covered< T >();
  size_t left_to_copy = sizeof( T );
 
  for ( size_t i = 0; i < num_uints; i++ )
  {
    memcpy( &( *( pos + i ) ), c + i * sizeof( unsigned int ), std::min( left_to_copy, sizeof( unsigned int ) ) );
    left_to_copy -= sizeof( unsigned int );
  }
 
  pos += num_uints;
}
 
template < typename T >
void
read_from_comm_buffer( T& d, std::vector< unsigned int >::iterator& pos )
{
  // there is no aliasing problem here, since cast to char* invalidate strict
  // aliasing assumptions
  char* const c = reinterpret_cast< char* >( &d );
 
  const size_t num_uints = number_of_uints_covered< T >();
  size_t left_to_copy = sizeof( T );
 
  for ( size_t i = 0; i < num_uints; i++ )
  {
    memcpy( c + i * sizeof( unsigned int ), &( *( pos + i ) ), std::min( left_to_copy, sizeof( unsigned int ) ) );
    left_to_copy -= sizeof( unsigned int );
  }
 
  pos += num_uints;
}
 
template < typename DataType, typename Subclass >
class DataSecondaryEvent : public SecondaryEvent
{
private:
  static std::set< synindex > supported_syn_ids_;
  static size_t coeff_length_;  // length of coeffarray
 
  union CoeffarrayBegin
  {
    std::vector< unsigned int >::iterator as_uint;
    typename std::vector< DataType >::iterator as_DataType;
 
    CoeffarrayBegin() {};  // need to provide default constructor due to
                           // non-trivial constructors of iterators
  } coeffarray_begin_;
 
  union CoeffarrayEnd
  {
    std::vector< unsigned int >::iterator as_uint;
    typename std::vector< DataType >::iterator as_DataType;
 
    CoeffarrayEnd() {};  // need to provide default constructor due to
                         // non-trivial constructors of iterators
  } coeffarray_end_;
 
public:
  void add_syn_id( const synindex synid ) override;
 
  const std::set< synindex >&
  get_supported_syn_ids() const override
  {
    return supported_syn_ids_;
  }
 
  void
  reset_supported_syn_ids() override
  {
    supported_syn_ids_.clear();
  }
 
  static void set_coeff_length( const size_t coeff_length );
 
  void
  set_coeffarray( std::vector< DataType >& ca )
  {
    coeffarray_begin_.as_DataType = ca.begin();
    coeffarray_end_.as_DataType = ca.end();
    assert( coeff_length_ == ca.size() );
  }
 
  std::vector< unsigned int >::iterator&
  operator<<( std::vector< unsigned int >::iterator& pos ) override
  {
    // The synid can be skipped here as it is stored in a static vector
 
    // generating a copy of the coeffarray is too time consuming
    // therefore we save an iterator to the beginning+end of the coeffarray
    coeffarray_begin_.as_uint = pos;
 
    pos += coeff_length_ * number_of_uints_covered< DataType >();
 
    coeffarray_end_.as_uint = pos;
 
    return pos;
  }
 
  std::vector< unsigned int >::iterator&
  operator>>( std::vector< unsigned int >::iterator& pos ) override
  {
    for ( auto it = coeffarray_begin_.as_DataType; it != coeffarray_end_.as_DataType; ++it )
    {
      // we need the static_cast here as the size of a stand-alone variable
      // and a std::vector entry may differ (e.g. for std::vector< bool >)
      write_to_comm_buffer( static_cast< DataType >( *it ), pos );
    }
    return pos;
  }
 
  size_t
  size() override
  {
    size_t s = number_of_uints_covered< synindex >();
    s += number_of_uints_covered< size_t >();
    s += number_of_uints_covered< DataType >() * coeff_length_;
 
    return s;
  }
 
  const std::vector< unsigned int >::iterator&
  begin()
  {
    return coeffarray_begin_.as_uint;
  }
 
  const std::vector< unsigned int >::iterator&
  end()
  {
    return coeffarray_end_.as_uint;
  }
 
  DataType get_coeffvalue( std::vector< unsigned int >::iterator& pos );
};
 
class GapJunctionEvent : public DataSecondaryEvent< double, GapJunctionEvent >
{
 
public:
  GapJunctionEvent()
  {
  }
 
  void operator()() override;
  GapJunctionEvent* clone() const override;
};
 
class InstantaneousRateConnectionEvent : public DataSecondaryEvent< double, InstantaneousRateConnectionEvent >
{
 
public:
  InstantaneousRateConnectionEvent()
  {
  }
 
  void operator()() override;
  InstantaneousRateConnectionEvent* clone() const override;
};
 
class DelayedRateConnectionEvent : public DataSecondaryEvent< double, DelayedRateConnectionEvent >
{
 
public:
  DelayedRateConnectionEvent()
  {
  }
 
  void operator()() override;
  DelayedRateConnectionEvent* clone() const override;
};
 
 
class DiffusionConnectionEvent : public DataSecondaryEvent< double, DiffusionConnectionEvent >
{
private:
  // drift factor of the corresponding connection
  double drift_factor_;
  // diffusion factor of the corresponding connection
  double diffusion_factor_;
 
public:
  DiffusionConnectionEvent()
  {
  }
 
  void operator()() override;
  DiffusionConnectionEvent* clone() const override;
 
  void
  set_diffusion_factor( double t ) override
  {
    diffusion_factor_ = t;
  };
 
  void
  set_drift_factor( double t ) override
  {
    drift_factor_ = t;
  };
 
  double get_drift_factor() const;
  double get_diffusion_factor() const;
};
 
class LearningSignalConnectionEvent : public DataSecondaryEvent< double, LearningSignalConnectionEvent >
{
 
public:
  LearningSignalConnectionEvent()
  {
  }
 
  void operator()() override;
  LearningSignalConnectionEvent* clone() const override;
};
 
template < typename DataType, typename Subclass >
inline DataType
DataSecondaryEvent< DataType, Subclass >::get_coeffvalue( std::vector< unsigned int >::iterator& pos )
{
  DataType elem;
  read_from_comm_buffer( elem, pos );
  return elem;
}
 
template < typename DataType, typename Subclass >
std::set< synindex > DataSecondaryEvent< DataType, Subclass >::supported_syn_ids_;
 
template < typename DataType, typename Subclass >
size_t DataSecondaryEvent< DataType, Subclass >::coeff_length_ = 0;
 
inline GapJunctionEvent*
GapJunctionEvent::clone() const
{
  return new GapJunctionEvent( *this );
}
 
inline InstantaneousRateConnectionEvent*
InstantaneousRateConnectionEvent::clone() const
{
  return new InstantaneousRateConnectionEvent( *this );
}
 
inline DelayedRateConnectionEvent*
DelayedRateConnectionEvent::clone() const
{
  return new DelayedRateConnectionEvent( *this );
}
 
inline DiffusionConnectionEvent*
DiffusionConnectionEvent::clone() const
{
  return new DiffusionConnectionEvent( *this );
}
 
inline double
DiffusionConnectionEvent::get_drift_factor() const
{
  return drift_factor_;
}
 
inline double
DiffusionConnectionEvent::get_diffusion_factor() const
{
  return diffusion_factor_;
}
 
inline LearningSignalConnectionEvent*
LearningSignalConnectionEvent::clone() const
{
  return new LearningSignalConnectionEvent( *this );
}
 
class SICEvent : public DataSecondaryEvent< double, SICEvent >
{
 
public:
  SICEvent()
  {
  }
 
  void operator()();
  SICEvent* clone() const;
};
 
inline SICEvent*
SICEvent::clone() const
{
  return new SICEvent( *this );
}
 
}  // namespace nest
 
#endif /* #ifndef SECONDARY_EVENT_H */