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

#include "nest.h"
#include "event.h"
#include "recordables_map.h"
#include "nest_time.h"

#include <vector>

namespace nest {

  class Network;
  
   template <typename HostNode>
   class UniversalDataLogger {

   public:
     
     UniversalDataLogger(HostNode&);
        
     port connect_logging_device(const DataLoggingRequest&,
                 const RecordablesMap<HostNode>&);

     void handle(const DataLoggingRequest&);
     
     void record_data(long_t);

     void reset();

     void init();

   private:

     class DataLogger_ {
     public:
       DataLogger_(const DataLoggingRequest&,
                   const RecordablesMap<HostNode>&);
       index get_mm_gid() const { return multimeter_; }
       void handle(HostNode&, const DataLoggingRequest&);
       void record_data(const HostNode&, long_t);
       void reset();
       void init();

     private:
       index  multimeter_;         
       size_t num_vars_;           

       Time   recording_interval_; 
       long_t rec_int_steps_;      
       long_t 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>
     port nest::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("UniversalDataLogger::connect_logging_device(): "
                   "Connections from multimeter to node must request rport 0.");

     // ensure that we have not connected this multimeter before
     const index  mm_gid = req.get_sender().get_gid();
     const size_t n_loggers = data_loggers_.size();
     size_t j = 0;
     while ( j < n_loggers && data_loggers_[j].get_mm_gid() != mm_gid )
       ++j;
     if ( j < n_loggers )
       throw IllegalConnection("UniversalDataLogger::connect_logging_device(): "
                               "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>
   nest::UniversalDataLogger<HostNode>::DataLogger_::DataLogger_(const DataLoggingRequest& req,
                                                                 const RecordablesMap<HostNode>& rmap):
      multimeter_(req.get_sender().get_gid()),
      num_vars_(0),
      recording_interval_(Time::neg_inf()),
      rec_int_steps_(0),
      next_rec_step_(-1),  // flag as uninitialized
      node_access_(),
      data_(),
      next_rec_(2,0)
   {
     const std::vector<Name>& recvars = req.record_from();
     for ( size_t j = 0 ; j < recvars.size() ; ++j )
       {
     typename RecordablesMap<HostNode>::const_iterator rec
       = rmap.find(recvars[j].toString());  // .toString() required as work-around for #339, 
                                            // remove when #348 is solved.

     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("UniversalDataLogger::connect_logging_device(): "
                   "Unknown recordable " + recvars[j].toString());
     }

     node_access_.push_back(rec->second);
       }

     num_vars_ = node_access_.size();

     if ( num_vars_ > 0 && req.get_recording_interval() < Time::step(1) )
       throw IllegalConnection("UniversalDataLogger::connect_logging_device(): "
                   "recording interval must be >= resolution.");

     recording_interval_ = req.get_recording_interval();
   }
   
}

#endif // UNIVERSAL_DATA_LOGGER_H