Changeset 12835 in project


Ignore:
Timestamp:
12/17/08 03:49:10 (13 years ago)
Author:
Ivan Raikov
Message:

Renaming state complex to reaction.

Location:
release/3/nemo/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • release/3/nemo/trunk/examples/AKP06/OFF_ON_OFF_protocol.hoc

    r11848 r12835  
    1212//**********************************************************************
    1313proc simulate() { local preDT, mainDT, Kbin
    14 
    15 Kbin = gmax_Kbin
    16 gmax_Kbin = 0
     14   
     15Kbin = gbar_Kv3_PotIhCa
     16gbar_Kv3_PotIhCa = 0
    1717
    1818mainDT = dt
     
    2222tstop = prelength
    2323run()
    24 gmax_Kbin = Kbin
     24
     25gbar_Kv3_PotIhCa = Kbin
    2526if ( stoprun == 1) return
    2627
    27 gmax_Kbin = 0
     28gbar_Kv3_PotIhCa = 0
    2829dt = mainDT
    2930continuerun(prelength + mainlength1)
    30 gmax_Kbin = Kbin
     31gbar_Kv3_PotIhCa = Kbin
    3132if ( stoprun == 1) return
    3233
    33 gmax_Kbin = Kbin
     34gbar_Kv3_PotIhCa = Kbin
    3435continuerun(prelength + mainlength1 + mainlength2)
    3536if ( stoprun == 1) return
    3637
    37 gmax_Kbin = 0
     38gbar_Kv3_PotIhCa = 0
    3839continuerun(prelength + mainlength1 + mainlength2 + mainlength3)
    39 gmax_Kbin = Kbin
     40gbar_Kv3_PotIhCa = Kbin
    4041
    4142if ( stoprun == 1) return
  • release/3/nemo/trunk/examples/hh-substrate.nemo

    r12708 r12835  
    3434            ;; each statement in the transitions block is of the form (-> SRC DEST RATE)
    3535            ;;
    36             (state-complex (m (transitions (<-> C O (amf (v)) (bmf (v))) )
     36            (reaction (m (transitions (<-> C O (amf (v)) (bmf (v))) )
    3737                              ;(initial (amf (Vrest) / (amf (Vrest) + bmf (Vrest))) )
    3838                              (conserve (1 = (C + O)))
     
    4040           
    4141            ;; the value of state complex h is determined by state h1 (open state)
    42             (state-complex (h (transitions (<-> C O (ahf (v)) (bhf (v))))
     42            (reaction (h (transitions (<-> C O (ahf (v)) (bhf (v))))
    4343                              ;(initial (ahf (Vrest) / (ahf (Vrest) + bhf (Vrest))) )
    4444                              (conserve (1 = (C + O)))
     
    7575            ;;
    7676            ;; the value of state complex n is determined by state n1 (open state)
    77             (state-complex (n (transitions (<-> C O (anf (v)) (bnf (v))) )
     77            (reaction (n (transitions (<-> C O (anf (v)) (bnf (v))) )
    7878                              ;(initial (anf (Vrest) / (anf (Vrest) + bnf (Vrest))) )
    7979                              (conserve (1 = (C + O)))
  • release/3/nemo/trunk/nemo-core.scm

    r12784 r12835  
    4444                 nemo:rhs? nemo:lineq? nemo:subst-term nemo:binding? nemo:bind
    4545                 eval-nemo-system-decls
    46                  TSCOMP ASGN CONST PRIM))
     46                 REACTION ASGN CONST PRIM))
    4747
    4848;--------------------
     
    112112  (ASGN       (name symbol?) (value number?) (rhs rhs?) )
    113113  (CONST      (name symbol?) (value number?))
    114   (TSCOMP     (name symbol?)
     114  (REACTION     (name symbol?)
    115115              (initial      (lambda (x) (or (rhs? x) (not x))))
    116116              (open         (lambda (x) (or (symbol? x) (and (list? x) (every symbol? x) ))))
     
    402402                                              " requires an integer power (" power  " was given)"))
    403403                             
    404                               (let ((en (TSCOMP name initial open transitions (and conserve (list conserve)) power)))
     404                              (let ((en (REACTION name initial open transitions (and conserve (list conserve)) power)))
    405405                                (environment-extend! nemo-env sym en)))))
    406406
     
    615615                      (if (nemo:quantity? x)
    616616                           (cases nemo:quantity x
    617                                   (TSCOMP (name initial open transitions conserve power)
     617                                  (REACTION (name initial open transitions conserve power)
    618618                                          (let* ((ss1 (delete-duplicates (append (map second transitions)
    619619                                                                                 (map third transitions))))
     
    625625
    626626
    627   (define (stcomps nemo-env)
     627  (define (reactions nemo-env)
    628628      (fold (lambda (sym ax)
    629629                    (let ((x (environment-ref nemo-env sym)))
    630630                      (if (nemo:quantity? x)
    631631                           (cases nemo:quantity x
    632                                   (TSCOMP (name initial open transitions conserve power)
     632                                  (REACTION (name initial open transitions conserve power)
    633633                                          (cons name ax))
    634634                                  (else ax))
     
    670670                              (fprintf out "    value: ~a\n" value)))
    671671
    672                      (TSCOMP (name initial open transitions conserve power)
     672                     (REACTION (name initial open transitions conserve power)
    673673                             (begin
    674674                               (fprintf out "~a: transition state complex\n" name)
     
    714714    (and (nemo:quantity? x)
    715715         (cases nemo:quantity x
    716                 (TSCOMP (name initial open transitions)  #t)
     716                (REACTION (name initial open transitions)  #t)
    717717                (else #f))))
    718718
     
    721721    (and (nemo:quantity? x)
    722722         (cases nemo:quantity x
    723                 (TSCOMP (name initial open transitions) 
     723                (REACTION (name initial open transitions) 
    724724                        (begin
    725725                          (map cadddr transitions)))
     
    803803                         (and (nemo:quantity? x)
    804804                              (cases nemo:quantity x
    805                                      (TSCOMP (name initial open transitions)
     805                                     (REACTION (name initial open transitions)
    806806                                             (let ((rs (map cadddr transitions)))
    807807                                               (list 'ts sym rs)))
     
    870870      ((asgns)               asgns)
    871871      ((states)              states)
    872       ((stcomps)             stcomps)
     872      ((reactions)           reactions)
    873873      ((defuns)              defuns)
    874874      ((consts)              consts)
     
    951951
    952952                            ;; state transition complex
    953                             (((or 'state-complex 'STATE-COMPLEX) ((and id (? symbol?)) . alst) )
     953                            (((or 'reactive 'REACTION) ((and id (? symbol?)) . alst) )
    954954                             (let* ((initial      (lookup-def 'initial alst))
    955955                                    (conserve-eq  (alist-ref 'conserve alst))
     
    11081108                                            "id = expr"))
    11091109                           
    1110                             (((or 'state-complex 'STATE-COMPLEX) . _)
     1110                            (((or 'reaction 'REACTION) . _)
    11111111                             (nemo:error 'eval-nemo-system-decls
    1112                                             "state complex declarations must be of the form: "
    1113                                             "state-complex (id ...)"))
     1112                                            "reaction declarations must be of the form: "
     1113                                            "reaction (id ...)"))
    11141114                           
    11151115                            (((or 'defun 'DEFUN) . _)
  • release/3/nemo/trunk/nemo-eggdoc.scm

    r12470 r12835  
    8080            (describe "--nmodl[=FILE]"     "write NMODL output to file (default: <model-name>.mod")
    8181            (describe "--nmodl-method=METHOD"  "specify NMODL integration method (cnexp, derivimplicit)")
    82             (describe "--nmodl-kinetic=[STATES]" "use NMODL kinetic equations for the given state complexes ")
     82            (describe "--nmodl-kinetic=[STATES]" "use NMODL kinetic equations for the given reactions")
    8383            (describe "--nmodl-depend=VARS" "specify DEPEND variables for NMODL interpolation tables ")
    8484            (describe "-t"                 "use interpolation tables in generated code")
     
    114114                        "(an expression that can refer to other quantities in the system)."))
    115115
    116              ( (ebnf-form (ebnf-kw "STATE-COMPLEX") (ebnf-var "ID") (ebnf-var "TRANSITIONS")
     116             ( (ebnf-form (ebnf-kw "REACTION") (ebnf-var "ID") (ebnf-var "TRANSITIONS")
    117117                          (ebnf-var "INITIAL-EXPR") (ebnf-var "OPEN-ID"))
    118                (p "Declares a state complex quantity. See below for the syntax of state transition equations. "
     118               (p "Declares a reaction quantity. See below for the syntax of state transition equations. "
    119119                  (ebnf-var "INITIAL-EXPR") " is an expression that computes the initial value. "
    120120                  (ebnf-var "OPEN-ID") " is the name of the open state. It must be one of the states "
     
    176176               ( (ebnf-form (ebnf-kw "COMPONENT") (ebnf-form (ebnf-kw "TYPE") "gate") "..." )
    177177                 (comment "One or more gate definitions. Each component of type gate "
    178                           "must export the state complexes that characterize the gate dynamics. "))
     178                          "must export the reactions that characterize the gate dynamics. "))
    179179               
    180180               ( (ebnf-form (ebnf-kw "COMPONENT")
     
    194194        (subsubsection "Hodgkin-Huxley ionic conductance extension"
    195195          (p "The Hodgkin-Huxley ionic conductance extension is a shortcut that declares "
    196              "a state transition complex corresponding to the Hodgkin-Huxley formulation "
     196             "a reaction corresponding to the Hodgkin-Huxley formulation "
    197197             "of ion channel dynamics. ")
    198198
     
    483483                                                exp (neg ((v + cvth2) / ckth2)))))))
    484484                         
    485                          (state-complex
     485                         (reaction
    486486                          (CaBK_z
    487487                           (transitions (<-> C O (CaBK_zinf (cai) / CaBK_ztau)
  • release/3/nemo/trunk/nemo-matlab.scm

    r12784 r12835  
    275275
    276276
    277 (define (stcomp-eq n open transitions)
     277(define (reaction-eq n open transitions)
    278278  (list (matlab-name n) (matlab-name (matlab-state-name n open))))
    279279
     
    312312
    313313
    314 (define (poset->stcomp-eq-defs poset sys)
     314(define (poset->reaction-eq-defs poset sys)
    315315  (fold-right
    316316   (lambda (lst ax)
     
    321321                               (cases nemo:quantity en
    322322                                      (TSCOMP  (name initial open transitions conserve power)
    323                                                (cons (stcomp-eq name open transitions) ax))
     323                                               (cons (reaction-eq name open transitions) ax))
    324324                                      (else  ax))
    325325                               ax))))
     
    416416             (asgns       ((dis 'asgns)   sys))
    417417             (states      ((dis 'states)  sys))
    418              (stcomps     ((dis 'stcomps) sys))
     418             (reactions   ((dis 'reactions) sys))
    419419             (defuns      ((dis 'defuns)  sys))
    420420             (components  ((dis 'components) sys))
     
    431431                                            (list (matlab-name (first nv)) v1))))
    432432                                   consts))
    433                 (globals          (map matlab-name
    434                                        (delete-duplicates (append (map first imports) exports (map first const-defs)))))
    435433                (poset            (vector->list ((dis 'depgraph->bfs-dist-poset) g)))
    436434                (asgn-eq-defs     (poset->asgn-eq-defs poset sys))
     
    464462                                            `(,(matlab-name ion) ,(matlab-name (s+ 'i ion)) ,(matlab-name (s+ ion 'i)))))
    465463                                        epools))
     464
     465               (pool-ion-i        (map (lambda (ep) (let ((ion (car ep))) (matlab-name (s+ 'i ion))))
     466                                       epools))
     467
    466468               
    467469               (i-eqs (filter-map
     
    538540                                (list) i-bkts))
    539541
    540                   (state-eq-defs    (reverse (poset->state-eq-defs poset sys)))
     542                  (state-eq-defs      (reverse (poset->state-eq-defs poset sys)))
    541543                 
    542                   (stcomp-eq-defs   (poset->stcomp-eq-defs poset sys))
    543 
    544                   (conserve-eq-defs  (map (lambda (eq) (list 0 `(- ,(second eq) ,(first eq))))
    545                                           (poset->state-conserve-eq-defs poset sys)))
     544                  (reaction-eq-defs   (poset->reaction-eq-defs poset sys))
     545
     546                  (conserve-eq-defs   (map (lambda (eq) (list 0 `(- ,(second eq) ,(first eq))))
     547                                           (poset->state-conserve-eq-defs poset sys)))
     548
     549                  (pool-consts       (concatenate
     550                                      (map (lambda (ep)
     551                                             (let* ((ep-name     (first ep))
     552                                                    (pool-ion    (assoc ep-name pool-ions))
     553                                                    (i-name      (second pool-ion))
     554                                                    (init-name   (matlab-name (s+ ep-name '-init)))
     555                                                    (temp-name   (matlab-name (s+ ep-name '-temp-adj)))
     556                                                    (beta-name   (matlab-name (s+ ep-name '-beta)))
     557                                                    (depth-name  (matlab-name (s+ ep-name '-depth))))
     558                                               (list init-name temp-name beta-name depth-name)))
     559                                           epools)))
     560
    546561                  (pool-eq-defs
    547562                   (map (lambda (ep)
     
    563578                 
    564579                  (init-eq-defs     (poset->state-init-defs poset sys))
    565                  
     580
    566581                  (state-index-map  (let ((acc (fold (lambda (def ax)
    567582                                                       (let ((st-name (first def)))
     
    580595                                                                    ax)))
    581596                                                            (list 1 (list))
    582                                                             state-eq-defs)))
    583                                                              
     597                                                            rate-eq-defs)))
    584598                                             (second acc)))
     599
     600                  (globals          (map matlab-name
     601                                       (delete-duplicates (append
     602                                                           exports
     603                                                           pool-consts
     604                                                           (map second  perm-ions)
     605                                                           (map third   perm-ions)
     606                                                           (map second  acc-ions)
     607                                                           (map third   acc-ions)
     608                                                           (map fourth  acc-ions)
     609                                                           (map second  pool-ions)
     610                                                           (map third   pool-ions)
     611                                                           (map first   imports)
     612                                                           (map first   const-defs)))))
     613
    585614               )
    586615
     
    601630            pool-ions)
    602631
    603 
    604            (for-each (lambda (ep)
    605                        (let* ((ep-name     (first ep))
    606                               (ep-props    (second ep))
    607                               (init-expr   (lookup-def 'initial ep-props))
    608                               (temp-expr   (lookup-def 'temp-adj ep-props))
    609                               (beta-expr   (lookup-def 'beta ep-props))
    610                               (depth-expr  (lookup-def 'depth ep-props))
    611                               (init-name   (matlab-name (s+ ep-name '-init)))
    612                               (temp-name   (matlab-name (s+ ep-name '-temp-adj)))
    613                               (beta-name   (matlab-name (s+ ep-name '-beta)))
    614                               (depth-name  (matlab-name (s+ ep-name '-depth))))
    615                          (if (or (not beta-expr) (not depth-expr) (not init-expr))
    616                              (nemo:error 'nemo:matlab-translator
    617                                          ": ion pool " ep-name " requires initial value, depth and beta parameters"))
    618                          (let ((temp-val  (and temp-expr (eval-const sys temp-expr)))
    619                                (init-val  (eval-const sys init-expr))
    620                                (beta-val  (eval-const sys beta-expr))
    621                                (depth-val (eval-const sys depth-expr)))
    622                            (pp indent
    623                                ,(expr->string/MATLAB init-val init-name)
    624                                ,(expr->string/MATLAB temp-val temp-name)
    625                                ,(expr->string/MATLAB beta-val beta-name)
    626                                ,(expr->string/MATLAB depth-val depth-name)))))
    627                      epools)
    628          
    629632           (if (not (null? globals)) (pp indent+ (global ,(sl\ " " globals))))
    630633
     
    639642               (let ((vi (lookup-def 'v state-index-map)))
    640643                 (if vi (pp indent+ ,(expr->string/MATLAB (s+ "y(" vi ")") 'v)))))
     644
    641645           
    642646           (for-each (lambda (def)
     
    645649                                       (s+ "y(" (lookup-def n state-index-map) ")") n))))
    646650                     rate-eq-defs)
     651
     652           (for-each (lambda (pool-ion)
     653                       (pp indent+ ,(expr->string/MATLAB (first pool-ion) (third pool-ion) )))
     654                     pool-ions)
    647655           
    648656           (for-each (lambda (def)
     
    655663                     (let ((n (first def)) (b (second def)))
    656664                       (pp indent+ ,(expr->string/MATLAB b n))))
    657                    stcomp-eq-defs)
    658          
     665                   reaction-eq-defs)
     666
    659667         (pp indent+ ,(expr->string/MATLAB `(zeros (length y) 1) 'dy))
    660668         
     669
    661670         (for-each (lambda (def)
    662                      (let ((n (s+ "dy(" (lookup-def (first def) state-index-map) ")")) (b (second def)))
     671                     (let ((n (s+ "dy(" (lookup-def (first def) state-index-map) ")"))
     672                           (b (second def)))
    663673                       (pp indent+ ,(s+ "# state " (first def))
    664674                           ,(expr->string/MATLAB b n))))
    665675                   rate-eq-defs)
    666          
    667          (for-each (lambda (pool-ion)
    668                      (pp indent+ ,(expr->string/MATLAB (first pool-ion) (third pool-ion) )))
    669                    pool-ions)
    670676         
    671677         (for-each (lambda (def)
     
    690696                  (let* ((n   (first def))
    691697                         (ni  (lookup-def n steady-state-index-map)))
    692                     (pp indent+ ,(expr->string/MATLAB (if ni (s+ "x(" ni ")") n) n))
     698                    (if ni (pp indent+ ,(expr->string/MATLAB (s+ "x(" ni ")") n)))
    693699                    ))
    694                 state-eq-defs)
     700                rate-eq-defs)
    695701               
    696702               (pp indent+ ,(expr->string/MATLAB `(zeros ,(length steady-state-index-map) 1) 'y))
     
    706712                         (ni  (lookup-def n steady-state-index-map))
    707713                         (b   (second def)))
    708                     (pp indent+ ,(s+ "# state " n)
    709                         ,(expr->string/MATLAB b (if ni (s+ "y(" ni ")") n)))
     714                    (if ni (pp indent+ ,(s+ "# state " n)
     715                               ,(expr->string/MATLAB b (s+ "y(" ni ")"))))
    710716                    ))
    711                 state-eq-defs)
     717                rate-eq-defs)
    712718               
    713719               (pp indent ,nl (endfunction))))
     
    720726         (pp indent+ ,(expr->string/MATLAB `(zeros ,(length state-index-map) 1) 'y0))
    721727         
     728         (for-each (lambda (ep)
     729                     (let* ((ep-name     (first ep))
     730                            (ep-props    (second ep))
     731                            (init-expr   (lookup-def 'initial ep-props))
     732                            (temp-expr   (lookup-def 'temp-adj ep-props))
     733                            (beta-expr   (lookup-def 'beta ep-props))
     734                            (depth-expr  (lookup-def 'depth ep-props))
     735                            (init-name   (matlab-name (s+ ep-name '-init)))
     736                            (temp-name   (matlab-name (s+ ep-name '-temp-adj)))
     737                            (beta-name   (matlab-name (s+ ep-name '-beta)))
     738                            (depth-name  (matlab-name (s+ ep-name '-depth))))
     739                       (if (or (not beta-expr) (not depth-expr) (not init-expr))
     740                           (nemo:error 'nemo:matlab-translator
     741                                       ": ion pool " ep-name " requires initial value, depth and beta parameters"))
     742                       (let ((temp-val  (and temp-expr (eval-const sys temp-expr)))
     743                             (init-val  (eval-const sys init-expr))
     744                             (beta-val  (eval-const sys beta-expr))
     745                             (depth-val (eval-const sys depth-expr)))
     746                         (pp indent+
     747                             ,(expr->string/MATLAB init-val init-name)
     748                             ,(expr->string/MATLAB temp-val temp-name)
     749                             ,(expr->string/MATLAB beta-val beta-name)
     750                             ,(expr->string/MATLAB depth-val depth-name)))))
     751                   epools)
     752         
     753
    722754         (if (member 'v globals)
    723755             (let ((vi (lookup-def 'v state-index-map)))
     
    746778         (if (not (null? steady-state-index-map))
    747779             (begin
     780               (for-each (lambda (def)
     781                                 (if (member (first def) pool-ion-i)
     782                                     (pp indent+ ,(expr->string/MATLAB (second def) (first def)))))
     783                         i-eqs)
     784
    748785               (pp indent+ ,(expr->string/MATLAB `(zeros ,(length steady-state-index-map) 1) 'xs)
    749786                   ,(expr->string/MATLAB
     
    751788                     "[ys,fval,info]"))
    752789               
     790
    753791               (for-each
    754792                (lambda (def)
     
    757795                         (ni (lookup-def n state-index-map)))
    758796                    (if si (pp indent+ ,(expr->string/MATLAB (s+ "ys(" si ")") (s+ "y0(" ni ")"))))))
    759                 state-eq-defs)
     797                rate-eq-defs)
    760798               ))
    761          
     799
     800
     801         (for-each (lambda (def)
     802                     (if (not (member (first def) pool-ion-i))
     803                         (pp indent+ ,(expr->string/MATLAB (second def) (first def)))))
     804                   i-eqs)
     805
    762806         (pp indent ,nl (endfunction))
    763807         
    764808         (pp indent ,nl)
    765809         
    766          (let* ((with      (inexact->exact (round (/ (abs (- max-v min-v)) step))))
    767                 (define-fn (make-define-fn table? min-v max-v with)))
     810         (let* ((with       (inexact->exact (round (/ (abs (- max-v min-v)) step))))
     811                (define-fn  (make-define-fn table? min-v max-v with)))
    768812           (for-each (lambda (fndef)
    769813                       (if (not (member (car fndef) builtin-fns))
  • release/3/nemo/trunk/nemo-nmodl.scm

    r12784 r12835  
    465465
    466466
    467 (define (stcomp-eq n open transitions)
     467(define (reaction-eq n open transitions)
    468468  (list (nmodl-name n) (nmodl-name (nmodl-state-name n open))))
    469469
     
    516516
    517517
    518 (define (poset->stcomp-eq-defs poset sys)
     518(define (poset->reaction-eq-defs poset sys)
    519519  (fold-right
    520520   (lambda (lst ax)
     
    525525                               (cases nemo:quantity en
    526526                                      (TSCOMP  (name initial open transitions conserve power)
    527                                                (cons (stcomp-eq name open transitions) ax))
     527                                               (cons (reaction-eq name open transitions) ax))
    528528                                      (else  ax))
    529529                               ax))))
     
    625625             (states      ((dis 'states)  sys))
    626626             (kinetic     (if (eq? kinetic 'all) (delete-duplicates (map first states)) kinetic))
    627              (stcomps     ((dis 'stcomps) sys))
     627             (reactions   ((dis 'reactions) sys))
    628628             (defuns      ((dis 'defuns)  sys))
    629629             (components  ((dis 'components) sys))
     
    792792                     states)
    793793           (for-each (lambda (st) (apply define-state (list indent+ st)))
    794                      stcomps)
     794                     reactions)
    795795           (for-each (lambda (pool-ion) (apply define-state (list indent+ (first pool-ion))))
    796796                     pool-ions)
     
    827827                 (pp indent "}")))
    828828             
    829            (if (not (null? stcomps))
     829           (if (not (null? reactions))
    830830               (begin
    831                  (pp indent ,nl (PROCEDURE stcomps () "{"))
    832                  (let* ((eq-defs   (poset->stcomp-eq-defs poset sys))
     831                 (pp indent ,nl (PROCEDURE reactions () "{"))
     832                 (let* ((eq-defs   (poset->reactions-eq-defs poset sys))
    833833                        (locals    (find-locals (map second eq-defs))) )
    834834                   (if (not (null? locals)) (pp indent+ (LOCAL ,(sl\ ", " locals))))
     
    941941                   (else           (pp indent+ (SOLVE states METHOD ,method)))))
    942942             (if has-kinetic?   (pp indent+  (SOLVE kstates METHOD sparse)))
    943              (if (not (null? stcomps))   (pp indent+ (stcomps ())))
     943             (if (not (null? reactions))   (pp indent+ (reactions ())))
    944944             (if (not (null? pool-ions)) (pp indent+ (pools ())))
    945945             (for-each (lambda (p) (pp indent+ ,(expr->string/NMODL (second p) (first p)))) i-eqs)
Note: See TracChangeset for help on using the changeset viewer.