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 (2e-5)
  37: 
  38: 
  39: struct Compartment compSoma =
  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:     4.57537e-11, // unscaled 0.0164,
  66: 
  67: /*     double dEm; */
  68: 
  69:     -0.08,
  70: 
  71: /*     double dInitVm; */
  72: 
  73:     -0.028,
  74: 
  75: /*     double dInject;           */
  76: 
  77:     0,
  78: 
  79: /*     double dRa; */
  80: 
  81:     360502, // unscaled 2.5,
  82: 
  83: /*     double dRm; */
  84: 
  85:     3.58441e+08, // unscaled 1
  86: };
  87: 
  88: 
  89: //v a simple fast calcium channel
  90: 
  91: struct ChannelActInact caiCaT =
  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.1375262439,
 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.394928884e-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.038918706451336625,
 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:                     2.6e3,
 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.021,
 165: 
 166:                     //m denormalized time constant
 167: 
 168:                     -8e-3,
 169:                 },
 170: 
 171:                 //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
 172: 
 173:                 {
 174:                     //m multiplier
 175: 
 176:                     0.18e3,
 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.04,
 198: 
 199:                     //m denormalized time constant
 200: 
 201:                     4e-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.082602128127539254,
 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.0025e3,
 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.04,
 253: 
 254:                     //m denormalized time constant
 255: 
 256:                     8e-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.19e3,
 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.05,
 286: 
 287:                     //m denormalized time constant
 288: 
 289:                     -10.0e-3,
 290:                 },
 291:             },
 292:         },
 293:     },
 294: };
 295: 
 296: 
 297: struct ExponentialDecay exdecCa =
 298: {
 299:     //m administrative overhead
 300: 
 301:     {
 302:         //m type of structure
 303: 
 304:         MATH_TYPE_ExponentialDecay,
 305:     },
 306: 
 307:     //m initial value
 308: 
 309:     4e-5,
 310: 
 311:     //m beta
 312: 
 313:     9412391936.0,
 314: 
 315:     //m steady state
 316: 
 317:     4e-05,
 318: 
 319:     //m tau
 320: 
 321:     0.00010,
 322: 
 323:     //m external contribution delivered by these intermediaries
 324: 
 325:     {
 326:         0,
 327:         -1,
 328:         -1,
 329:         -1,
 330:     },
 331: };
 332: 
 333: 
 334: int piC2m[] =
 335: {
 336:     2,
 337:     -1,
 338: };
 339: 
 340: 
 341: struct MathComponentArray mca =
 342: {
 343:     //m number of math components
 344: 
 345:     2,
 346: 
 347:     //m math component data
 348: 
 349:     NULL,
 350: 
 351:     //m math component index, initialize to NULL
 352: 
 353:     NULL,
 354: 
 355: };
 356: 
 357: 
 358: struct Intermediary inter =
 359: {
 360:     //m compartment array
 361: 
 362:     1,
 363: 
 364:     &compSoma,
 365: 
 366:     //m all other mathematical components
 367: 
 368:     &mca,
 369: 
 370:     //m compartment 2 first mechanism number
 371: 
 372:     piC2m,
 373: };
 374: 
 375: 
 376: int main(int argc, char *argv[])
 377: {
 378:     //- determine intermediary size, and allocate
 379: 
 380:     struct MathComponentInfo *pmciCaT = MathComponentInfoLookup(caiCaT.mc.iType);
 381: 
 382:     struct MathComponentInfo *pmciCa = MathComponentInfoLookup(exdecCa.mc.iType);
 383: 
 384:     int iChars = pmciCaT->iChars + pmciCa->iChars;
 385: 
 386:     void *pmc = calloc(sizeof(char), iChars);
 387: 
 388:     //- prepare the mechanism intermediary
 389: 
 390:     struct ChannelActInact *pcai = (struct ChannelActInact *)pmc;
 391: 
 392:     *pcai = caiCaT;
 393: 
 394:     struct ExponentialDecay *pexdec = (struct ExponentialDecay *)&((char *)pcai)[pmciCaT->iChars];
 395: 
 396:     *pexdec = exdecCa;
 397: 
 398:     //- link the intermediary
 399: 
 400:     mca.pmc = pmc;
 401: 
 402:     //- do the simulation
 403: 
 404:     simulate(argc,argv);
 405: }
 406: 
 407: 
 408: #define main(argc,argv) simulate(argc,argv)
 409: 
 410: //t this prototype can give warning and perhaps errors.
 411: 
 412: int main(int argc, char *argv[]);
 413: 
 414: 
 415: #include "main.c"
 416: 
 417: 
 418: