// =======================================================================================
// F2_delay.h
// Time-stamp: <2004-02-25 15:30:00 aknoblau>
// Definition of delay types for support of connections
// programmed in June 2001 by Andreas Knoblauch
// Department of Neural Information Processing
// University of Ulm, Germany
// Version 1.0 alpha
// last documented change: June 6, 2001
// =======================================================================================
// types/classes/interfaces:
// TDelay
// TMKernelDelay
// ---------------------------------------------------------------------------------------
// global objects:
// ---------------------------------------------------------------------------------------
// related modules:
// ---------------------------------------------------------------------------------------
// notes:
// ---------------------------------------------------------------------------------------
// history:
// Version 1.0 alpha programmed on June 6, 2001 by Andreas Knoblauch
// ---------------------------------------------------------------------------------------
// bugs:
// ---------------------------------------------------------------------------------------
// 2 do:
// =======================================================================================
#ifndef F2_delay_H
#define F2_delay_H
#include "F2_types.h"
#include "F2_parser.h"
#include "F2_kernel.h"
#include "F2_simenv.h"
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TDelay
* Base class for all multi-modal Delays
*
* @short Base class for all multi-modal Delays
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: June 6, 2001
*/
class TDelay {
// **************************************************************************************************************************
public:
TSimulationEnvironment& simEnv;
string name; // id
int maxDelayAllowed; // maximal allowed delays in simulation steps
int multiModalFlag; // set if more than one delay mode is p o s s i b l e
TiPar parNModes; // parameter for parsing of nModes
int& nModes; // number of modes (reference to parNModes)
int *minModeDelay; // for each mode, the minimal delay in simulation steps
int *maxModeDelay; // for each mode, the maximal delay in simulation steps
int minDelay,maxDelay; // minimal and maximal delay for all modes in simulation steps
TDelay(TSimulationEnvironment& simenv_arg, TParamOwner* owner, // constructor (default)
const char* name_arg, int maxDelayAllowed_arg, int multiModalFlag_arg);
TDelay(TSimulationEnvironment& simenv_arg, TParamOwner* owner,
const char* name_arg, int maxDelayAllowed_arg, int multiModalFlag_arg, int parse); // " (complete)
TDelay(const TDelay& pattern, TParamOwner* owner, // " (patterned)
const char* name_arg, int maxDelayAllowed_arg);
~TDelay(); // destructor
void resize(); // reallocate arrays
void resize(int nModes_new); // set nModes to new value nModes_new and reallocate arrays
void prepSetParameters(); // should be called by descendants to prepare setting of parameters
void prepSetParameters(int mode); // only one mode is prepared
inline void checkDelayLimits(int del); // checks if delay is in allowed range, and actualizes extremas
inline void checkDelayLimits(int mode, int del); // checks if delay is in allowed range, and actualizes extremas
void outputLimits(ostream & os); // output the limits
void outputLimits(ostream & os, int mode); // output the limits of one mode and the total limits
void reparseConstruct(vector& repPars); // reparse parameters; adds reparsed parameters to repPars
void reparseDelete(vector& repPars); // reparse parameters; removes reparsed parameters from repPars
int handleUpdatedParameters(); // handle parameters updated by sliders or reparsing
void outputState(ostream & os) const; // output of all fields
friend ostream& operator<<(ostream& os, const TDelay& delay); // stream output
friend istream& operator>>(istream& is, TDelay& delay); // input via parser
};
ostream& operator<<(ostream& os, const TDelay& delay); // stream output
istream& operator<<(istream& is, TDelay& delay); // stream input
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TDelayDist
* Base class for specification of distance dependence for synaptic delays according to various distance measures
*
* @short Base class for specification of distance dependence for synaptic delays according to various distance measures
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: June 6, 2001
*/
class TDelayDist {
// **************************************************************************************************************************
public:
static const char* DT_RECT; // delay type RECT: distance is computed rectangular
static const char* DT_DIAG; // delay type DIAG: distance is computed diagonal
static const char* DT_CIRC; // delay type CIRC: distance is computed circular
// reference to stepSize_inv
TFloat& stepSize_inv; // needed for
// parameter
TVecPar parBaseDelay; // the delay between a spike of neuron i and its arrival at neuron j is computed as follows:
TVecPar parDistDelay; // delay = baseDelay + dist(straighDist,branchDist,dType)*distDelay
TPar parStraightDist; // and dist1(d) is computed according to parDistanceType
TsPar parDistType; // either "RECT", "DIAG", or "CIRC"; see also AB2/38 page 139
TFloat& straightDist; // reference to parStraightDist
char* dType; // either DT_RECT, DT_DIAG or DT_CIRC, according to parDistType
// constructors/destructors
TDelayDist(TSimulationEnvironment& simEnv, TParamOwner *owner, int nModes); // constructor (default version 1)
TDelayDist(TParamOwner *owner, TFloat& stepSize_inv_arg, int nModes); // " (default version 2)
TDelayDist(TSimulationEnvironment& simEnv, TParamOwner *owner, int nModes, int parse); // " (complete version 1)
TDelayDist(const TDelayDist& copy, TParamOwner *owner); // " (patterned)
~TDelayDist(); // destructor
// methods
void resize(int nModes_new); // resize to nModes_new modes
void setDefaultParameters(); // set default parameters (called by the default constructors)
inline TFloat distRECT(TFloat branchDist); // RECT distance: simply addition of straightDist and branchDist
inline TFloat distDIAG(TFloat branchDist); // DIAG distance: Euklidian length of vector (straightDist, branchDist)
inline TFloat distCIRC(TFloat branchDist); // CIRC distance: between RECT and DIAG distance acc. to circular curvation
inline TFloat dist(TFloat branchDist); // chooses one of the distances above according to dType; see AB2/38 page 139
inline TFloat getDelay(int mode, TFloat branchDist); // returns delay according to branchDist for mode in TFloat (usually in msec)
inline int getDelaySteps(int mode, TFloat branchDist); // returns delay according to branchDist for mode in simulation steps
void reparseConstruct(TParser& parser, vector& repPars); // reparse parameters; adds reparsed parameters to repPars
void reparseDelete(vector& repPars); // reparse parameters; remove reparsed parameters from repPars
int handleUpdatedParameters(); // handle parameters updated by sliders or reparsing
void outputState(ostream & os) const; // output of all fields
friend ostream& operator<<(ostream& os, const TDelayDist& delay); // stream output
friend istream& operator>>(istream& is, TDelayDist& delay); // stream input
protected:
void create(); // create object (called by all constructors)
};
ostream& operator<<(ostream& os, const TDelayDist& delay); // stream output
istream& operator>>(istream& is, TDelayDist& delay); // stream input
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TDelayNoise
* Base class for specification of noisy synaptic delays
*
* @short Base class for specification of noisy synaptic delays
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: June 6, 2001
*/
class TDelayNoise {
// **************************************************************************************************************************
public:
static const char* DN_FIXED; // indicates that the delay noise should be generated only once and then memorized
static const char* DN_VOLATILE; // delay noise should be generated each time a spike is propagated (to save memory)
// reference to a random generator
TRand& randGen; // random generator for getNoiseDelay()
// parameters
TsPar parNoiseType; // either string(DN_FIXED) or string(DN_VOLATILE), usually used by descendants
TVecPar parPowerDelayNoise; // noise power factor used for randGen.randLUT(...)
TVecPar parMinDelayNoise; // minimum noise delay
TVecPar parMaxDelayNoise; // maximum noise delay
TVecPar parLimitsDelayNoise; // soft and hard limits for call to randGen.randLUT(...)
char* noiseType; // reference to parNoiseType
TFloat& softLimit; // reference to parLimitsDelayNoise[0]
TFloat& hardLimit; // reference to parLimitsDelayNoise[1]
// constructors/destructors
TDelayNoise(TSimulationEnvironment& simEnv, TParamOwner* owner, // constructor (default version 1)
int nModes);
TDelayNoise(TSimulationEnvironment& simEnv, TParamOwner* owner, // " (default version 2)
int nModes, TRand& randGen_arg);
TDelayNoise(TSimulationEnvironment& simEnv, TParamOwner* owner, // " (complete version 1)
int nModes, int parse);
TDelayNoise(TSimulationEnvironment& simEnv, TParamOwner* owner, // " (complete version 2)
int nModes, TRand& randGen_arg, int parse);
TDelayNoise(const TDelayNoise& copy, TParamOwner* owner); // " (patterned)
~TDelayNoise(); // destructor
// methods
void resize(int nModes_new); // resize arrays to nModes_new modes
void setDefaultParameters(); // set default parameters (i.e. no noise at all)
inline TFloat getNoiseDelay(); // returns noise delay of randGen.randLUT()
inline TFloat getNoiseDelay(TMLookUpTable& lut); // returns noise delay of randGen.randLUT(lut)
inline TFloat getNoiseDelay(TFloat offset); // returns noise delay of randGen.randLUT(offset)
inline TFloat getNoiseDelay(TFloat offset, TMLookUpTable& lut); // returns noise delay of randGen.randLUT(offset,lut)
inline TFloat getNoiseDelay(int mode); // returns noise delay of randGen.randLUT()
inline TFloat getNoiseDelay(int mode, TMLookUpTable& lut); // returns noise delay of randGen.randLUT(lut)
inline TFloat getNoiseDelay(int mode, TFloat offset); // returns noise delay of randGen.randLUT(offset)
inline TFloat getNoiseDelay(int mode, TFloat offset, TMLookUpTable& lut); // returns noise delay of randGen.randLUT(offset,lut)
void reparseConstruct(TParser& parser, vector& repPars); // reparse parameters; adds reparsed par. to repPars
void reparseDelete(vector& repPars); // reparse parameters; remove reparsed par.
int handleUpdatedParameters(); // handle parameters updated by sliders or reparsing
void outputState(ostream & os) const; // output of all fields
friend ostream& operator<<(ostream& os, const TDelayNoise& delNoise); // stream output
friend istream& operator>>(istream& is, TDelayNoise& delNoise); // stream input
protected:
void create(); // called by all constructors
};
ostream& operator<<(ostream& os, const TDelayNoise& delNoise); // stream output
istream& operator>>(istream& is, TDelayNoise& delNoise); // stream input
// **************************************************************************************************************************
// **************************************************************************************************************************
/**
* TMKernelDY
* Kernelled Delays, e.g. for topographic connections
*
* @short Kernelled Delays, e.g. for topographic connections
* @author Andreas Knoblauch
* @version 1.0 alpha,
* last change: June 6, 2001
*/
template
class TMKernelDY : public TDelay, public TDelayDist, public TDelayNoise {
// **************************************************************************************************************************
public:
// delay kernels
string scopeID_TMKernelDY; // scope ID
int zeroCenteredFlag; // 1 <=> Distance is computed relative to the kernel center, odd kernels required!
TKernel *kernel; // kernel representing the delays
// constructors/destructors
TMKernelDY(TSimulationEnvironment& simEnv_arg, TParamOwner* owner, const char* name_arg, // constructor (default)
int maxDelayAllowed_arg, int multiModalFlag_arg, int zeroCenteredFlag_arg, const TKernel& kernel_arg);
TMKernelDY(TSimulationEnvironment& simEnv_arg, TParamOwner* owner, const char* name_arg, // constructor (complete)
int maxDelayAllowed_arg, int multiModalFlag_arg, int zeroCenteredFlag_arg, const TKernel& kernel_arg, int parse);
TMKernelDY(const TMKernelDY& pattern, TParamOwner* owner, const char* name_arg, // constructor (patterned/copy)
int maxDelayAllowed_arg, int zeroCenteredFlag_arg, const TKernel& kernel_arg);
TMKernelDY(const TMKernelDY& pattern, TParamOwner* owner, const char* name_arg, // constructor (patterned/copy with data)
int maxDelayAllowed_arg, int zeroCenteredFlag_arg, const TKernel& kernel_arg, TNum** kernels_arg);
~TMKernelDY(); // destructor
// methods
void resize(int nModes_new, int setDel); // resizes to nModes_new modes; setDelays() if setDel
void setDelays(int outFlag); // set all delays according to parameters; output if outFlag
void setDelays(int mode, int outFlag); // set delays of one mode according to parameters; output if outFlag
void reparseConstruct(vector& repPars); // reparse parameters; adds reparsed parameters to repPars
void reparseDelete(vector& repPars); // reparse parameters; adds reparsed parameters to repPars
void handleUpdatedParameters(); // handle parameters updated by sliders or reparsing
void outputState(ostream & os) const; // output of all fields
void outputState(ostream & os, int complete) const; // if complete==0 then only output of the most important fields
friend ostream& operator<< (ostream& os, const TMKernelDY& delay); // stream output
friend istream& operator>> (istream& is, TMKernelDY& delay); // stream input input
protected:
void create(const TKernel& kernel_arg, int fullAllocation, TNum** kernels_arg); // called by constructors; setDelays if fullAllocation
void deallocate(); // called by the destructor
private:
static const char* scopeString;
};
template
const char* TMKernelDY::scopeString="TMKernelDY";
template
ostream& operator<<(ostream& os, const TMKernelDY& delay); // stream output
template
istream& operator>>(istream& is, TMKernelDY& delay); // stream input
#endif /* F2_delay_H */
| Generated by: aknoblau on synfire on Sat May 1 14:32:16 2004, using kdoc 2.0a54. |