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