universal_data_logger.h

Go to the documentation of this file.

/*
 *  universal_data_logger.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 UNIVERSAL_DATA_LOGGER_H
#define UNIVERSAL_DATA_LOGGER_H
 
// C++ includes:
#include <algorithm>
#include <vector>
 
// Includes from nestkernel:
#include "event.h"
#include "nest_time.h"
#include "nest_types.h"
#include "recordables_map.h"
 
namespace nest
{
template < typename HostNode >
class UniversalDataLogger
{
 
public:
  UniversalDataLogger( HostNode& );
 
  size_t connect_logging_device( const DataLoggingRequest&, const RecordablesMap< HostNode >& );
 
  void handle( const DataLoggingRequest& );
 
  void record_data( long );
 
  void reset();
 
  void init();
 
private:
  class DataLogger_
  {
  public:
    DataLogger_( const DataLoggingRequest&, const RecordablesMap< HostNode >& );
    size_t
    get_mm_node_id() const
    {
      return multimeter_;
    }
    void handle( HostNode&, const DataLoggingRequest& );
    void record_data( const HostNode&, long );
    void reset();
    void init();
 
  private:
    size_t multimeter_;  
    size_t num_vars_;    
 
    Time recording_interval_;  
    Time recording_offset_;    
    long rec_int_steps_;       
    long next_rec_step_;       
 
    std::vector< typename RecordablesMap< HostNode >::DataAccessFct > node_access_;
 
    std::vector< DataLoggingReply::Container > data_;
 
    std::vector< size_t > next_rec_;
  };
 
  HostNode& host_;  
 
  std::vector< DataLogger_ > data_loggers_;
  typedef typename std::vector< DataLogger_ >::iterator DLiter_;
 
  UniversalDataLogger( const UniversalDataLogger& );
 
  UniversalDataLogger const& operator=( const UniversalDataLogger& );
};
 
// must be defined in this file, since it is required by check_connection(),
// which typically is in h-files.
template < typename HostNode >
size_t
UniversalDataLogger< HostNode >::connect_logging_device( const DataLoggingRequest& req,
  const RecordablesMap< HostNode >& rmap )
{
  // rports are assigned consecutively, the caller may not request specific
  // rports.
  if ( req.get_rport() != 0 )
  {
    throw IllegalConnection( "Connections from multimeter to node must request rport 0." );
  }
 
  // ensure that we have not connected this multimeter before
  const size_t mm_node_id = req.get_sender().get_node_id();
 
  const auto item = std::find_if( data_loggers_.begin(),
    data_loggers_.end(),
    [ & ]( const DataLogger_& dl ) { return dl.get_mm_node_id() == mm_node_id; } );
 
  if ( item != data_loggers_.end() )
  {
    throw IllegalConnection( "Each multimeter can only be connected once to a given node." );
  }
 
  // we now know that we have no DataLogger_ for the given multimeter, so we
  // create one and push it
  data_loggers_.push_back( DataLogger_( req, rmap ) );
 
  // rport is index plus one, i.e., size
  return data_loggers_.size();
}
 
template < typename HostNode >
UniversalDataLogger< HostNode >::DataLogger_::DataLogger_( const DataLoggingRequest& req,
  const RecordablesMap< HostNode >& rmap )
  : multimeter_( req.get_sender().get_node_id() )
  , num_vars_( 0 )
  , recording_interval_( Time::neg_inf() )
  , recording_offset_( Time::ms( 0. ) )
  , rec_int_steps_( 0 )
  , next_rec_step_( -1 )  // flag as uninitialized
  , node_access_()
  , data_()
  , next_rec_( 2, 0 )
{
  const std::vector< std::string >& recvars = req.record_from();
  for ( size_t j = 0; j < recvars.size(); ++j )
  {
    typename RecordablesMap< HostNode >::const_iterator rec = rmap.find( recvars[ j ] );
 
    if ( rec == rmap.end() )
    {
      // delete all access information again: the connect either succeeds
      // for all entries in recvars, or it fails, leaving the logger untouched
      node_access_.clear();
      throw IllegalConnection( "Cannot connect with unknown recordable " + recvars[ j ] );
    }
 
    node_access_.push_back( rec->second );
  }
 
  num_vars_ = node_access_.size();
 
  if ( num_vars_ > 0 and req.get_recording_interval() < Time::step( 1 ) )
  {
    throw IllegalConnection( "Recording interval must be >= resolution." );
  }
 
  recording_interval_ = req.get_recording_interval();
  recording_offset_ = req.get_recording_offset();
}
 
 
template < typename HostNode >
class DynamicUniversalDataLogger
{
 
public:
  DynamicUniversalDataLogger( HostNode& );
 
  size_t connect_logging_device( const DataLoggingRequest&, const DynamicRecordablesMap< HostNode >& );
 
  void handle( const DataLoggingRequest& );
 
  void record_data( long );
 
  void reset();
 
  void init();
 
private:
  class DataLogger_
  {
  public:
    DataLogger_( const DataLoggingRequest&, const DynamicRecordablesMap< HostNode >& );
    size_t
    get_mm_node_id() const
    {
      return multimeter_;
    }
    void handle( HostNode&, const DataLoggingRequest& );
    void record_data( const HostNode&, long );
    void reset();
    void init();
 
  private:
    size_t multimeter_;  
    size_t num_vars_;    
 
    Time recording_interval_;  
    Time recording_offset_;    
    long rec_int_steps_;       
    long next_rec_step_;       
 
    std::vector< const typename DynamicRecordablesMap< HostNode >::DataAccessFct* > node_access_;
 
    std::vector< DataLoggingReply::Container > data_;
 
    std::vector< size_t > next_rec_;
  };
 
  HostNode& host_;  
 
  std::vector< DataLogger_ > data_loggers_;
  typedef typename std::vector< DataLogger_ >::iterator DLiter_;
 
  DynamicUniversalDataLogger( const DynamicUniversalDataLogger& );
 
  DynamicUniversalDataLogger const& operator=( const DynamicUniversalDataLogger& );
};
 
 
// must be defined in this file, since it is required by check_connection(),
// which typically is in h-files.
template < typename HostNode >
size_t
DynamicUniversalDataLogger< HostNode >::connect_logging_device( const DataLoggingRequest& req,
  const DynamicRecordablesMap< HostNode >& rmap )
{
  // rports are assigned consecutively, the caller may not request specific
  // rports.
  if ( req.get_rport() != 0 )
  {
    throw IllegalConnection( "Connections from multimeter to node must request rport 0." );
  }
 
  // ensure that we have not connected this multimeter before
  const size_t mm_node_id = req.get_sender().get_node_id();
  const size_t n_loggers = data_loggers_.size();
  size_t j = 0;
  while ( j < n_loggers and data_loggers_[ j ].get_mm_node_id() != mm_node_id )
  {
    ++j;
  }
  if ( j < n_loggers )
  {
    throw IllegalConnection( "Each multimeter can only be connected once to a given node." );
  }
 
  // we now know that we have no DataLogger_ for the given multimeter, so we
  // create one and push it
  data_loggers_.push_back( DataLogger_( req, rmap ) );
 
  // rport is index plus one, i.e., size
  return data_loggers_.size();
}
 
template < typename HostNode >
DynamicUniversalDataLogger< HostNode >::DataLogger_::DataLogger_( const DataLoggingRequest& req,
  const DynamicRecordablesMap< HostNode >& rmap )
  : multimeter_( req.get_sender().get_node_id() )
  , num_vars_( 0 )
  , recording_interval_( Time::neg_inf() )
  , recording_offset_( Time::ms( 0. ) )
  , rec_int_steps_( 0 )
  , next_rec_step_( -1 )
  ,  // flag as uninitialized
  node_access_()
  , data_()
  , next_rec_( 2, 0 )
{
  const std::vector< std::string >& recvars = req.record_from();
  for ( size_t j = 0; j < recvars.size(); ++j )
  {
    typename DynamicRecordablesMap< HostNode >::const_iterator rec = rmap.find( recvars[ j ] );
 
    if ( rec == rmap.end() )
    {
      // delete all access information again: the connect either succeeds
      // for all entries in recvars, or it fails, leaving the logger untouched
      node_access_.clear();
      throw IllegalConnection( "Cannot connect with unknown recordable " + recvars[ j ] );
    }
 
    node_access_.push_back( &( rec->second ) );
  }
 
  num_vars_ = node_access_.size();
 
  if ( num_vars_ > 0 and req.get_recording_interval() < Time::step( 1 ) )
  {
    throw IllegalConnection( "Recording interval must be >= resolution." );
  }
 
  recording_interval_ = req.get_recording_interval();
  recording_offset_ = req.get_recording_offset();
}
 
}  // namespace nest
 
#endif /* #ifndef UNIVERSAL_DATA_LOGGER_H */