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_REPORTING_GRANULARITY 100
  26: #define HECCER_TEST_STEPS 1000
  27: #define HECCER_TEST_TESTED_THINGS ( HECCER_DUMP_VM_COMPARTMENT_MATRIX \
  28:                                     | HECCER_DUMP_VM_COMPARTMENT_DATA \
  29:                                     | HECCER_DUMP_VM_COMPARTMENT_OPERATIONS \
  30:                                     | HECCER_DUMP_VM_MECHANISM_DATA \
  31:                                     | HECCER_DUMP_VM_MECHANISM_OPERATIONS \
  32:                                     | HECCER_DUMP_VM_SUMMARY \
  33:         )
  34: #define HECCER_TEST_TIME_STEP (1e-6)
  35: 
  36: 
  37: struct Compartment comp =
  38: {
  39:     //m administrative overhead
  40: 
  41:     {
  42:         //m type of structure
  43: 
  44:         MATH_TYPE_Compartment,
  45:     },
  46: 
  47:     //m index of parent compartment, -1 for none
  48: 
  49:     -1,
  50: 
  51: /*      //m first mechanism */
  52: 
  53: /*      NULL, */
  54: 
  55: /*      //m number of mechanisms */
  56: 
  57: /*      0, */
  58: 
  59:     //m descriptive values, alphabetical order
  60: 
  61: /*     double dCm; */
  62: 
  63:     5.755329373e-12, // unscaled 0.0164,
  64: 
  65: /*     double dEm; */
  66: 
  67:     -0.08,
  68: 
  69: /*     double dInitVm; */
  70: 
  71:     -0.068,
  72: 
  73: /*     double dInject;           */
  74: 
  75:     0,
  76: 
  77: /*     double dRa; */
  78: 
  79:     772813.4375, // unscaled 2.5,
  80: 
  81: /*     double dRm; */
  82: 
  83:     8.548598272e9, // unscaled 3
  84: };
  85: 
  86: 
  87: struct ChannelActInact caiCaT =
  88: {
  89:     //m administrative overhead
  90: 
  91:     {
  92:         //m type of structure
  93: 
  94:         MATH_TYPE_ChannelActInact,
  95:     },
  96: 
  97:     //m first set of descriptive values, alphabetical order
  98: 
  99:     //m initial reversal potential
 100: 
 101:     0.14702148735523224,
 102: 
 103:     //m get reversal potential from this intermediary, -1 for none
 104: 
 105:     -1,
 106: 
 107:     //m maximal conductance when all channels are permissive
 108: 
 109:     1.7546722963501793e-09,
 110: 
 111:     //m contributes to this concentration pool, -1 for none, boolean indicator only.
 112: 
 113:     1,
 114: 
 115:     //m activation description
 116: 
 117:     {
 118:         //m power, for a standard heccer, something between 1 and 4 or so.
 119: 
 120:         1,
 121: 
 122:         //m gate definition
 123: 
 124:         {
 125:             //m initial value, commonly forward over backward steady states
 126: 
 127:             0.03891870645,
 128: 
 129:             //m corresponding index in tables, set to -1 for initialization.
 130: 
 131:             -1,
 132: 
 133:             {
 134:                 //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
 135: 
 136:                 {
 137:                     //m multiplier
 138: 
 139:                     2.6e3,
 140: 
 141:                     //m multiplier membrane dependence, 0.0 for no dependence
 142: 
 143:                     0.0,
 144: 
 145:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 146: 
 147:                     0.0,
 148: 
 149:                     //m choose between nominator or denominator, 1 means nominator, -1
 150:                     //m means denominator
 151: 
 152:                     -1.0,
 153: 
 154:                     //m nominator or denominator offset
 155: 
 156:                     1.0,
 157: 
 158:                     //m membrane offset
 159: 
 160:                     0.021,
 161: 
 162:                     //m denormalized time constant
 163: 
 164:                     -8e-3,
 165:                 },
 166: 
 167:                 //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
 168: 
 169:                 {
 170:                     //m multiplier
 171: 
 172:                     0.18e3,
 173: 
 174:                     //m multiplier membrane dependence, 0.0 for no dependence
 175: 
 176:                     0.0,
 177: 
 178:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 179: 
 180:                     0.0,
 181: 
 182:                     //m choose between nominator or denominator, 1 means nominator, -1
 183:                     //m means denominator
 184: 
 185:                     -1.0,
 186: 
 187:                     //m nominator or denominator offset
 188: 
 189:                     1.0,
 190: 
 191:                     //m membrane offset
 192: 
 193:                     0.04,
 194: 
 195:                     //m denormalized time constant
 196: 
 197:                     4e-3,
 198:                 },
 199:             },
 200:         },
 201:     },
 202: 
 203:     //m inactivation description
 204: 
 205:     {
 206:         //m power, for a standard heccer, something between 1 and 4 or so.
 207: 
 208:         1,
 209: 
 210:         //m gate definition
 211: 
 212:         {
 213:             //m initial value, commonly forward over backward steady states
 214: 
 215:             0.08260212813,
 216: 
 217:             //m corresponding index in tables, set to -1 for initialization.
 218: 
 219:             -1,
 220: 
 221:             {
 222:                 //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
 223: 
 224:                 {
 225:                     //m multiplier
 226: 
 227:                     0.0025e3,
 228: 
 229:                     //m multiplier membrane dependence, 0.0 for no dependence
 230: 
 231:                     0.0,
 232: 
 233:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 234: 
 235:                     0.0,
 236: 
 237:                     //m choose between nominator or denominator, 1 means nominator, -1
 238:                     //m means denominator
 239: 
 240:                     -1.0,
 241: 
 242:                     //m nominator or denominator offset
 243: 
 244:                     1.0,
 245: 
 246:                     //m membrane offset
 247: 
 248:                     0.04,
 249: 
 250:                     //m denormalized time constant
 251: 
 252:                     8e-3,
 253:                 },
 254: 
 255:                 //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
 256: 
 257:                 {
 258:                     //m multiplier
 259: 
 260:                     0.19e3,
 261: 
 262:                     //m multiplier membrane dependence, 0.0 for no dependence
 263: 
 264:                     0.0,
 265: 
 266:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 267: 
 268:                     0.0,
 269: 
 270:                     //m choose between nominator or denominator, 1 means nominator, -1
 271:                     //m means denominator
 272: 
 273:                     -1.0,
 274: 
 275:                     //m nominator or denominator offset
 276: 
 277:                     1.0,
 278: 
 279:                     //m membrane offset
 280: 
 281:                     0.05,
 282: 
 283:                     //m denormalized time constant
 284: 
 285:                     -10.0e-3,
 286:                 },
 287:             },
 288:         },
 289:     },
 290: };
 291: 
 292: 
 293: struct ExponentialDecay exdecCa =
 294: {
 295:     //m administrative overhead
 296: 
 297:     {
 298:         //m type of structure
 299: 
 300:         MATH_TYPE_ExponentialDecay,
 301:     },
 302: 
 303:     //m initial value
 304: 
 305:     4e-5,
 306: 
 307:     //m beta
 308: 
 309:     7.579027046e+10,
 310: 
 311:     //m steady state
 312: 
 313:     4e-05,
 314: 
 315:     //m tau
 316: 
 317:     0.00010,
 318: 
 319:     //m external contribution delivered by these intermediaries
 320: 
 321:     {
 322:         0,
 323:         -1,
 324:         -1,
 325:         -1,
 326:     },
 327: };
 328: 
 329: 
 330: struct ChannelActConc cacKC =
 331: {
 332:     //m administrative overhead
 333: 
 334:     {
 335:         //m type of structure
 336: 
 337:         MATH_TYPE_ChannelActConc,
 338:     },
 339: 
 340:     //m first set of descriptive values, alphabetical order
 341: 
 342:     //m initial reversal potential
 343: 
 344:     85,
 345: 
 346:     //m get reversal potential from this intermediary, -1 for none
 347: 
 348:     -1,
 349: 
 350:     //m maximal conductance when all channels are permissive
 351: 
 352:     2.80747571e-07,
 353: 
 354:     //m contributes to this concentration pool, -1 for none, boolean indicator only.
 355: 
 356:     -1,
 357: 
 358:     //m activation description
 359: 
 360:     {
 361:         //m power, for a standard heccer, something between 1 and 4 or so.
 362: 
 363:         1,
 364: 
 365:         //m gate definition
 366: 
 367:         {
 368:             //m initial value, commonly forward over backward steady states
 369: 
 370:             0.063531859768213905,
 371: 
 372:             //m corresponding index in tables, set to -1 for initialization.
 373: 
 374:             -1,
 375: 
 376:             {
 377:                 //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
 378: 
 379:                 {
 380:                     //m multiplier
 381: 
 382:                     7.5e3,
 383: 
 384:                     //m multiplier membrane dependence, 0.0 for no dependence
 385: 
 386:                     0.0,
 387: 
 388:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 389: 
 390:                     0.0,
 391: 
 392:                     //m choose between nominator or denominator, 1 means nominator, -1
 393:                     //m means denominator
 394: 
 395:                     -1.0,
 396: 
 397:                     //m nominator or denominator offset
 398: 
 399:                     0.0,
 400: 
 401:                     //m membrane offset
 402: 
 403:                     0.0,
 404: 
 405:                     //m denormalized time constant
 406: 
 407:                     1e12,
 408:                 },
 409: 
 410:                 //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
 411: 
 412:                 {
 413:                     //m multiplier
 414: 
 415:                     0.11e3,
 416: 
 417:                     //m multiplier membrane dependence, 0.0 for no dependence
 418: 
 419:                     0.0,
 420: 
 421:                     //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
 422: 
 423:                     0.0,
 424: 
 425:                     //m choose between nominator or denominator, 1 means nominator, -1
 426:                     //m means denominator
 427: 
 428:                     -1.0,
 429: 
 430:                     //m nominator or denominator offset
 431: 
 432:                     0.0,
 433: 
 434:                     //m membrane offset
 435: 
 436:                     -0.035,
 437: 
 438:                     //m denormalized time constant
 439: 
 440:                     14.9e-3,
 441:                 },
 442:             },
 443:         },
 444:     },
 445: 
 446:     //m activator dependence description
 447: 
 448:     {
 449:         //m power, for a standard heccer, something between 1 and 4 or so.
 450: 
 451:         2,
 452: 
 453:         //m activator definition
 454: 
 455:         {
 456:             //m initial value, commonly steady state
 457: 
 458:             0.0099009900989999993,
 459: 
 460:             //m corresponding index in tables, set to -1 for initialization.
 461: 
 462:             -1,
 463: 
 464:             //m is activated by the output of this mechanism, must be filled in
 465: 
 466:             1,
 467: 
 468:             {
 469:                 //m basal level, A in EDS1994
 470: 
 471:                 4.0e-3,
 472: 
 473:                 //m time constant, B in EDS1994
 474: 
 475:                 0.010,
 476:             },
 477:         },
 478:     },
 479: };
 480: 
 481: 
 482: int piC2m[] =
 483: {
 484:     3,
 485:     -1,
 486: };
 487: 
 488: 
 489: struct MathComponentArray mca =
 490: {
 491:     //m number of math components
 492: 
 493:     3,
 494: 
 495:     //m math component data
 496: 
 497:     NULL,
 498: 
 499:     //m math component index, initialize to NULL
 500: 
 501:     NULL,
 502: 
 503: };
 504: 
 505: 
 506: struct Intermediary inter =
 507: {
 508:     //m compartment array
 509: 
 510:     1,
 511: 
 512:     &comp,
 513: 
 514:     //m all other mathematical components
 515: 
 516:     &mca,
 517: 
 518:     //m compartment 2 first mechanism number
 519: 
 520:     piC2m,
 521: };
 522: 
 523: 
 524: int main(int argc, char *argv[])
 525: {
 526:     //- determine intermediary size, and allocate
 527: 
 528:     struct MathComponentInfo *pmciCaT = MathComponentInfoLookup(caiCaT.mc.iType);
 529: 
 530:     struct MathComponentInfo *pmciCa = MathComponentInfoLookup(exdecCa.mc.iType);
 531: 
 532:     struct MathComponentInfo *pmciKC = MathComponentInfoLookup(cacKC.mc.iType);
 533: 
 534:     int iChars = pmciCaT->iChars + pmciCa->iChars + pmciKC->iChars;
 535: 
 536:     void *pmc = calloc(sizeof(char), iChars);
 537: 
 538:     //- prepare the mechanism intermediary
 539: 
 540:     struct ChannelActInact *pcai = (struct ChannelActInact *)pmc;
 541: 
 542:     *pcai = caiCaT;
 543: 
 544:     struct ExponentialDecay *pexdec = (struct ExponentialDecay *)&((char *)pcai)[pmciCaT->iChars];
 545: 
 546:     *pexdec = exdecCa;
 547: 
 548:     struct ChannelActConc *pcac = (struct ChannelActConc *)&((char *)pexdec)[pmciCa->iChars];
 549: 
 550:     *pcac = cacKC;
 551: 
 552:     //- link the intermediary
 553: 
 554:     mca.pmc = pmc;
 555: 
 556:     //- do the simulation
 557: 
 558:     simulate(argc,argv);
 559: }
 560: 
 561: 
 562: #define main(argc,argv) simulate(argc,argv)
 563: 
 564: //t this prototype can give warning and perhaps errors.
 565: 
 566: int main(int argc, char *argv[]);
 567: 
 568: 
 569: #include "main.c"
 570: 
 571: 
 572: