carlsim_datastructures.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Regents of the University of California. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The names of its contributors may not be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * *********************************************************************************************** *
 * CARLsim
 * created by:      (MDR) Micah Richert, (JN) Jayram M. Nageswaran
 * maintained by:   (MA) Mike Avery <averym@uci.edu>, (MB) Michael Beyeler <mbeyeler@uci.edu>,
 *                  (KDC) Kristofor Carlson <kdcarlso@uci.edu>
 *                  (TSC) Ting-Shuo Chou <tingshuc@uci.edu>
 *
 * CARLsim available from http://socsci.uci.edu/~jkrichma/CARLsim/
 * Ver 2/21/2014
 */

#ifndef _CARLSIM_DATASTRUCTURES_H_
#define _CARLSIM_DATASTRUCTURES_H_

#include <ostream>          // print struct info
#include <user_errors.h>    // CARLsim user errors

enum loggerMode_t {
     USER,            
     DEVELOPER,       
     SHOWTIME,        
     SILENT,          
     CUSTOM,          
     UNKNOWN_LOGGER
};
static const char* loggerMode_string[] = {
    "USER","DEVELOPER","SHOWTIME","SILENT","CUSTOM","Unknown mode"
};

enum simMode_t {
     CPU_MODE,     
     GPU_MODE,     
     UNKNOWN_SIM
};
static const char* simMode_string[] = {
    "CPU mode","GPU mode","Unknown mode"
};

enum integrationMethod_t {
    FORWARD_EULER,
    RUNGE_KUTTA4,
    UNKNOWN_INTEGRATION
};
static const char* integrationMethod_string[] = {
    "Forward-Euler", "4-th order Runge-Kutta", "Unknown integration method"
};

// \TODO: extend documentation, add relevant references
enum stdpType_t {
    STANDARD,         
    DA_MOD,           
    UNKNOWN_STDP
};
static const char* stdpType_string[] = {
    "Standard STDP",
    "Dopamine-modulated STDP",
    "Unknown mode"
};

enum stdpCurve_t {
    EXP_CURVE,           
    PULSE_CURVE,         
    TIMING_BASED_CURVE,  
    UNKNOWN_CURVE        
};
static const char* stdpCurve_string[] = {
    "exponential curve",
    "pulse curve",
    "timing-based curve",
    "Unknow curve"
};

enum spikeMonMode_t {
    COUNT,      
    AER,        
};
static const char* spikeMonMode_string[] = {
    "SpikeCount Mode","SpikeTime Mode"
};

enum neuromodulator_t {
    NM_DA,      
    NM_5HT,     
    NM_ACh,     
    NM_NE,      
    NM_UNKNOWN  
};
static const char* neuromodulator_string[] = {
    "Dopamine", "Serotonin", "Acetylcholine", "Noradrenaline", "Unknown neuromodulator"
};

enum updateInterval_t {
    INTERVAL_10MS,      
    INTERVAL_100MS,     
    INTERVAL_1000MS     
};
static const char* updateInterval_string[] = {
    "10 ms interval", "100 ms interval", "1000 ms interval"
};

enum carlsimState_t {
    CONFIG_STATE,       
    SETUP_STATE,        
    RUN_STATE           
};
static const char* carlsimState_string[] = {
    "Configuration state", "Setup state", "Run state"
};

struct RangeDelay {
    RangeDelay(int _val) {
        min = _val;
        max = _val;
    }
    RangeDelay(int _min, int _max) {
        UserErrors::assertTrue(_min<=_max, UserErrors::CANNOT_BE_LARGER, "RangeDelay", "minDelay", "maxDelay");
        min = _min;
        max = _max;
    }

    friend std::ostream& operator<<(std::ostream &strm, const RangeDelay &d) {
        return strm << "delay=[" << d.min << "," << d.max << "]";
    }
    int min,max;
};

struct RangeWeight {
    RangeWeight(double _val) {
        init = _val;
        max = _val;
        min = 0;
    }
    RangeWeight(double _min, double _max) {
        UserErrors::assertTrue(_min<=_max, UserErrors::CANNOT_BE_LARGER, "RangeWeight", "minWt", "maxWt");
        min = _min;
        init = _min;
        max = _max;
    }
    RangeWeight(double _min, double _init, double _max) {
        UserErrors::assertTrue(_min<=_init, UserErrors::CANNOT_BE_LARGER, "RangeWeight", "minWt", "initWt");
        UserErrors::assertTrue(_init<=_max, UserErrors::CANNOT_BE_LARGER, "RangeWeight", "initWt", "maxWt");
        min = _min;
        init = _init;
        max = _max;
    }

    friend std::ostream& operator<<(std::ostream &strm, const RangeWeight &w) {
        return strm << "wt=[" << w.min << "," << w.init << "," << w.max << "]";
    }
    double min, init, max;
};

struct RadiusRF {
    RadiusRF(double rad) : radX(rad), radY(rad), radZ(rad) {}
    RadiusRF(double rad_x, double rad_y, double rad_z) : radX(rad_x), radY(rad_y), radZ(rad_z) {}

    friend std::ostream& operator<<(std::ostream &strm, const RadiusRF &r) {
        return strm << "RadiusRF=[" << r.radX << "," << r.radY << "," << r.radZ << "]";
    }

    const double radX, radY, radZ;
};

typedef struct GroupSTDPInfo {
    bool        WithSTDP;           
    bool        WithESTDP;          
    bool        WithISTDP;          
    stdpType_t  WithESTDPtype;      
    stdpType_t  WithISTDPtype;      
    stdpCurve_t WithESTDPcurve;     
    stdpCurve_t WithISTDPcurve;     
    float       TAU_PLUS_INV_EXC;   
    float       TAU_MINUS_INV_EXC;  
    float       ALPHA_PLUS_EXC;     
    float       ALPHA_MINUS_EXC;    
    float       TAU_PLUS_INV_INB;   
    float       TAU_MINUS_INV_INB;  
    float       ALPHA_PLUS_INB;     
    float       ALPHA_MINUS_INB;    
    float       GAMMA;              
    float       BETA_LTP;           
    float       BETA_LTD;           
    float       LAMBDA;             
    float       DELTA;              
} GroupSTDPInfo_t;

typedef struct GroupNeuromodulatorInfo {
    float       baseDP;     
    float       base5HT;    
    float       baseACh;    
    float       baseNE;     
    float       decayDP;        
    float       decay5HT;       
    float       decayACh;       
    float       decayNE;        
} GroupNeuromodulatorInfo_t;

struct Grid3D {
    Grid3D(int w) : x(w), y(1), z(1), width(w), height(1), depth(1), columns(1), channels(1), N(w) {
        UserErrors::assertTrue(w>0, UserErrors::MUST_BE_POSITIVE, "Grid3D", "width");
    }
    Grid3D(int w, int h) : x(w), y(h), z(1), width(w), height(h), depth(1), columns(1), channels(1), N(w*h) {
        UserErrors::assertTrue(w>0, UserErrors::MUST_BE_POSITIVE, "Grid3D", "width");
        UserErrors::assertTrue(h>0, UserErrors::MUST_BE_POSITIVE, "Grid3D", "height");
    }
    Grid3D(int w, int h, int d) : x(w), y(h), z(d), width(w), height(h), depth(d), columns(d), channels(d), N(w*h*d) {
         UserErrors::assertTrue(w>0, UserErrors::MUST_BE_POSITIVE, "Grid3D", "width");
         UserErrors::assertTrue(h>0, UserErrors::MUST_BE_POSITIVE, "Grid3D", "height");
         UserErrors::assertTrue(d>0, UserErrors::MUST_BE_POSITIVE, "Grid3D", "depth");
    }

    friend std::ostream& operator<<(std::ostream &strm, const Grid3D &g) {
        return strm << "Grid3D=[" << g.x << "," << g.y << "," << g.z << "]";
    }

    int x, y, z;
    int width, height, depth;
    int columns, channels;
    int N;
};

struct ExpCurve {
    ExpCurve(float _alphaPlus, float _tauPlus, float _alphaMinus, float _tauMinus) : alphaPlus(_alphaPlus), tauPlus(_tauPlus), alphaMinus(_alphaMinus), tauMinus(_tauMinus) {
        UserErrors::assertTrue(_tauPlus > 0.0f, UserErrors::MUST_BE_POSITIVE, "ExpCurve", "tauPlus");
        UserErrors::assertTrue(_tauMinus > 0.0f, UserErrors::MUST_BE_POSITIVE, "ExpCurve", "tauMinus");

        stdpCurve = EXP_CURVE;
    }

    stdpCurve_t stdpCurve; 
    float alphaPlus; 
    float tauPlus; 
    float alphaMinus; 
    float tauMinus; 
};

struct TimingBasedCurve {
    TimingBasedCurve(float _alphaPlus, float _tauPlus, float _alphaMinus, float _tauMinus, float _gamma) : alphaPlus(_alphaPlus), tauPlus(_tauPlus), alphaMinus(_alphaMinus), tauMinus(_tauMinus) , gamma(_gamma) {
        UserErrors::assertTrue(_alphaPlus > 0.0f, UserErrors::MUST_BE_POSITIVE, "TimingBasedCurve", "alphaPlus");
        UserErrors::assertTrue(_alphaMinus < 0.0f, UserErrors::MUST_BE_NEGATIVE, "TimingBasedCurve", "alphaMinus");
        UserErrors::assertTrue(_tauPlus > 0.0f, UserErrors::MUST_BE_POSITIVE, "TimingBasedCurve", "tauPlus");
        UserErrors::assertTrue(_tauMinus > 0.0f, UserErrors::MUST_BE_POSITIVE, "TimingBasedCurve", "tauMinus");
        UserErrors::assertTrue(_gamma > 0.0f, UserErrors::MUST_BE_POSITIVE, "TimingBasedCurve", "gamma");
        UserErrors::assertTrue(_tauPlus >= _gamma, UserErrors::CANNOT_BE_SMALLER, "TimingBasedCurve", "tauPlus >= gamma");

        stdpCurve = TIMING_BASED_CURVE;
    }

    stdpCurve_t stdpCurve; 
    float alphaPlus; 
    float tauPlus; 
    float alphaMinus; 
    float tauMinus; 
    float gamma; 
};

struct PulseCurve {
    PulseCurve(float _betaLTP, float _betaLTD, float _lambda, float _delta) : betaLTP(_betaLTP), betaLTD(_betaLTD), lambda(_lambda), delta(_delta) {
        UserErrors::assertTrue(_betaLTP > 0.0f, UserErrors::MUST_BE_POSITIVE, "PulseCurve", "betaLTP");
        UserErrors::assertTrue(_betaLTD < 0.0f, UserErrors::MUST_BE_NEGATIVE, "PulseCurve", "betaLTD");
        UserErrors::assertTrue(_lambda > 0.0f, UserErrors::MUST_BE_POSITIVE, "PulseCurve", "lambda");
        UserErrors::assertTrue(_delta > 0.0f, UserErrors::MUST_BE_POSITIVE, "PulseCurve", "delta");
        UserErrors::assertTrue(_lambda < _delta, UserErrors::MUST_BE_SMALLER, "PulseCurve", "lambda < delta");

        stdpCurve = PULSE_CURVE;
    }

    stdpCurve_t stdpCurve; 
    float betaLTP; 
    float betaLTD; 
    float lambda; 
    float delta; 
};

#endif