file:/local_home/local_home/hugo/neurospaces_project/heccer/source/c/snapshots/0/tests/code/addressing-aggregator1.c (Fri Jul 4 10:44:24 2008
) HOME
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 <malloc.h>
20: #include <stdlib.h>
21:
22: #include "../../heccer/addressing.h"
23: #include "../../heccer/compartment.h"
24: #include "../../heccer/heccer.h"
25:
26:
27: #include "main.h"
28:
29:
30: #define HECCER_TEST_OPTIONS (HECCER_OPTION_ENABLE_AGGREGATORS | HECCER_OPTION_ENABLE_INDIVIDUAL_CURRENTS)
31: #define HECCER_TEST_TESTED_THINGS ( HECCER_DUMP_VM_COMPARTMENT_MATRIX \
32: | HECCER_DUMP_VM_COMPARTMENT_DATA \
33: | HECCER_DUMP_VM_COMPARTMENT_OPERATIONS \
34: | HECCER_DUMP_VM_CHANNEL_POOL_FLUXES \
35: | HECCER_DUMP_VM_MECHANISM_DATA \
36: | HECCER_DUMP_VM_MECHANISM_OPERATIONS \
37: | HECCER_DUMP_VM_SUMMARY \
38: | HECCER_DUMP_VM_AGGREGATORS \
39: )
40: /* #define HECCER_TEST_TIME_STEP (2e-5) */
41:
42:
43: struct Compartment compSoma =
44: {
45: //m administrative overhead
46:
47: {
48: //m type of structure
49:
50: MATH_TYPE_Compartment,
51:
52: #ifdef HECCER_SOURCE_NEUROSPACES
53:
54: //m identification
55:
56: ADDRESSING_NEUROSPACES_2_HECCER(1000),
57:
58: #endif
59:
60: #ifdef HECCER_SOURCE_TYPING
61:
62: //m model source type number
63:
64: //! source typing is used to compute aggregate currents ao
65: //! things.
66:
67: -1,
68:
69: #endif
70:
71: },
72:
73: //m index of parent compartment, -1 for none
74:
75: -1,
76:
77: /* //m first mechanism */
78:
79: /* NULL, */
80:
81: /* //m number of mechanisms */
82:
83: /* 0, */
84:
85: //m descriptive values, alphabetical order
86:
87: /* double dCm; */
88:
89: 4.57537e-11, // unscaled 0.0164,
90:
91: /* double dEm; */
92:
93: -0.08,
94:
95: /* double dInitVm; */
96:
97: -0.068,
98:
99: /* double dInject; */
100:
101: 0,
102:
103: /* double dRa; */
104:
105: 360502, // unscaled 2.5,
106:
107: /* double dRm; */
108:
109: 3.58441e+08, // unscaled 1
110: };
111:
112:
113: struct ChannelActInact caiCaT =
114: {
115: //m administrative overhead
116:
117: {
118: //m type of structure
119:
120: MATH_TYPE_ChannelActInact,
121:
122: #ifdef HECCER_SOURCE_NEUROSPACES
123:
124: //m identification
125:
126: ADDRESSING_NEUROSPACES_2_HECCER(2000),
127:
128: #endif
129:
130: #ifdef HECCER_SOURCE_TYPING
131:
132: //m model source type number
133:
134: //! source typing is used to compute aggregate currents ao
135: //! things.
136:
137: 0,
138:
139: #endif
140:
141: },
142:
143: //m first set of descriptive values, alphabetical order
144:
145: //m initial reversal potential
146:
147: 0.1375262439,
148:
149: //m get reversal potential from this intermediary, -1 for none
150:
151: -1,
152:
153: //m maximal conductance when all channels are permissive
154:
155: 1.394928884e-08,
156:
157: //m contributes to this concentration pool, -1 for none, boolean indicator only.
158:
159: -1,
160:
161: //m activation description
162:
163: {
164: //m power, for a standard heccer, something between 1 and 4 or so.
165:
166: 1,
167:
168: //m gate definition
169:
170: {
171: //m initial value, commonly forward over backward steady states
172:
173: 0.039478155609280696,
174:
175: //m corresponding index in tables, set to -1 for initialization.
176:
177: -1,
178:
179: {
180: //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
181:
182: {
183: //m multiplier
184:
185: 2.6e3,
186:
187: //m multiplier membrane dependence, 0.0 for no dependence
188:
189: 0.0,
190:
191: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
192:
193: 0.0,
194:
195: //m choose between nominator or denominator, 1 means nominator, -1
196: //m means denominator
197:
198: -1.0,
199:
200: //m nominator or denominator offset
201:
202: 1.0,
203:
204: //m membrane offset
205:
206: 0.021,
207:
208: //m denormalized time constant
209:
210: -8e-3,
211: },
212:
213: //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
214:
215: {
216: //m multiplier
217:
218: 0.18e3,
219:
220: //m multiplier membrane dependence, 0.0 for no dependence
221:
222: 0.0,
223:
224: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
225:
226: 0.0,
227:
228: //m choose between nominator or denominator, 1 means nominator, -1
229: //m means denominator
230:
231: -1.0,
232:
233: //m nominator or denominator offset
234:
235: 1.0,
236:
237: //m membrane offset
238:
239: 0.04,
240:
241: //m denormalized time constant
242:
243: 4e-3,
244: },
245: },
246: },
247: },
248:
249: //m inactivation description
250:
251: {
252: //m power, for a standard heccer, something between 1 and 4 or so.
253:
254: 1,
255:
256: //m gate definition
257:
258: {
259: //m initial value, commonly forward over backward steady states
260:
261: 0.08211379989188651,
262:
263: //m corresponding index in tables, set to -1 for initialization.
264:
265: -1,
266:
267: {
268: //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
269:
270: {
271: //m multiplier
272:
273: 0.0025e3,
274:
275: //m multiplier membrane dependence, 0.0 for no dependence
276:
277: 0.0,
278:
279: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
280:
281: 0.0,
282:
283: //m choose between nominator or denominator, 1 means nominator, -1
284: //m means denominator
285:
286: -1.0,
287:
288: //m nominator or denominator offset
289:
290: 1.0,
291:
292: //m membrane offset
293:
294: 0.04,
295:
296: //m denormalized time constant
297:
298: 8e-3,
299: },
300:
301: //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
302:
303: {
304: //m multiplier
305:
306: 0.19e3,
307:
308: //m multiplier membrane dependence, 0.0 for no dependence
309:
310: 0.0,
311:
312: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
313:
314: 0.0,
315:
316: //m choose between nominator or denominator, 1 means nominator, -1
317: //m means denominator
318:
319: -1.0,
320:
321: //m nominator or denominator offset
322:
323: 1.0,
324:
325: //m membrane offset
326:
327: 0.05,
328:
329: //m denormalized time constant
330:
331: -10.0e-3,
332: },
333: },
334: },
335: },
336: };
337:
338:
339: //v a delayed rectifier potassium channel
340:
341: struct ChannelSteadyStateSteppedTau csstKdr =
342: {
343: //m administrative overhead
344:
345: {
346: //m type of structure
347:
348: MATH_TYPE_ChannelSteadyStateSteppedTau,
349:
350: #ifdef HECCER_SOURCE_NEUROSPACES
351:
352: //m identification
353:
354: ADDRESSING_NEUROSPACES_2_HECCER(3000),
355:
356: #endif
357:
358: #ifdef HECCER_SOURCE_TYPING
359:
360: //m model source type number
361:
362: //! source typing is used to compute aggregate currents ao
363: //! things.
364:
365: 1,
366:
367: #endif
368:
369: },
370:
371: //m first set of descriptive values, alphabetical order
372:
373: //m initial reversal potential
374:
375: -0.085,
376:
377: //m get reversal potential from this intermediary, -1 for none
378:
379: -1,
380:
381: //m maximal conductance when all channels are permissive
382:
383: 1.67392e-05,
384:
385: //m contributes to this concentration pool, -1 for none, boolean indicator only.
386:
387: -1,
388:
389: //m first power
390:
391: 2,
392:
393: //m second power
394:
395: 1,
396:
397: //m first table, -1 for initialization
398:
399: -1,
400:
401: //m second table, -1 for initialization
402:
403: -1,
404:
405: //m first initial value
406:
407: 0.003599440607,
408:
409: //m second initial value
410:
411: 0.9999799396,
412:
413: //m steady state definition
414:
415: {
416: //m first kinetiks
417:
418: {
419: //m part a
420:
421: {
422: //m 1: multiplier
423:
424: -23.5e3,
425:
426: //m 2: multiplier membrane dependence offset, 0.0 for no offset
427:
428: 0.012,
429:
430: //m 4: nominator or denominator offset
431:
432: -1.0,
433:
434: //m 5: membrane offset
435:
436: 0.012,
437:
438: //m 6: denormalized time constant
439:
440: -12e-3,
441:
442: },
443:
444: //m part b
445:
446: {
447: //m 1: multiplier
448:
449: 5e3,
450:
451: //m 2: multiplier membrane dependence, 0.0 for no dependence
452:
453: 0.030,
454:
455: //m 2: multiplier membrane dependence offset, 0.0 for no offset
456:
457: 0.147,
458:
459: },
460: },
461:
462: //m second kinetiks
463:
464: {
465: //m part a
466:
467: {
468: //m 1: multiplier
469:
470: -23.5e3,
471:
472: //m 2: multiplier membrane dependence offset, 0.0 for no offset
473:
474: -0.008,
475:
476: //m 4: nominator or denominator offset
477:
478: -1.0,
479:
480: //m 5: membrane offset
481:
482: -0.008,
483:
484: //m 6: denormalized time constant
485:
486: -12e-3,
487:
488: },
489:
490: //m part b
491:
492: {
493: //m 1: multiplier
494:
495: 5e3,
496:
497: //m 2: multiplier membrane dependence, 0.0 for no dependence
498:
499: 0.030,
500:
501: //m 2: multiplier membrane dependence offset, 0.0 for no offset
502:
503: 0.127,
504:
505: },
506: },
507: },
508:
509: //m time constant definition
510:
511: {
512: //m part a
513:
514: {
515: //m threshold
516:
517: -0.025,
518:
519: //m low membrane potential target value
520:
521: 1.2,
522:
523: //m above membrane potential target value
524:
525: 0.010,
526:
527: },
528:
529: //m part b
530:
531: {
532: //m 4: nominator or denominator offset
533:
534: 1.0,
535:
536: //m 5: membrane offset
537:
538: 0.025,
539:
540: //m 6: denormalized time constant
541:
542: 0.004,
543:
544: },
545: },
546: };
547:
548:
549: //v a persistent sodium channel
550:
551: struct ChannelAct caNaP =
552: {
553: //m administrative overhead
554:
555: {
556: //m type of structure
557:
558: MATH_TYPE_ChannelAct,
559:
560: #ifdef HECCER_SOURCE_NEUROSPACES
561:
562: //m identification
563:
564: ADDRESSING_NEUROSPACES_2_HECCER(4000),
565:
566: #endif
567:
568: #ifdef HECCER_SOURCE_TYPING
569:
570: //m model source type number
571:
572: //! source typing is used to compute aggregate currents ao
573: //! things.
574:
575: 2,
576:
577: #endif
578:
579: },
580:
581: //m first set of descriptive values, alphabetical order
582:
583: //m initial reversal potential
584:
585: 0.045,
586:
587: //m get reversal potential from this intermediary, -1 for none
588:
589: -1,
590:
591: //m maximal conductance when all channels are permissive
592:
593: 2.789857767e-08,
594:
595: //m contributes to this concentration pool, -1 for none, boolean indicator only.
596:
597: -1,
598:
599: //m activation description
600:
601: {
602: //m power, for a standard heccer, something between 1 and 4 or so.
603:
604: 3,
605:
606: //m gate definition
607:
608: {
609: //m initial value, commonly forward over backward steady states
610:
611: 0.7612305421,
612:
613: //m corresponding index in tables, set to -1 for initialization.
614:
615: -1,
616:
617: {
618: //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
619:
620: {
621: //m multiplier
622:
623: 200.0e3,
624:
625: //m multiplier membrane dependence, 0.0 for no dependence
626:
627: 0.0,
628:
629: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
630:
631: 0.0,
632:
633: //m choose between nominator or denominator, 1 means nominator, -1
634: //m means denominator
635:
636: -1.0,
637:
638: //m nominator or denominator offset
639:
640: 1.0,
641:
642: //m membrane offset
643:
644: -0.018,
645:
646: //m denormalized time constant
647:
648: -16.0e-3,
649: },
650:
651: //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
652:
653: {
654: //m multiplier
655:
656: 25.0e3,
657:
658: //m multiplier membrane dependence, 0.0 for no dependence
659:
660: 0.0,
661:
662: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
663:
664: 0.0,
665:
666: //m choose between nominator or denominator, 1 means nominator, -1
667: //m means denominator
668:
669: -1.0,
670:
671: //m nominator or denominator offset
672:
673: 1.0,
674:
675: //m membrane offset
676:
677: 0.058,
678:
679: //m denormalized time constant
680:
681: 8.0e-3,
682: },
683: },
684: },
685: },
686:
687: };
688:
689:
690: //v a simple fast sodium channel
691:
692: struct ChannelActInact caiNaF =
693: {
694: //m administrative overhead
695:
696: {
697: //m type of structure
698:
699: MATH_TYPE_ChannelActInact,
700:
701: #ifdef HECCER_SOURCE_NEUROSPACES
702:
703: //m identification
704:
705: ADDRESSING_NEUROSPACES_2_HECCER(5000),
706:
707: #endif
708:
709: #ifdef HECCER_SOURCE_TYPING
710:
711: //m model source type number
712:
713: //! source typing is used to compute aggregate currents ao
714: //! things.
715:
716: 2,
717:
718: #endif
719:
720: },
721:
722: //m first set of descriptive values, alphabetical order
723:
724: //m initial reversal potential
725:
726: 0.045,
727:
728: //m get reversal potential from this intermediary, -1 for none
729:
730: -1,
731:
732: //m maximal conductance when all channels are permissive
733:
734: 0.0002092393115,
735:
736: //m contributes to this concentration pool, -1 for none, boolean indicator only.
737:
738: -1,
739:
740: //m activation description
741:
742: {
743: //m power, for a standard heccer, something between 1 and 4 or so.
744:
745: 3,
746:
747: //m gate definition
748:
749: {
750: //m initial value, commonly forward over backward steady states
751:
752: 0.0078406449371415214,
753:
754: //m corresponding index in tables, set to -1 for initialization.
755:
756: -1,
757:
758: {
759: //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
760:
761: {
762: //m multiplier
763:
764: 35.0e3,
765:
766: //m multiplier membrane dependence, 0.0 for no dependence
767:
768: 0.0,
769:
770: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
771:
772: 0.0,
773:
774: //m choose between nominator or denominator, 1 means nominator, -1
775: //m means denominator
776:
777: -1.0,
778:
779: //m nominator or denominator offset
780:
781: 0.0,
782:
783: //m membrane offset
784:
785: 5.0e-3,
786:
787: //m denormalized time constant
788:
789: -10.0e-3,
790: },
791:
792: //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
793:
794: {
795: //m multiplier
796:
797: 7.0e3,
798:
799: //m multiplier membrane dependence, 0.0 for no dependence
800:
801: 0.0,
802:
803: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
804:
805: 0.0,
806:
807: //m choose between nominator or denominator, 1 means nominator, -1
808: //m means denominator
809:
810: -1.0,
811:
812: //m nominator or denominator offset
813:
814: 0.0,
815:
816: //m membrane offset
817:
818: 65.0e-3,
819:
820: //m denormalized time constant
821:
822: 20.0e-3,
823: },
824: },
825: },
826: },
827:
828: //m inactivation description
829:
830: {
831: //m power, for a standard heccer, something between 1 and 4 or so.
832:
833: 1,
834:
835: //m gate definition
836:
837: {
838: //m initial value, commonly forward over backward steady states
839:
840: 0.26397776926502026,
841:
842: //m corresponding index in tables, set to -1 for initialization.
843:
844: -1,
845:
846: {
847: //m forward kinetiks, commonly denoted with alpha or non-perm to perm rate
848:
849: {
850: //m multiplier
851:
852: 0.225e3,
853:
854: //m multiplier membrane dependence, 0.0 for no dependence
855:
856: 0.0,
857:
858: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
859:
860: 0.0,
861:
862: //m choose between nominator or denominator, 1 means nominator, -1
863: //m means denominator
864:
865: -1.0,
866:
867: //m nominator or denominator offset
868:
869: 1.0,
870:
871: //m membrane offset
872:
873: 80.0e-3,
874:
875: //m denormalized time constant
876:
877: 10.0e-3,
878: },
879:
880: //m backward kinetiks, commonly denoted with beta or perm to non-perm rate
881:
882: {
883: //m multiplier
884:
885: 7.5e3,
886:
887: //m multiplier membrane dependence, 0.0 for no dependence
888:
889: 0.0,
890:
891: //m 2b: multiplier membrane dependence offset, 0.0 for no dependence
892:
893: 0.0,
894:
895: //m choose between nominator or denominator, 1 means nominator, -1
896: //m means denominator
897:
898: -1.0,
899:
900: //m nominator or denominator offset
901:
902: 0.0,
903:
904: //m membrane offset
905:
906: -3.0e-3,
907:
908: //m denormalized time constant
909:
910: -18.0e-3,
911: },
912: },
913: },
914: },
915: };
916:
917:
918: int piC2m[] =
919: {
920: 4,
921: -1,
922: };
923:
924:
925: struct MathComponentArray mca =
926: {
927: //m number of math components
928:
929: 4,
930:
931: //m math component data
932:
933: NULL,
934:
935: //m math component index, initialize to NULL
936:
937: NULL,
938:
939: };
940:
941:
942: struct Intermediary inter =
943: {
944: //m compartment array
945:
946: 1,
947:
948: &compSoma,
949:
950: //m all other mathematical components
951:
952: &mca,
953:
954: //m compartment 2 first mechanism number
955:
956: piC2m,
957:
958: #ifdef HECCER_SOURCE_NEUROSPACES
959:
960: //m identification of the originator, mostly a cell or cell
961: //m population, but perhaps just a segment vector
962:
963: //m start range
964:
965: ADDRESSING_NEUROSPACES_2_HECCER(1000 - 1),
966:
967: //m end range
968:
969: ADDRESSING_NEUROSPACES_2_HECCER(9000),
970:
971: #endif
972:
973: };
974:
975:
976: int main(int argc, char *argv[])
977: {
978: //- determine intermediary size, and allocate
979:
980: struct MathComponentInfo *pmciCaT = MathComponentInfoLookup(caiCaT.mc.iType);
981:
982: struct MathComponentInfo *pmciKdr = MathComponentInfoLookup(csstKdr.mc.iType);
983:
984: struct MathComponentInfo *pmciNaP = MathComponentInfoLookup(caNaP.mc.iType);
985:
986: struct MathComponentInfo *pmciNaF = MathComponentInfoLookup(caiNaF.mc.iType);
987:
988: //- prepare the mechanism intermediary
989:
990: int iChars = pmciCaT->iChars + pmciKdr->iChars + pmciNaP->iChars + pmciNaF->iChars;
991:
992: void *pmc = calloc(sizeof(char), iChars);
993:
994: struct MathComponent *pmcTarget = pmc;
995:
996: pmcTarget = MathComponentCopyNext(pmcTarget, &caiCaT.mc);
997: pmcTarget = MathComponentCopyNext(pmcTarget, &csstKdr.mc);
998: pmcTarget = MathComponentCopyNext(pmcTarget, &caNaP.mc);
999: pmcTarget = MathComponentCopyNext(pmcTarget, &caiNaF.mc);
1000:
1001: //- link the intermediary
1002:
1003: mca.pmc = pmc;
1004:
1005: //- do the simulation
1006:
1007: simulate(argc,argv);
1008:
1009: #ifdef HECCER_SOURCE_NEUROSPACES
1010:
1011: //- address variables via the external ids
1012:
1013: double *pdAggregator0External = HeccerAddressVariable(pheccer, 1000 - 1, "aggregator[0]");
1014:
1015: double *pdAggregator1External = HeccerAddressVariable(pheccer, 1000 - 1, "aggregator[1]");
1016:
1017: double *pdAggregator2External = HeccerAddressVariable(pheccer, 1000 - 1, "aggregator[2]");
1018:
1019: #endif
1020:
1021: //- address variables via the internal indices
1022:
1023: double *pdAggregator0Internal = HeccerAddressAggregator(pheccer, 0, "aggregator[0]");
1024:
1025: double *pdAggregator1Internal = HeccerAddressAggregator(pheccer, 1, "aggregator[1]");
1026:
1027: double *pdAggregator2Internal = HeccerAddressAggregator(pheccer, 2, "aggregator[2]");
1028:
1029: #ifdef HECCER_SOURCE_NEUROSPACES
1030:
1031: if (pdAggregator0Internal != pdAggregator0External)
1032: {
1033: fprintf(stdout, "*** Error: (pdAggregator0Internal != pdAggregator0External)\n");
1034:
1035: exit(EXIT_FAILURE);
1036: }
1037:
1038: if (pdAggregator1Internal != pdAggregator1External)
1039: {
1040: fprintf(stdout, "*** Error: (pdAggregator1Internal != pdAggregator1External)\n");
1041:
1042: exit(EXIT_FAILURE);
1043: }
1044:
1045: if (pdAggregator2Internal != pdAggregator2External)
1046: {
1047: fprintf(stdout, "*** Error: (pdAggregator2Internal != pdAggregator2External)\n");
1048:
1049: exit(EXIT_FAILURE);
1050: }
1051:
1052: #endif
1053:
1054: fprintf(stdout, "pdAggregator0 is %g\n", pdAggregator0External[0]);
1055:
1056: fprintf(stdout, "pdAggregator1 is %g\n", pdAggregator1External[0]);
1057:
1058: fprintf(stdout, "pdAggregator2 is %g\n", pdAggregator2External[0]);
1059:
1060: //- set default result : ok
1061:
1062: int iResult = EXIT_SUCCESS;
1063:
1064: //- return result
1065:
1066: return(iResult);
1067: }
1068:
1069:
1070: #define main(argc,argv) simulate(argc,argv)
1071:
1072: //t this prototype can give warning and perhaps errors.
1073:
1074: int main(int argc, char *argv[]);
1075:
1076:
1077: #include "main.c"
1078:
1079:
1080:
Generated by Xrefactory version 2.0.14 on Thu Jul 24 22:41:20 2008