Changeset 31400 in project


Ignore:
Timestamp:
09/12/14 09:31:07 (7 years ago)
Author:
Ivan Raikov
Message:

nemo: completed initial conversion of nmodl backend to templates

File:
1 edited

Legend:

Unmodified
Added
Removed
  • release/4/nemo/trunk/nemo-nmodl.scm

    r31375 r31400  
    456456#<<EOF
    457457
    458 FUNCTION {{functionName}} ({{join(",", functionVars)}}) {
     458FUNCTION {{functionName}} ({{join(", ", functionVars)}}) {
    459459{% if (!(localVars == [])) %}
    460 LOCAL {{join(",", localVars)}}
    461 {% endif %}
    462 {{ exprString }}
     460LOCAL {{join(", ", localVars)}}
     461{% endif %}
     462
     463{{ pad(indent,exprString) }}
     464
    463465}
    464466
     
    481483             (tmpl-vars
    482484              `(
     485                (indent       . ,(ersatz:sexpr->tvalue indent+))
    483486                (functionName . ,(ersatz:sexpr->tvalue (nmodl-name n)))
    484487                (functionVars . ,(ersatz:sexpr->tvalue vars))
     
    499502TITLE {{modelName}}
    500503
     504
    501505COMMENT
    502506This file was generated by {{nemoVersionString}} on {{currentTimestamp}}
     507
    503508ENDCOMMENT
    504509
     
    515520
    516521{% if (hasEvents) %}
    517 POINT_PROCESS {{modelName}}
    518 {% endif %}
    519 
     522  POINT_PROCESS {{modelName}}
     523
     524{% endif %}
    520525{# NMODL has a line character limit, so we limit the number of entries in each RANGE stmt to 10 #}
    521 
    522 COMMENT
    523  exports
    524 ENDCOMMENT
    525 
    526526{% for exportGroup in groupBy(10, exports) %}
    527 RANGE {{join(",", exportGroup)}}
    528 {% endfor %}
    529 
     527{% if (!(exportGroup == [])) %}
     528  RANGE {{join(", ", exportGroup)}}
     529
     530{% endif %}
     531{% endfor %}
    530532{% if (!(currents == [])) %}
    531 RANGE {{join(",", currents)}}
    532 {% endif %}
    533 
     533  RANGE {{join(", ", currents)}}
     534
     535{% endif %}
    534536{#
    535537   if rev potential is defined for this ion, declare the ionic current
     
    537539   the ionic current as a range variable
    538540#}
    539 
    540541{% for p in permeatingIons %}
    541542{% if (p.species == "non-specific") %}
    542 RANGE {{p.e}}
     543  RANGE {{p.e}}
     544
    543545{% elseif (p.erev) %}
    544 RANGE {{p.i}}, {{p.e}}
     546  RANGE {{p.i}}, {{p.e}}
     547
    545548{% else %}
    546 RANGE {{p.i}}
    547 {% endif %}
    548 {% endfor %}
    549 
     549  RANGE {{p.i}}
     550
     551{% endif %}
     552{% endfor %}
    550553{% for p in poolIons %}
    551 RANGE {{p.in}}, {{p.out}}
    552 {% endfor %}
    553 
     554  RANGE {{p.in}}, {{p.out}}
     555
     556{% endfor %}
    554557{% if (accumulatingIons == []) %}
    555558{% for p in poolIons %}
    556 RANGE {{p.in}}, {{p.out}}
     559  RANGE {{p.in}}, {{p.out}}
     560
    557561{% endfor %}
    558562{% for m in modulatingIons %}
    559 RANGE {{m.in}}, {{m.out}}
     563  RANGE {{m.in}}, {{m.out}}
     564
    560565{% endfor %}
    561566{% else %}
    562567{% for a in accumulatingIons %}
    563 RANGE {{a.i}}
    564 {% endfor %}
    565 {% endif %}
    566 
    567 COMMENT
    568 range parameters
    569 ENDCOMMENT
    570 
     568  RANGE {{a.i}}
     569
     570{% endfor %}
     571{% endif %}
    571572{% for parameterGroup in groupBy(10, rangeParameters) %}
    572 RANGE {{join(",", parameterGroup)}}
    573 {% endfor %}
    574 
    575 COMMENT
    576 use ions
    577 ENDCOMMENT
    578 
     573{% if (!(parameterGroup == [])) %}
     574  RANGE {{join(", ", parameterGroup)}}
     575
     576{% endif %}
     577{% endfor %}
    579578{% for useIon in useIons %}
    580579{% if (useIon.nonSpecific) %}
    581 NONSPECIFIC_CURRENT {{useIon.name}}
     580  NONSPECIFIC_CURRENT {{useIon.name}}
     581
    582582{% elseif (useIon.valence && (!(useIon.write == [])) && (!(useIon.read == [])) ) %}
    583 USEION {{useIon.name}} READ {{join (", ", useIon.read)}} WRITE {{join (", ", useIon.write)}} VALENCE {{useIon.valence}}
     583  USEION {{useIon.name}} READ {{join (", ", useIon.read)}} WRITE {{join (", ", useIon.write)}} VALENCE {{useIon.valence}}
     584
    584585{% elseif (useIon.valence && (useIon.write == []) && (!(useIon.read == [])) ) %}
    585 USEION {{useIon.name}} READ {{join (", ", useIon.read)}} VALENCE {{useIon.valence}}
     586  USEION {{useIon.name}} READ {{join (", ", useIon.read)}} VALENCE {{useIon.valence}}
     587
    586588{% elseif ((!(useIon.write == [])) && (!(useIon.read == [])) ) %}
    587 USEION {{useIon.name}} READ {{join (", ", useIon.read)}} WRITE {{join (", ", useIon.write)}}
     589  USEION {{useIon.name}} READ {{join (", ", useIon.read)}} WRITE {{join (", ", useIon.write)}}
     590
    588591{% elseif ((useIon.write == []) && (!(useIon.read == [])) ) %}
    589 USEION {{useIon.name}} READ {{join (", ", useIon.read)}}
    590 {% endif %}
    591 {% endfor %}
     592  USEION {{useIon.name}} READ {{join (", ", useIon.read)}}
     593
     594{% endif %}
     595{% endfor %}
     596
    592597}
    593598
     
    601606   (ersatz:template-std-env autoescape: #f)
    602607#<<EOF
     608
    603609PARAMETER {
    604610{% if (!(parameterLocals == [])) %}
    605   LOCAL {{join(",1", parameterLocals)}}
    606 {% endif %}
    607 
     611  LOCAL {{join(", ", parameterLocals)}}
     612{% endif %}
    608613{% for parameterDef in parameterDefs %}
    609 {{parameterDef}}
     614{{pad(indent,parameterDef)}}
     615
    610616{% endfor %}
    611617
     
    620626   (ersatz:template-std-env autoescape: #f)
    621627#<<EOF
     628{% if (!(stateDefs == [])) %}
     629
    622630STATE {
    623 {% for stateDef in stateDefs %}
    624 {{stateDef}}
    625 {% endfor %}
     631{% for def in stateDefs %}
     632{{pad(indent,def)}}
     633
     634{% endfor %}
     635
    626636}
     637
     638{% endif %}
    627639
    628640EOF
    629641))
     642
    630643
    631644(define assigned-template
     
    633646   (ersatz:template-std-env autoescape: #f)
    634647#<<EOF
     648
    635649ASSIGNED {
    636 {% for assignedDef in assignedDefs %}
    637 {{assignedDef}}
    638 {% endfor %}
     650{% for def in assignedDefs %}
     651{{pad(indent,def)}}
     652
     653{% endfor %}
     654
    639655}
    640656
     
    648664#<<EOF
    649665{% if (!(assignedEqDefs == [])) %}
     666
    650667PROCEDURE asgns () {
    651668{% if (!(assignedEqLocals == [])) %}
    652 LOCAL {{join(",", assignedEqLocals)}}
     669  LOCAL {{join(", ", assignedEqLocals)}}
    653670{% endif %}
    654671{% for assignedEqDef in assignedEqDefs %}
    655 {{assignmentEqDef}}
    656 {% endfor %}
     672{{pad(indent,assignedEqDef)}}
     673
     674{% endfor %}
     675
    657676}
    658677
     
    667686#<<EOF
    668687{% if (!(reactionEqDefs == [])) %}
     688
    669689PROCEDURE reactions () {
    670 {% if (!(reactionLocals == [])) %}
    671 LOCAL {{join(",3", reactionLocals)}}
     690{% if (!(reactionEqLocals == [])) %}
     691  LOCAL {{join(", ", reactionEqLocals)}}
    672692{% endif %}
    673693{% for reactionEqDef in reactionEqDefs %}
    674 {{reactionEqDef}}
    675 {% endfor %}
     694{{pad(indent,reactionEqDef)}}
     695
     696{% endfor %}
     697
    676698}
    677699
     
    686708#<<EOF
    687709{% if (!(poolIons == [])) %}
     710
    688711PROCEDURE pools () {
    689712{% for poolIon in poolIons %}
    690 {{poolIon.in}} = {{poolIon.inq}}
    691 {{poolIon.out}} = {{poolIon.outq}}
    692 {% endfor %}
     713  {{poolIon.in}} = {{poolIon.inq}}
     714
     715  {{poolIon.out}} = {{poolIon.outq}}
     716
     717{% endfor %}
     718
    693719}
    694720
    695721{% endif %}
     722EOF
     723))
     724
     725
     726(define rate-template
     727  (ersatz:statements-from-string
     728   (ersatz:template-std-env autoescape: #f)
     729#<<EOF
     730{% if (!(rateEqDefs == [])) %}
     731DERIVATIVE states {
     732{% if (!(rateEqLocals == [])) %}
     733  LOCAL {{join(", ", rateEqLocals)}}
     734{% endif %}
     735
     736{% for externalEqDef in externalEqDefs %}
     737{{pad(indent,externalEqDef)}}
     738
     739{% endfor %}
     740
     741{% if (!(assignedEqDefs == [])) %}
     742  asgns()
     743
     744{% endif %}
     745
     746{% for rateEqDef in rateEqDefs %}
     747{{pad(indent,rateEqDef)}}
     748
     749{% endfor %}
     750
     751}
     752
     753{% endif %}
     754EOF
     755))
     756
     757
     758(define kstates-template
     759  (ersatz:statements-from-string
     760   (ersatz:template-std-env autoescape: #f)
     761#<<EOF
     762{% if (!(kineticEqDefs == [])) %}
     763KINETIC kstates {
     764{% if (!(kineticEqLocals == [])) %}
     765  LOCAL {{join(", ", kineticEqLocals)}}
     766{% endif %}
     767
     768{% for externalEqDef in externalEqDefs %}
     769{{pad(indent,externalEqDef)}}
     770
     771{% endfor %}
     772
     773{% if (!(assignedEqDefs == [])) %}
     774  asgns()
     775
     776{% endif %}
     777
     778{% for kineticEqDef in kineticEqDefs %}
     779{% for eq in kineticEqDef %}
     780{{pad(indent,eq)}}
     781
     782{% endfor %}
     783{% endfor %}
     784
     785}
     786
     787{% endif %}
     788EOF
     789))
     790
     791
     792(define initial-template
     793  (ersatz:statements-from-string
     794   (ersatz:template-std-env autoescape: #f)
     795#<<EOF
     796{% if (!(initEqDefs == [])) %}
     797
     798INITIAL {
     799{% if (!(initEqLocals == [])) %}
     800  LOCAL {{join(", ", initEqLocals)}}
     801{% endif %}
     802
     803{% for externalEqDef in externalEqDefs %}
     804{{pad(indent,externalEqDef)}}
     805
     806{% endfor %}
     807
     808{% if (!(assignedEqDefs == [])) %}
     809  asgns()
     810
     811{% endif %}
     812         
     813{% for initEqDef in initEqDefs %}
     814{{pad(indent,initEqDef)}}
     815
     816{% endfor %}
     817
     818{% if (hasKinetic) %}
     819  SOLVE kstates STEADYSTATE sparse
     820  reactions()
     821
     822{% endif %}
     823         
     824{% for eq in reversalPotentialEqDefs %}
     825{{pad(indent,eq)}}
     826
     827{% endfor %}
     828
     829
     830{% if (!(poolIons == [])) %}
     831  pools()
     832
     833{% endif %}
     834         
     835}
     836
     837{% endif %}
     838
     839EOF
     840))
     841
     842
     843(define event-template
     844  (ersatz:statements-from-string
     845   (ersatz:template-std-env autoescape: #f)
     846#<<EOF
     847
     848{% if (hasEvents) %}
     849NET_RECEIVE ({{join(",",eventVars)}}) {
     850{% if (!(eventLocals == [])) %}
     851LOCAL {{join(", ", eventLocals)}}
     852{% endif %}
     853         
     854{% for eq in externalEventEqDefs %}
     855{{pad(indent,eq)}}
     856
     857{% endfor %}
     858         
     859{% for eq in transientEventEqDefs %}
     860{{pad(indent,eq)}}
     861
     862{% endfor %}
     863
     864}
     865{% endif %}
     866
    696867EOF
    697868))
     
    776947             (external-eq-defs   (sys->external-eq-defs sys nmodl-name rhsexpr/NMODL canonicalize-expr/NMODL
    777948                                                        namespace-filter: (lambda (x) (not (equal? x 'event)))))
     949             (external-event-eq-defs   (sys->external-eq-defs
     950                                        sys nmodl-name rhsexpr/NMODL canonicalize-expr/NMODL
     951                                        namespace-filter: (lambda (x) (equal? x 'event))))
     952
    778953             (asgn-eq-defs       (poset->asgn-eq-defs poset sys nmodl-name rhsexpr/NMODL canonicalize-expr/NMODL))
    779954             (asgn-eq-defs       (append asgn-eq-defs
     
    11141289               (reaction-locals (find-locals (map second reaction-eq-defs)))
    11151290
    1116                )
     1291               (rate-locals  (find-locals (map second rate-eq-defs)))
     1292
     1293               (init-locals (find-locals (map second state-init-defs)))
     1294
     1295               (event-locals (find-locals (map second transient-event-defs)))
     1296               (event-vars   (delete-duplicates
     1297                              (filter-map
     1298                               (lambda (x) (let ((ns (third x)))
     1299                                             (and (equal? ns 'event) (second x))))
     1300                               imports)))
     1301               )
    11171302             
    11181303        (let* (
     1304               (prime (lambda (x) (s+ x "'")))
     1305
    11191306               (tenv-enter
    11201307                (lambda (x env)
    11211308                  (let ((k (car x)) (v (cdr x)))
    1122                     (print "k = " k " v = " v)
    11231309                    (cons (cons k (if (null? v) (ersatz:Tlist '()) (ersatz:sexpr->tvalue v))) env))))
    11241310
     
    11261312                (fold tenv-enter '()
    11271313                `(
     1314                  (indent            . ,indent+)
    11281315                  (modelName         . ,sysname)
    11291316                  (currentTimestamp  . ,(seconds->string (current-seconds)))
    11301317                  (nemoVersionString . ,(nemo:version-string))
     1318                  (hasEvents         . ,has-events?)
     1319                  (hasKinetic        . ,has-kinetic?)
    11311320                  (exports           . ,(map nmodl-name exports))
    11321321                  (currents          . ,(append
     
    11701359                                          (lambda (x)
    11711360                                            (let ((u (cdr x)))
    1172                                               (print "u = " u)
    11731361                                              (cases useion u
    11741362                                                     (UseIon (name read write valence)
     
    12291417                                              (expr->string/NMODL b n)))
    12301418                                          reaction-eq-defs))
     1419
     1420                  (rateEqLocals . ,rate-locals)
     1421
     1422                  (rateEqDefs . ,(map (lambda (def)
     1423                                        (let ((n (prime (first def)))
     1424                                              (b (second def)))
     1425                                          (expr->string/NMODL b n)))
     1426                                      rate-eq-defs))
     1427
     1428                  (externalEqDefs . ,(map (lambda (def)
     1429                                            (let ((n (nmodl-name (first def))) (b (second def)))
     1430                                              (expr->string/NMODL b n)))
     1431                                          external-eq-defs))
     1432
     1433                  (kineticEqLocals . ,(let* ((exprs (concatenate (map second kstate-eq-defs))))
     1434                                        (concatenate
     1435                                         (find-locals
     1436                                          (append (map fourth exprs)
     1437                                                  (filter-map (lambda (x) (and (> (length x) 4) (fifth x))) exprs))))))
     1438
     1439                  (kineticEqDefs . ,(map
     1440                                     (lambda (def)
     1441                                       (let* ((n (first def))
     1442                                              (eqs (let ((eqs (second def)))
     1443                                                     (let-values (((pair-eqs1 rest)
     1444                                                                   (partition (lambda (eq) (match eq (('<-> a b r1 r2) eq) (else #f))) eqs)))
     1445                                                       (let ((pair-eqs2
     1446                                                              (append
     1447                                                               (filter-map
     1448                                                                (lambda (eq)
     1449                                                                  (match eq
     1450                                                                         (('-> s0 s1 rexpr)
     1451                                                                          (let ((rev
     1452                                                                                 (find (lambda (r)
     1453                                                                                         (match r (('-> t0 t1 texpr)
     1454                                                                                                   (and (equal? s0 t1) (equal? s1 t0) texpr))
     1455                                                                                                (else #f)))
     1456                                                                                       eqs)))
     1457                                                                            (if rev
     1458                                                                                `(<-> ,s0 ,s1 ,rexpr ,(fourth rev))
     1459                                                                                (error  'nemo-nmodl "-> kinetic equation not supported in NMODL" eq))))
     1460                                                                         (('<-> s0 s1 rexpr1 rexpr2)  #f)
     1461                                                                         ))
     1462                                                                rest))))
     1463                                                         (append pair-eqs1 (delete-duplicates
     1464                                                                            pair-eqs2
     1465                                                                            (lambda (x y)
     1466                                                                              (match (list x y)
     1467                                                                                     ((('<-> s0 s1 s t) ('<-> t0 t1 u v))
     1468                                                                                      (and (equal? s0 t1) (equal? s1 t0)))
     1469                                                                                     (else #f)))))
     1470                                                         
     1471                                                         ))
     1472                                                     ))
     1473                                              (conserve-eqs  (lookup-def (nmodl-name n) conserve-eq-defs)))
     1474
     1475                                         (append
     1476                                          (map
     1477                                           (lambda (eq)
     1478                                             (match eq
     1479                                                    (('-> s0 s1 rexpr)
     1480                                                     (error 'nemo-nmodl "-> kinetic equation not supported in NMODL" eq))
     1481                                                    (('<-> s0 s1 rexpr1 rexpr2) 
     1482                                                     (sprintf "~~ ~A <-> ~A (~A, ~A)"
     1483                                                              s0 s1
     1484                                                              (expr->string/NMODL rexpr1)
     1485                                                              (expr->string/NMODL rexpr2)
     1486                                                              ))
     1487                                                    ))
     1488                                           eqs)
     1489                                          (map (lambda (eq)
     1490                                                 (let ((val  (first eq))
     1491                                                       (expr (third eq)))
     1492                                                   (conserve-conseq->string/NMODL expr val)))
     1493                                               conserve-eqs))
     1494                                         ))
     1495                                     kstate-eq-defs))
     1496
     1497
     1498                  (reversalPotentialEqDefs .
     1499                                           ,(filter-map
     1500                                             (lambda (gate-complex)
     1501                                               (let* ((label             (first gate-complex))
     1502                                                      (n                 (second gate-complex))
     1503                                                      (subcomps          ((dis 'component-subcomps) sys n))
     1504                                                      (perm              (lookup-def 'permeating-ion subcomps))
     1505                                                      (permqs            (and perm ((dis 'component-exports) sys (cid perm))))
     1506                                                      )
     1507                                                 (and perm
     1508                                                      (case (cn perm)
     1509                                                        ((non-specific)
     1510                                                         (let* ((e      (nmodl-name 'e))
     1511                                                                (elocal (car permqs)))
     1512                                                           (and (not (equal? e elocal))
     1513                                                                (expr->string/NMODL (nmodl-name elocal) e))))
     1514                                                        (else #f)))
     1515                                                 ))
     1516                                             gate-complexes))
     1517                 
     1518
     1519                  (initEqLocals . ,init-locals)
     1520
     1521                  (initEqDefs . ,(map (lambda (def)
     1522                                        (let ((n (first def)) (b (second def)))
     1523                                          (expr->string/NMODL b n)))
     1524                                      state-init-defs))
     1525
     1526                  (eventLocals         . ,event-locals)
     1527                  (eventVars           . ,event-vars)
     1528
     1529                  (externalEventEqDefs . ,(map (lambda (def)
     1530                                                 (let ((n (nmodl-name (first def)) )
     1531                                                       (b (second def)))
     1532                                                   (expr->string/NMODL b n)))
     1533                                               external-event-eq-defs))
     1534
     1535                  (transientEventEqDefs . ,(map (lambda (def)
     1536                                                  (let ((n (nmodl-name (first def)) )
     1537                                                        (b (second def)))
     1538                                                    (expr->string/NMODL b n)))
     1539                                                transient-event-defs))
     1540
    12311541                  ))
    1232                 )
    1233 
    1234                )
    1235 
    1236 
    1237         (pp indent
    1238             ,(instantiate-template prelude-template tmpl-env)
    1239             ,(instantiate-template neuron-template tmpl-env)
    1240             ,(instantiate-template parameter-template tmpl-env)
    1241             ,(instantiate-template state-template tmpl-env)
    1242             ,(instantiate-template assigned-template tmpl-env)
    1243             )
     1542                ))
     1543
     1544
     1545          (instantiate-template prelude-template tmpl-env)
     1546          (instantiate-template neuron-template tmpl-env)
     1547          (instantiate-template parameter-template tmpl-env)
     1548          (instantiate-template state-template tmpl-env)
     1549          (instantiate-template assigned-template tmpl-env)
     1550           
     1551          (for-each (lambda (fndef)
     1552                      (if (not (member (car fndef) builtin-fns))
     1553                          (apply fn-translator fndef)))
     1554                    defuns)
    12441555       
    1245            
    1246         (for-each (lambda (fndef)
    1247                     (if (not (member (car fndef) builtin-fns))
    1248                         (apply fn-translator fndef)))
    1249                   defuns)
     1556          (instantiate-template asgns-template tmpl-env)
     1557          (instantiate-template reactions-template tmpl-env)
     1558          (instantiate-template pools-template tmpl-env)
     1559          (instantiate-template rate-template tmpl-env)
     1560          (instantiate-template kstates-template tmpl-env)
     1561          (instantiate-template initial-template tmpl-env)
     1562          (instantiate-template event-template tmpl-env)
    12501563       
    1251 
    1252         (pp indent
    1253             ,(instantiate-template asgns-template tmpl-env)
    1254             ,(instantiate-template reactions-template tmpl-env)
    1255             ,(instantiate-template pools-template tmpl-env)
    1256             )
    1257        
    1258         (if has-ode?
    1259             (let ((locals   (find-locals (map second rate-eq-defs))))
    1260               (case method
    1261                 ((expeuler) (pp indent ,nl (PROCEDURE states () "{")))
    1262                 (else       (pp indent ,nl (DERIVATIVE states "{"))))
    1263 
    1264               (if (not (null? current-locals)) (pp indent+ (LOCAL ,(slp ", " current-locals))))
    1265 
    1266               (for-each (lambda (def)
    1267                           (let ((n (first def))
    1268                                 (b (second def)))
    1269                             (pp indent+ ,(expr->string/NMODL b n))))
    1270                         external-eq-defs)
    1271              
    1272               (if (not (null? asgns))  (pp indent+ (asgns ())))
    1273 
    1274               (let ((prime (case method
    1275                              ((expeuler) identity)
    1276                              (else  (lambda (x) (s+ x "'"))))))
    1277                 (for-each (lambda (def)
    1278                             (let ((n (prime (first def)))
    1279                                   (b (second def)))
    1280                               (pp indent+ ,(expr->string/NMODL b n))))
    1281                           rate-eq-defs))
    1282               (pp indent "}")))
    1283        
    1284         (if has-kinetic?
    1285             (begin
    1286               (pp indent ,nl (KINETIC kstates "{"))
    1287 
    1288               (let* ((exprs             (concatenate (map second kstate-eq-defs)))
    1289                      (locals            (concatenate
    1290                                          (find-locals
    1291                                           (append (map fourth exprs)
    1292                                                   (filter-map (lambda (x) (and (> (length x) 4) (fifth x))) exprs))))))
    1293                 (if (not (null? locals)) (pp indent+ (LOCAL ,(slp ", " locals))))
    1294                
    1295                 (for-each (lambda (def)
    1296                             (let ((n (first def))
    1297                                   (b (second def)))
    1298                               (pp indent+ ,(expr->string/NMODL b n))))
    1299                           external-eq-defs)
    1300 
    1301                 (if (not (null? asgns))     (pp indent+ (asgns ())))
    1302                 (for-each
    1303                  (lambda (def)
    1304                    (let* ((n     (first def))
    1305                           (eqs   (let ((eqs (second def)))
    1306                                    (let-values (((pair-eqs1 rest)
    1307                                                  (partition (lambda (eq) (match eq (('<-> a b r1 r2) eq) (else #f))) eqs)))
    1308                                      (let ((pair-eqs2
    1309                                             (append
    1310                                              (filter-map
    1311                                               (lambda (eq)
    1312                                                 (match eq
    1313                                                        (('-> s0 s1 rexpr)
    1314                                                         (let ((rev
    1315                                                                (find (lambda (r)
    1316                                                                        (match r (('-> t0 t1 texpr)
    1317                                                                                  (and (equal? s0 t1) (equal? s1 t0) texpr))
    1318                                                                               (else #f)))
    1319                                                                      eqs)))
    1320                                                           (if rev
    1321                                                               `(<-> ,s0 ,s1 ,rexpr ,(fourth rev))
    1322                                                               (error  'nemo-nmodl "-> kinetic equation not supported in NMODL" eq))))
    1323                                                        (('<-> s0 s1 rexpr1 rexpr2)  #f)
    1324                                                        ))
    1325                                               rest))))
    1326                                      (append pair-eqs1 (delete-duplicates
    1327                                                         pair-eqs2
    1328                                                         (lambda (x y)
    1329                                                           (match (list x y)
    1330                                                                  ((('<-> s0 s1 s t) ('<-> t0 t1 u v))
    1331                                                                   (and (equal? s0 t1) (equal? s1 t0)))
    1332                                                                  (else #f)))))
    1333                                                                                                          
    1334                                      ))
    1335                                    ))
    1336                           (conserve-eqs  (lookup-def (nmodl-name n) conserve-eq-defs)))
    1337                      (for-each
    1338                       (lambda (eq)
    1339                         (match eq
    1340                                (('-> s0 s1 rexpr)
    1341                                 (error 'nemo-nmodl "-> kinetic equation not supported in NMODL" eq))
    1342                                (('<-> s0 s1 rexpr1 rexpr2) 
    1343                                 (pp indent+ (~ ,s0 <-> ,s1 (,(expr->string/NMODL rexpr1) #\,
    1344                                                             ,(expr->string/NMODL rexpr2)
    1345                                                             ))))
    1346                                ))
    1347                       eqs)
    1348                      (if conserve-eqs
    1349                          (for-each (lambda (eq)
    1350                                      (let ((val  (first eq))
    1351                                            (expr (third eq)))
    1352                                        (pp indent+ ,(conserve-conseq->string/NMODL expr val))))
    1353                                    conserve-eqs))
    1354                      ))
    1355                  kstate-eq-defs))
    1356               (pp indent "}")))
    1357        
    1358        
    1359         (let ((locals (find-locals (map second state-init-defs))))
    1360 
    1361           (pp indent ,nl (INITIAL "{"))
    1362          
    1363           (if (not (null? locals)) (pp indent+ (LOCAL ,(slp ", " locals))))
    1364 
    1365           (for-each (lambda (def)
    1366                       (let ((n (first def))
    1367                             (b (second def)))
    1368                         (pp indent+ ,(expr->string/NMODL b n))))
    1369                     external-eq-defs)
    1370 
    1371           (if (not (null? asgns))  (pp indent+ (asgns ())))
    1372 
    1373           (for-each (lambda (def)
    1374                       (let ((n (first def)) (b (second def)))
    1375                         (pp indent+ ,(expr->string/NMODL b n))))
    1376                     state-init-defs)
    1377 
    1378           (if has-kinetic?
    1379               (pp indent+
    1380                   (SOLVE kstates STEADYSTATE sparse)
    1381                   ("reactions ()")
    1382                 ))
    1383          
    1384           (for-each
    1385            (lambda (gate-complex)
    1386              
    1387              (let* ((label             (first gate-complex))
    1388                     (n                 (second gate-complex))
    1389                     (subcomps          ((dis 'component-subcomps) sys n))
    1390                     (perm              (lookup-def 'permeating-ion subcomps))
    1391                     (permqs            (and perm ((dis 'component-exports) sys (cid perm))))
    1392                     )
    1393                
    1394                (if perm
    1395                    
    1396                    (case (cn perm)
    1397                      ((non-specific)
    1398                       (let* ((e      (nmodl-name 'e))
    1399                              (elocal (car permqs)))
    1400                         (if (not (equal? e elocal))
    1401                             (pp indent+ ,(expr->string/NMODL (nmodl-name elocal) e)))))
    1402                      ))
    1403                      
    1404                ))
    1405            gate-complexes)
    1406 
    1407           (if (not (null? pool-ions)) (pp indent+ (pools ())))
    1408          
    1409           (pp indent "}")
    1410 
    1411           (if has-events?
    1412               (let* (
    1413                      (locals (find-locals (map second transient-event-defs)))
    1414                      (vars   (delete-duplicates
    1415                               (filter-map
    1416                                (lambda (x) (let ((ns (third x)))
    1417                                            (and (equal? ns 'event) (second x))))
    1418                              imports)))
    1419                      (external-eq-defs   (sys->external-eq-defs sys nmodl-name rhsexpr/NMODL canonicalize-expr/NMODL
    1420                                                                 namespace-filter: (lambda (x) (equal? x 'event))))
    1421                      )
    1422                
    1423                 (pp indent ,nl (NET_RECEIVE (,(slp ", " vars)) "{"))
    1424 
    1425                 (for-each (lambda (def)
    1426                             (let ((n (nmodl-name (first def)) )
    1427                                   (b (second def)))
    1428                               (pp indent+ ,(expr->string/NMODL b n))))
    1429                           external-eq-defs)
    1430 
    1431                 (for-each (lambda (def)
    1432                             (let ((n (nmodl-name (first def)) )
    1433                                   (b (second def)))
    1434                               (pp indent+ ,(expr->string/NMODL b n))))
    1435                           transient-event-defs)
    1436 
    1437                 (pp indent "}")
    1438                 ))
    1439            
    1440           (pp indent ,nl (PROCEDURE print_state () "{"))
    1441 
    1442           (let ((lst (sort (map (compose ->string first) rate-eq-defs) string<?)))
    1443             (for-each (lambda (x)
    1444                         (pp indent+ (printf (,(s+ #\" "NMODL state: t = %g v = %g "  x " = %g\\n"  #\") ", t, v, " ,x ))))
    1445                       lst))
    1446          
    1447           (let ((lst (sort (map (compose ->string first) reaction-eq-defs) string<?)))
    1448             (for-each (lambda (x)
    1449                         (pp indent+ (printf (,(s+ #\" "NMODL state: t = %g v = %g "  x " = %g\\n"  #\") ", t, v, " ,x ))))
    1450                       lst))
    1451          
    1452           (pp indent "}")
    14531564         
    14541565          ))
    14551566      ))
    14561567  ))
    1457 ))
    1458 
    1459 
     1568)
     1569
     1570
Note: See TracChangeset for help on using the changeset viewer.