1: //
   2: // Heccer : a compartmental solver that implements efficient Crank-Nicolson
   3: // integration for neuronal models.
   4: //
   5: 
   6: //////////////////////////////////////////////////////////////////////////////
   7: //'
   8: //' Heccer : testbed C implementation
   9: //'
  10: //' Copyright (C) 2006-2008 Hugo Cornelis
  11: //'
  12: //' functional ideas .. Hugo Cornelis, hugo.cornelis@gmail.com
  13: //'
  14: //' coding ............ Hugo Cornelis, hugo.cornelis@gmail.com
  15: //'
  16: //////////////////////////////////////////////////////////////////////////////
  17: 
  18: 
  19: #include <stdlib.h>
  20: 
  21: #include "../../heccer/compartment.h"
  22: #include "../../heccer/heccer.h"
  23: 
  24: 
  25: #define HECCER_TEST_INTERVAL_DEFAULT_START                      (-0.1)
  26: #define HECCER_TEST_INTERVAL_DEFAULT_END                        (0.05)
  27: #define HECCER_TEST_INTERVAL_DEFAULT_ENTRIES                    50
  28: #define HECCER_TEST_STEPS 1
  29: 
  30: 
  31: struct Compartment comp =
  32: {
  33:     //m administrative overhead
  34: 
  35:     {
  36:         //m type of structure
  37: 
  38:         MATH_TYPE_Compartment,
  39:     },
  40: 
  41:     //m index of parent compartment, -1 for none
  42: 
  43:     -1,
  44: 
  45: /*      //m first mechanism */
  46: 
  47: /*      NULL, */
  48: 
  49: /*      //m number of mechanisms */
  50: 
  51: /*      0, */
  52: 
  53:     //m descriptive values, alphabetical order
  54: 
  55: /*     double dCm; */
  56: 
  57:     5.755329373e-12, // unscaled 0.0164,
  58: 
  59: /*     double dEm; */
  60: 
  61:     -0.08,
  62: 
  63: /*     double dInitVm; */
  64: 
  65:     -0.068,
  66: 
  67: /*     double dInject;           */
  68: 
  69:     0,
  70: 
  71: /*     double dRa; */
  72: 
  73:     772813.4375, // unscaled 2.5,
  74: 
  75: /*     double dRm; */
  76: 
  77:     8.548598272e9, // unscaled 3
  78: };
  79: 
  80: 
  81: struct ChannelActConc cacKC =
  82: {
  83:     //m administrative overhead
  84: 
  85:     {
  86:         //m type of structure
  87: 
  88:         MATH_TYPE_ChannelActConc,
  89:     },
  90: 
  91:     //m first set of descriptive values, alphabetical order
  92: 
  93:     //m initial reversal potential
  94: 
  95:     -0.085,
  96: 
  97:     //m get reversal potential from this intermediary, -1 for none
  98: 
  99:     -1,
 100: 
 101:     //m maximal conductance when all channels are permissive
 102: 
 103:     2.80747571e-07,
 104: 
 105:     //m contributes to this concentration pool, -1 for none, boolean indicator only.
 106: 
 107:     -1,
 108: 
 109:     //m activation description
 110: 
 111:     {
 112:         //m power, for a standard heccer, something between 1 and 4 or so.
 113: 
 114:         1,
 115: 
 116:         //m gate definition
 117: 
 118:         {
 119:             //m initial value, commonly forward over backward steady states
 120: 
 121:             0.063531859768213905,
 122: 
 123:             //m corresponding index in tables, set to -1 for initialization.
 124: 
 125:             -1,
 126: 
 127:             {
 128:                 //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
 129: 
 130:                 {
 131:                     //m multiplier
 132: 
 133:                     7.5e3,
 134: 
 135:                     //m multiplier membrane dependence, 0.0 for no dependence
 136: 
 137:                     0.0,
 138: 
 139:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 140: 
 141:                     0.0,
 142: 
 143:                     //m choose between nominator or denominator, 1 means nominator, -1
 144:                     //m means denominator
 145: 
 146:                     -1.0,
 147: 
 148:                     //m nominator or denominator offset
 149: 
 150:                     0.0,
 151: 
 152:                     //m membrane offset
 153: 
 154:                     0.0,
 155: 
 156:                     //m denormalized time constant
 157: 
 158:                     1e12,
 159:                 },
 160: 
 161:                 //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
 162: 
 163:                 {
 164:                     //m multiplier
 165: 
 166:                     0.11e3,
 167: 
 168:                     //m multiplier membrane dependence, 0.0 for no dependence
 169: 
 170:                     0.0,
 171: 
 172:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 173: 
 174:                     0.0,
 175: 
 176:                     //m choose between nominator or denominator, 1 means nominator, -1
 177:                     //m means denominator
 178: 
 179:                     -1.0,
 180: 
 181:                     //m nominator or denominator offset
 182: 
 183:                     0.0,
 184: 
 185:                     //m membrane offset
 186: 
 187:                     -0.035,
 188: 
 189:                     //m denormalized time constant
 190: 
 191:                     14.9e-3,
 192:                 },
 193:             },
 194:         },
 195:     },
 196: 
 197:     //m activator dependence description
 198: 
 199:     {
 200:         //m power, for a standard heccer, something between 1 and 4 or so.
 201: 
 202:         2,
 203: 
 204:         //m activator definition
 205: 
 206:         {
 207:             //m initial value, commonly steady state
 208: 
 209:             0.0099009900989999993,
 210: 
 211:             //m corresponding index in tables, set to -1 for initialization.
 212: 
 213:             -1,
 214: 
 215:             //m is activated by the output of this mechanism, must be filled in
 216: 
 217:             -1,
 218: 
 219:             {
 220:                 //m basal level, A in EDS1994
 221: 
 222:                 4.0e-3,
 223: 
 224:                 //m time constant, B in EDS1994
 225: 
 226:                 0.010,
 227:             },
 228:         },
 229:     },
 230: };
 231: 
 232: 
 233: int piC2m[] =
 234: {
 235:     1,
 236:     -1,
 237: };
 238: 
 239: 
 240: struct MathComponentArray mca =
 241: {
 242:     //m number of math components
 243: 
 244:     1,
 245: 
 246:     //m math component data
 247: 
 248:     &cacKC.mc,
 249: 
 250:     //m math component index, initialize to NULL
 251: 
 252:     NULL,
 253: 
 254: };
 255: 
 256: 
 257: struct Intermediary inter =
 258: {
 259:     //m compartment array
 260: 
 261:     1,
 262: 
 263:     &comp,
 264: 
 265:     //m all other mathematical components
 266: 
 267:     &mca,
 268: 
 269:     //m compartment 2 first mechanism number
 270: 
 271:     piC2m,
 272: };
 273: 
 274: 
 275: #include "main.c"
 276: 
 277: 
 278: