---

readout.h

Go to the documentation of this file.

#ifndef _READOUT_H_
#define _READOUT_H_

#include "advanceable.h"
#include "analogfilter.h"
#include "spikefilter.h"
#include "preprocessor.h"
#include "algorithm.h"
#include <list>
#include <string>
#include <pthread.h>
#include "csimclass.h"
#include "modelinput.h"

#define EPSILON 10e-20




class Readout : public Advancable, public ModelInput {

  DO_REGISTERING

 public:
 
  Readout(void);

  ~Readout(void);

  virtual int advance();

  virtual int addIncoming(Advancable *Incoming);

  virtual int addOutgoing(Advancable *a);

  virtual int addInputField(csimClass *O, char *fieldname);

  virtual void reset();

  void setAnalogFilter(AnalogFilter *af);

  void setSpikeFilter(SpikeFilter *sf);

  int appendPreprocessor(Preprocessor *pp);

  int prependPreprocessor(Preprocessor *pp);

  int insertPreprocessor(Preprocessor *pp, int position);

  int getNumberPreprocessors();

  int importPreprocessor(int ind, double *rep, int rep_length);

  double* exportPreprocessor(int ind, int *rep_length);

  string getPreprocessorFormatDescription(int ind);

  int setLearningAlgorithm(Algorithm *learner);

  int importAlgorithm(double *rep, int rep_length);

  double* exportAlgorithm(int *rep_length);

  string getAlgorithmFormatDescription();


  void setRange(double lower_bound, double upper_bound);



  inline uint32 getAnalogFilterID(void)  { if (analogFilter) return analogFilter->getId(); else return 0; }

  inline bool hasAnalogFilter(void) { return (analogFilter != 0); }

  inline uint32 getSpikeFilterID(void) { if (spikeFilter) return spikeFilter->getId(); else return 0; };

  inline bool hasSpikeFilter(void) { return (spikeFilter != 0); }

  inline uint32 getAlgorithmID(void) { if (algorithm) return algorithm->getId(); else return 0; };

  inline bool hasAlgorithm(void) { return (algorithm != 0); }

  void getPreprocessorIDs(uint32 *idx);


  int enabled;

  
  double offset;

  double range;


  // We must also implement some recorder interface, because we want to use
  // not only the psr of neurons as input, but also other fields


 protected:
  
  struct RecField {
    short      i;  

    csimClass *o;  

    char *p;

    short type;
  };

  int add(RecField *f);
  

  int nRecFields;

  int lRecFields;

  RecField **recFields;

  int nAnalogFields;
  int lAnalogFields;

  int *analogIndices;

  int nSpikingFields;
  int lSpikingFields;

  int *spikingIndices;



  SynapseTarget **outgoing;

  int nOutgoing;
  int lOutgoing;




  //  double output;

  list<Preprocessor *> pre_processors;

  AnalogFilter *analogFilter;

  SpikeFilter *spikeFilter;

  Algorithm *algorithm;


  static double* m_response;
  static double* m_target;

  static int lReservedMemory;

  static pthread_mutex_t mutex_temp_memory;

  static int nReadouts;

};


#endif

---