spike_data.h

Go to the documentation of this file.

/*
 *  spike_data.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 SPIKE_DATA_H
#define SPIKE_DATA_H
 
// C++ includes
#include <cassert>
 
// Includes from nestkernel:
#include "nest_types.h"
#include "target.h"
 
 
namespace nest
{
 
enum enum_status_spike_data_id
{
  SPIKE_DATA_ID_DEFAULT,
  SPIKE_DATA_ID_END,
  SPIKE_DATA_ID_COMPLETE,
  SPIKE_DATA_ID_INVALID
};
 
enum enum_flush_event
{
  FLUSH_EVENT_FALSE,
  FLUSH_EVENT_TRUE
};
 
class SpikeData
{
protected:
  static constexpr int MAX_LAG = generate_max_value( NUM_BITS_LAG );
 
  size_t lcid_ : NUM_BITS_LCID;                       
  unsigned int marker_ : NUM_BITS_MARKER_SPIKE_DATA;  
  unsigned int flush_event_ : NUM_BITS_FLUSH_EVENT;   
  unsigned int lag_ : NUM_BITS_LAG;                   
  unsigned int tid_ : NUM_BITS_TID;                   
  synindex syn_id_ : NUM_BITS_SYN_ID;                 
 
public:
  SpikeData();
  SpikeData( const SpikeData& rhs );
  SpikeData( const Target& target, const size_t lag, const bool is_flush_event );
  SpikeData( const size_t tid, const synindex syn_id, const size_t lcid, const unsigned int lag );
 
  SpikeData& operator=( const SpikeData& rhs );
 
  void set( const size_t tid, const synindex syn_id, const size_t lcid, const unsigned int lag, const double offset );
 
  template < class TargetT >
  void set( const TargetT& target, const unsigned int lag );
 
  size_t get_lcid() const;
 
  void set_lcid( size_t );
 
  unsigned int get_lag() const;
 
  size_t get_tid() const;
 
  synindex get_syn_id() const;
 
  unsigned int get_marker() const;
 
  void reset_marker();
 
  void set_complete_marker();
 
  void set_end_marker();
 
  void set_invalid_marker();
 
  bool is_complete_marker() const;
 
  bool is_end_marker() const;
 
  bool is_invalid_marker() const;
 
  bool is_flush_event() const;
 
  double get_offset() const;
 
  void set_flush_event_flag( bool is_flush_event );
};
 
using success_spike_data_size = StaticAssert< sizeof( SpikeData ) == 8 >::success;
 
inline SpikeData::SpikeData()
  : lcid_( 0 )
  , marker_( SPIKE_DATA_ID_DEFAULT )
  , flush_event_( FLUSH_EVENT_FALSE )
  , lag_( 0 )
  , tid_( 0 )
  , syn_id_( 0 )
{
}
 
inline SpikeData::SpikeData( const SpikeData& rhs )
  : lcid_( rhs.lcid_ )
  , marker_( rhs.marker_ )
  , flush_event_( rhs.flush_event_ )
  , lag_( rhs.lag_ )
  , tid_( rhs.tid_ )
  , syn_id_( rhs.syn_id_ )
{
}
 
inline SpikeData::SpikeData( const Target& target, const size_t lag, const bool is_flush_event )
  : lcid_( target.get_lcid() )
  , marker_( SPIKE_DATA_ID_DEFAULT )
  , flush_event_( FLUSH_EVENT_FALSE )
  , lag_( lag )
  , tid_( target.get_tid() )
  , syn_id_( target.get_syn_id() )
{
  if ( is_flush_event )
  {
    flush_event_ = FLUSH_EVENT_TRUE;
  }
}
 
inline SpikeData::SpikeData( const size_t tid, const synindex syn_id, const size_t lcid, const unsigned int lag )
  : lcid_( lcid )
  , marker_( SPIKE_DATA_ID_DEFAULT )
  , flush_event_( FLUSH_EVENT_FALSE )
  , lag_( lag )
  , tid_( tid )
  , syn_id_( syn_id )
{
}
 
inline SpikeData&
SpikeData::operator=( const SpikeData& rhs )
{
  lcid_ = rhs.lcid_;
  marker_ = rhs.marker_;
  flush_event_ = rhs.flush_event_;
  lag_ = rhs.lag_;
  tid_ = rhs.tid_;
  syn_id_ = rhs.syn_id_;
  return *this;
}
 
inline void
SpikeData::set( const size_t tid, const synindex syn_id, const size_t lcid, const unsigned int lag, const double )
{
  assert( tid <= MAX_TID );  // MAX_TID is allowed since it is not used as invalid value
  assert( syn_id < MAX_SYN_ID );
  assert( lcid < MAX_LCID );
  assert( lag < MAX_LAG );
 
  lcid_ = lcid;
  marker_ = SPIKE_DATA_ID_DEFAULT;
  lag_ = lag;
  tid_ = tid;
  syn_id_ = syn_id;
}
 
 
template < class TargetT >
inline void
SpikeData::set( const TargetT& target, const unsigned int lag )
{
  // the assertions in the above function are granted by the TargetT object!
  assert( lag < MAX_LAG );
  lcid_ = target.get_lcid();
  marker_ = SPIKE_DATA_ID_DEFAULT;
  lag_ = lag;
  tid_ = target.get_tid();
  syn_id_ = target.get_syn_id();
}
 
inline size_t
SpikeData::get_lcid() const
{
  return lcid_;
}
 
inline void
SpikeData::set_lcid( size_t value )
{
  assert( value < MAX_LCID );
  lcid_ = value;
}
 
inline unsigned int
SpikeData::get_lag() const
{
  return lag_;
}
 
inline size_t
SpikeData::get_tid() const
{
  return tid_;
}
 
inline synindex
SpikeData::get_syn_id() const
{
  return syn_id_;
}
 
inline unsigned int
SpikeData::get_marker() const
{
  return marker_;
}
 
inline void
SpikeData::reset_marker()
{
  marker_ = SPIKE_DATA_ID_DEFAULT;
}
 
inline void
SpikeData::set_complete_marker()
{
  marker_ = SPIKE_DATA_ID_COMPLETE;
}
 
inline void
SpikeData::set_end_marker()
{
  marker_ = SPIKE_DATA_ID_END;
}
 
inline void
SpikeData::set_invalid_marker()
{
  marker_ = SPIKE_DATA_ID_INVALID;
}
 
inline bool
SpikeData::is_complete_marker() const
{
  return marker_ == SPIKE_DATA_ID_COMPLETE;
}
 
inline bool
SpikeData::is_end_marker() const
{
  return marker_ == SPIKE_DATA_ID_END;
}
 
inline bool
SpikeData::is_invalid_marker() const
{
  return marker_ == SPIKE_DATA_ID_INVALID;
}
 
inline bool
SpikeData::is_flush_event() const
{
  return flush_event_ == FLUSH_EVENT_TRUE;
}
 
inline double
SpikeData::get_offset() const
{
  return 0;
}
 
inline void
SpikeData::set_flush_event_flag( bool is_flush_event )
{
  flush_event_ = is_flush_event ? FLUSH_EVENT_TRUE : FLUSH_EVENT_FALSE;
}
 
class OffGridSpikeData : public SpikeData
{
private:
  double offset_;
 
public:
  OffGridSpikeData();
  OffGridSpikeData( const Target& target, const size_t lag, const double offset );
  OffGridSpikeData( const size_t tid,
    const synindex syn_id,
    const size_t lcid,
    const unsigned int lag,
    const double offset );
  OffGridSpikeData( const OffGridSpikeData& rhs );
  OffGridSpikeData& operator=( const OffGridSpikeData& rhs );
  OffGridSpikeData& operator=( const SpikeData& rhs );
  void set( const size_t tid, const synindex syn_id, const size_t lcid, const unsigned int lag, const double offset );
 
  template < class TargetT >
  void set( const TargetT& target, const unsigned int lag );
  double get_offset() const;
};
 
using success_offgrid_spike_data_size = StaticAssert< sizeof( OffGridSpikeData ) == 16 >::success;
 
inline OffGridSpikeData::OffGridSpikeData()
  : SpikeData()
  , offset_( 0.0 )
{
}
 
inline OffGridSpikeData::OffGridSpikeData( const Target& target, const size_t lag, const double offset )
  : SpikeData( target, lag, false )
  , offset_( offset )
{
}
 
inline OffGridSpikeData::OffGridSpikeData( const size_t tid,
  const synindex syn_id,
  const size_t lcid,
  const unsigned int lag,
  const double offset )
  : SpikeData( tid, syn_id, lcid, lag )
  , offset_( offset )
{
}
 
inline OffGridSpikeData::OffGridSpikeData( const OffGridSpikeData& rhs )
  : SpikeData( rhs )
  , offset_( rhs.offset_ )
{
}
 
inline OffGridSpikeData&
OffGridSpikeData::operator=( const OffGridSpikeData& rhs )
{
  lcid_ = rhs.lcid_;
  marker_ = rhs.marker_;
  lag_ = rhs.lag_;
  tid_ = rhs.tid_;
  syn_id_ = rhs.syn_id_;
  offset_ = rhs.offset_;
  return *this;
}
 
inline OffGridSpikeData&
OffGridSpikeData::operator=( const SpikeData& rhs )
{
  // Need to use get_*() here, direct access to protected members of base-class instance is prohibited,
  // see example in https://en.cppreference.com/w/cpp/language/access.
  lcid_ = rhs.get_lcid();
  marker_ = rhs.get_marker();
  lag_ = rhs.get_lag();
  tid_ = rhs.get_tid();
  syn_id_ = rhs.get_syn_id();
  offset_ = 0;
  return *this;
}
 
inline void
OffGridSpikeData::set( const size_t tid,
  const synindex syn_id,
  const size_t lcid,
  const unsigned int lag,
  const double offset )
{
  assert( tid <= MAX_TID );  // MAX_TID is allowed since it is not used as invalid value
  assert( syn_id < MAX_SYN_ID );
  assert( lcid < MAX_LCID );
  assert( lag < MAX_LAG );
 
  lcid_ = lcid;
  marker_ = SPIKE_DATA_ID_DEFAULT;
  lag_ = lag;
  tid_ = tid;
  syn_id_ = syn_id;
  offset_ = offset;
}
 
 
template < class TargetT >
inline void
OffGridSpikeData::set( const TargetT& target, const unsigned int lag )
{
  SpikeData::set( target, lag );
  offset_ = target.get_offset();
}
 
inline double
OffGridSpikeData::get_offset() const
{
  return offset_;
}
 
 
struct SpikeDataWithRank
{
  SpikeDataWithRank( const Target& target, const size_t lag, const bool is_flush_event );
 
  const size_t rank;           
  const SpikeData spike_data;  
};
 
inline SpikeDataWithRank::SpikeDataWithRank( const Target& target, const size_t lag, const bool is_flush_event )
  : rank( target.get_rank() )
  , spike_data( target, lag, is_flush_event )
{
}
 
struct OffGridSpikeDataWithRank
{
  OffGridSpikeDataWithRank( const Target& target, const size_t lag, const double offset );
 
  const size_t rank;                  
  const OffGridSpikeData spike_data;  
};
 
inline OffGridSpikeDataWithRank::OffGridSpikeDataWithRank( const Target& target, const size_t lag, const double offset )
  : rank( target.get_rank() )
  , spike_data( target, lag, offset )
{
}
 
 
}  // namespace nest
 
#endif /* SPIKE_DATA_H */