Changeset 31426 in project


Ignore:
Timestamp:
09/15/14 08:52:13 (5 years ago)
Author:
Ivan Raikov
Message:

nemo: refactoring dynamics and residual functions in nest backend to use templates

Location:
release/4/nemo/trunk
Files:
2 edited

Legend:

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

    r31417 r31426  
    278278{% endif %}
    279279
    280 {{ pad(indent,exprString) }}
     280  {{exprString}}
    281281
    282282  return {{returnVar}};
     
    286286))
    287287
    288 
    289 
    290 (define fn-header
    291   (ersatz:statements-from-string
    292    (ersatz:template-std-env autoescape: #f)
    293 #<<EOF
    294 
    295 {{returnType}} {{functionName}} {{ join (", ", functionVars) }} {
    296 
    297   double {{returnVar}};
    298 
    299 {% if (!(localVars == [])) %}
    300   double {{join(", ", localVars)}};
    301 {% endif %}
    302 
    303 {% if (!(consts == [])) %}
    304   double {{join(", ", consts)}};
    305   const ~A::Parameters_{{sysname}} & p = *(reinterpret_cast< const ~A::Parameters_ *>(params));
    306 
    307 {% for const in consts %}
    308   {{const}} =  p.{{const}};
    309 {% endfor %}
    310 {% endif %}
    311 
    312 {{ pad(indent,exprString) }}
    313 
    314   return {{returnVar}};
    315 }
    316 
    317 EOF
    318 ))
    319288
    320289
     
    609578))
    610579
    611 (define (fsolve-prelude ss-method)
    612   (case ss-method
    613     ((kinsol)
     580
     581(define fsolve-prelude-template
     582  (ersatz:statements-from-string
     583   (ersatz:template-std-env autoescape: #f)
    614584#<<EOF
     585
     586{% if (SSMethod == "kinsol") %}
    615587
    616588  int fsolve (KINSysFn f, int N, N_Vector fval, void *user_data, std::string name)
     
    649621  }
    650622
    651 EOF
    652   )
    653   (else
    654 #<<EOF
     623{% else %}
    655624
    656625  int fsolve (int (*fss)(const gsl_vector *, void *user_data, gsl_vector *), int N, gsl_vector *fval, void *user_data, std::string name)
     
    698667  }
    699668
    700 EOF
    701    
     669{% endif %}
     670
     671EOF
    702672))
    703 )
     673
     674
     675
     676(define dynamics-template
     677  (ersatz:statements-from-string
     678   (ersatz:template-std-env autoescape: #f)
     679#<<EOF
     680
     681{% if ((ODEmethod == "cvode") || (ODEmethod == "ida") ) %}
     682extern "C" int {{sysname}}_dynamics (double t, N_Vector y, N_Vector f, void* pnode)
     683{% else %}
     684extern "C" int {{sysname}}_dynamics (double t, const double y[], double f[], void* pnode)
     685{% endif %}
     686{
     687   double {{join(", ", vars)}};
     688
     689   // S is shorthand for the type that describes the model state
     690   typedef {{sysname}}::State_ S;
     691       
     692   // cast the node ptr to an object of the proper type
     693   assert(pnode);
     694   const {{sysname}} & node =  *(reinterpret_cast<{{sysname}}*>(pnode));
     695   {{sysname}} & vnode =  *(reinterpret_cast<{{sysname}}*>(pnode));
     696
     697   // params is a reference to the model parameters
     698   const struct {{sysname}}::Parameters_ *params;
     699   params = &(node.P_);
     700
     701   // state is a reference to the model state
     702   struct {{sysname}}::State_ *state;
     703   state = &(vnode.S_);
     704       
     705   // y[] must be the state vector supplied by the integrator,
     706   // not the state vector in the node, node.S_.y[].
     707
     708   {% for parameterDef in parameterDefs %}
     709   {{parameterDef}}
     710
     711   {% endfor %}
     712
     713   {% for eq in ratePrevEqDefs %}
     714   {{eq}}
     715
     716   {% endfor %}
     717
     718   {% for eq in eqOrderDefs %}
     719   {{eq}}
     720
     721   {% endfor %}
     722
     723   {% for eq in rateEqDefs %}
     724   {{eq}}
     725
     726   {% endfor %}
     727
     728{% if ((ODEmethod == "cvode") || (ODEmethod == "ida") ) %}
     729   return 0;
     730{% else %}
     731   return GSL_SUCCESS;
     732{% endif %}
     733
     734}
     735
     736EOF
     737))
     738
     739
     740
     741(define residual-template
     742  (ersatz:statements-from-string
     743   (ersatz:template-std-env autoescape: #f)
     744#<<EOF
     745
     746{% if (ODEmethod == "ida") %}
     747
     748extern "C" int {{sysname}}_residual (double t, N_Vector y, N_Vector yp, N_Vector f, void* pnode)
     749{
     750   int status;
     751
     752   // cast the node ptr to an object of the proper type
     753   assert(pnode);
     754   const {{sysname}} & node =  *(reinterpret_cast<{{sysname}}*>(pnode));
     755   {{sysname}} & vnode =  *(reinterpret_cast<{{sysname}}*>(pnode));
     756
     757   N_Vector y1 = vnode.B_.y1;
     758             
     759   status = {{sysname}}_dynamics (t, y, y1, pnode);
     760
     761   {% for eq in residualRateEqDefs %}
     762   {{eq}}
     763
     764   {% endfor %}
     765
     766   return status;
     767}
     768
     769{% endif %}
     770
     771EOF
     772
     773))
    704774
    705775
    706776(define (output-event-handle
    707777         sysname state-index-map
    708          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     778         const-defs asgn-eq-defs init-eq-defs
    709779         reaction-eq-defs i-eqs pool-ions perm-ions
    710780         synapse-info
     
    765835(define (output-header
    766836         sysname method ss-method state-index-map steady-state-index-map
    767          defaults external-eq-defs const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     837         defaults external-eq-defs const-defs asgn-eq-defs init-eq-defs
    768838         reaction-eq-defs i-eqs pool-ions perm-ions
    769839         synapse-info
     
    12151285
    12161286
    1217 (define (output-jac sysname method state-index-map pool-ions i-eqs v-eq indent indent+)
     1287(define (output-jac sysname method state-index-map pool-ions i-eqs indent indent+)
    12181288
    12191289;; Diagonal Jacobian approximation: (f(s+.01) - f(s))/.001
     
    12701340
    12711341(define (output-cvode-event sysname method imports const-defs state-index-map
    1272            external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    1273            defaults i-eqs v-eq indent indent+)
     1342           external-eq-defs reaction-eq-defs asgn-eq-defs
     1343           defaults i-eqs indent indent+)
    12741344
    12751345  (let ((vi (lookup-def 'v state-index-map)))
     
    13311401
    13321402(define (output-ida-event sysname method imports const-defs state-index-map
    1333            external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    1334            defaults i-eqs v-eq indent indent+)
     1403           external-eq-defs reaction-eq-defs asgn-eq-defs
     1404           defaults i-eqs indent indent+)
    13351405
    13361406  (let ((vi (lookup-def 'v state-index-map)))
     
    17211791(define (output-update
    17221792         sysname method state-index-map
    1723          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     1793         const-defs asgn-eq-defs init-eq-defs
    17241794         reaction-eq-defs transient-event-defs
    17251795         i-eqs pool-ions perm-ions synapse-info
     
    17861856(define (output-nodes-leapfrog
    17871857         sysname method state-index-map
    1788          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     1858         const-defs asgn-eq-defs init-eq-defs
    17891859         reaction-eq-defs i-eqs pool-ions perm-ions
    17901860         synapse-info defaults abstol reltol maxstep
     
    18521922(define (output-nodes-cvode
    18531923         sysname method state-index-map
    1854          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     1924         const-defs asgn-eq-defs init-eq-defs
    18551925         reaction-eq-defs i-eqs pool-ions perm-ions
    18561926         synapse-info defaults abstol reltol maxstep
     
    20522122(define (output-nodes-ida
    20532123         sysname method state-index-map
    2054          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     2124         const-defs asgn-eq-defs init-eq-defs
    20552125         reaction-eq-defs i-eqs pool-ions perm-ions
    20562126         synapse-info defaults abstol reltol maxstep
     
    22402310(define (output-nodes-gsl
    22412311         sysname method state-index-map
    2242          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     2312         const-defs asgn-eq-defs init-eq-defs
    22432313         reaction-eq-defs i-eqs pool-ions perm-ions
    22442314         synapse-info defaults abstol reltol maxstep
     
    23802450(define (output-buffers
    23812451         sysname method state-index-map
    2382          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     2452         const-defs asgn-eq-defs init-eq-defs
    23832453         reaction-eq-defs i-eqs pool-ions perm-ions
    23842454         synapse-info defaults
     
    24702540
    24712541(define (output-accessors+modifiers
    2472          sysname imports defaults state-index-map const-defs asgn-eq-defs rate-eq-defs
     2542         sysname imports defaults state-index-map const-defs asgn-eq-defs
    24732543         reaction-eq-defs i-eqs pool-ions perm-ions constraints
    24742544         indent indent+)
     
    26582728     const-defs)
    26592729
    2660     (let ((vi (lookup-def 'v state-index-map))
    2661           (vrest (or (and (lookup-def 'Vrest const-defs) 'Vrest) -65.0)))
    2662       (if (and vi vrest)
    2663           (pp indent+ ,(expr->string/C++  vrest 'v ))))
    26642730
    26652731    (for-each (lambda (n)
     
    28422908(define (output-recordables
    28432909         sysname state-index-map
    2844          const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     2910         const-defs asgn-eq-defs init-eq-defs
    28452911         reaction-eq-defs i-eqs pool-ions perm-ions indent indent+)
    28462912 
     
    28682934(define (output-dy sysname method imports const-defs state-index-map
    28692935                   external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    2870                    pool-ions i-eqs v-eq constraints indent indent+)
     2936                   pool-ions i-eqs constraints indent indent+)
    28712937
    28722938  (let* (
     
    28822948           i-eqs))
    28832949
    2884          (v-eq
    2885           (and v-eq
    2886                (list (first v-eq)
    2887                      (add-params-to-fncall (canonicalize-expr/C++ (second v-eq)) builtin-fns))))
    28882950
    28892951         (eqs
     
    29212983         (eq-locals  (find-locals
    29222984                      (map second
    2923                            (if v-eq (cons v-eq (append i-eqs rate-eq-defs eqs))
    2924                                (append i-eqs rate-eq-defs eqs)))))
     2985                           (append i-eqs rate-eq-defs eqs))))
     2986
     2987         (vars       (delete-duplicates
     2988                      (map (compose ->string nest-name)
     2989                           (filter (lambda (x)
     2990                                     (not (member x builtin-consts)))
     2991                                   (append
     2992                                    eq-locals
     2993                                    eq-order
     2994                                    (map first i-eqs)
     2995                                    (map first external-eq-defs)
     2996                                    (map first state-index-map)
     2997                                    (map first const-defs)
     2998                                    )))
     2999                      string=?))
    29253000         )
    29263001
    2927 
    2928     (case method
    2929       ((leapfrog)
    2930        (pp indent ,nl (
    2931                        ,(sprintf "extern \"C\" int ~A_dynamics" sysname)
    2932                        (,(slp ", " `("double t"
    2933                                      "const double y[]"
    2934                                      "double f[]"
    2935                                      "void* pnode"
    2936                                      )))
    2937                        #\{
    2938                        )))
    2939       ((cvode ida)
    2940        (pp indent ,nl (,(sprintf "extern \"C\" int ~A_dynamics" sysname)
    2941                        (,(slp ", " `("double t"
    2942                                      "N_Vector y"
    2943                                      "N_Vector f"
    2944                                      "void* pnode"
    2945                                      )))
    2946                        #\{
    2947                        )))
    2948       ((gsl)
    2949        (pp indent ,nl (,(sprintf "extern \"C\" int ~A_dynamics" sysname)
    2950                        (,(slp ", " `("double t"
    2951                                      "const double y[]"
    2952                                      "double f[]"
    2953                                      "void* pnode"
    2954                                      )))
    2955                        #\{
    2956                        )))
    2957       )
    2958 
    2959 
    2960 
    2961     (pp indent+ (double ,(slp ", " (delete-duplicates
    2962                                     (map (compose ->string nest-name)
    2963                                          (filter (lambda (x)
    2964                                                    (not (member x builtin-consts)))
    2965                                                  (append
    2966                                                   eq-locals
    2967                                                   eq-order
    2968                                                   (map first i-eqs)
    2969                                                   (map first external-eq-defs)
    2970                                                   (map first state-index-map)
    2971                                                   (map first const-defs)
    2972                                                   )))
    2973                                     string=?))
    2974                         ";"))
    2975 
    2976     (pp indent+ ,nl
    2977 
    2978         ("// S is shorthand for the type that describes the model state ")
    2979         (typedef ,(sprintf "~A::State_" sysname) "S;")
    2980        
    2981         ,nl
    2982        
    2983         ("// cast the node ptr to an object of the proper type")
    2984         ("assert(pnode);")
    2985         ("const " ,sysname "& node =  *(reinterpret_cast<" ,sysname "*>(pnode));")
    2986         (,sysname "& vnode =  *(reinterpret_cast<" ,sysname "*>(pnode));")
    2987        
    2988         ,nl
    2989 
    2990         ("// params is a reference to the model parameters ")
    2991         (const struct ,(sprintf "~A::Parameters_" sysname) "*params;")
    2992         ("params = &(node.P_);")
    2993        
    2994         ,nl
    2995 
    2996         ("// state is a reference to the model state ")
    2997         (struct ,(sprintf  "~A::State_" sysname) "*state;")
    2998         ("state = &(vnode.S_);")
    2999        
    3000         ,nl
    3001 
    3002         ("// y[] must be the state vector supplied by the integrator, ")
    3003         ("// not the state vector in the node, node.S_.y[]. ")
    3004 
    3005         ,nl
    3006 
    3007         )
    3008 
    3009     (for-each (lambda (def)
    3010                 (let ((n (first def)) )
    3011                   (pp indent+
    3012                       ,(expr->string/C++ (sprintf "params->~A" n) n))))
    3013               const-defs)
    3014 
    3015     (let ((vi (lookup-def 'v state-index-map)))
    3016       (if vi (pp indent+ ,(expr->string/C++ (ith 'y vi) 'v))))
    3017 
    3018     (for-each (lambda (def)
    3019                 (let* ((n (first def))
    3020                        (ni (lookup-def n state-index-map)))
    3021                   (pp indent+ ,(expr->string/C++ (ith 'y ni) (nest-name n)))))
    3022               rate-eq-defs)
    3023 
    3024     (for-each (lambda (n)
    3025                 (let ((b  (lookup-def n eqs)))
    3026                   (if b (pp indent+ ,(expr->string/C++ b (nest-name n))))))
    3027               eq-order)
    3028 
    3029     (for-each (lambda (def)
    3030                 (let* ((n (first def))
    3031                        (b (second def))
    3032                        (fv (ith 'f (lookup-def n state-index-map)))
    3033                        )
    3034                   (pp indent+ ,(s+ "// rate equation " n)
    3035                       ,(expr->string/C++ b fv))))
    3036               rate-eq-defs)
    3037    
    3038     (if v-eq
    3039         (let ((vi (lookup-def 'v state-index-map)))
    3040           (if vi
    3041               (pp indent+ ,(expr->string/C++ (second v-eq) (ith 'f vi)))
    3042               )))
    3043 
    3044     (case method
    3045       ((leapfrog)
    3046         (pp indent+ ,nl ("return 0;")))
    3047       ((cvode ida)
    3048         (pp indent+ ,nl ("return 0;")))
    3049       ((gsl)
    3050         (pp indent+ ,nl ("return GSL_SUCCESS;")))
    3051       )
    3052 
    3053     (pp indent  #\})
    3054 
    3055     ))
     3002    (let (
     3003          (tmpl-env
     3004           (fold tenv-enter '()
     3005                 `(
     3006                   (sysname       . ,sysname)
     3007                   (ODEmethod     . ,method)
     3008                   (vars          . ,vars)
     3009
     3010                   (parameterDefs .
     3011                                  ,(map (lambda (def)
     3012                                          (let ((n (first def)) )
     3013                                            (expr->string/C++ (sprintf "params->~A" n) n)))
     3014                                        const-defs))
     3015                   (ratePrevEqDefs .
     3016                                   ,(map (lambda (def)
     3017                                           (let* ((n (first def))
     3018                                                  (ni (lookup-def n state-index-map)))
     3019                                             (expr->string/C++ (ith 'y ni) (nest-name n))))
     3020                                         rate-eq-defs))
     3021
     3022                   (eqOrderDefs .
     3023                                ,(filter-map (lambda (n)
     3024                                               (let ((b (lookup-def n eqs)))
     3025                                                 (and b (expr->string/C++ b (nest-name n)))))
     3026                                             eq-order))
     3027                   
     3028                   (rateEqDefs .
     3029                               ,(map (lambda (def)
     3030                                       (let* ((n (first def))
     3031                                              (b (second def))
     3032                                              (fv (ith 'f (lookup-def n state-index-map)))
     3033                                              )
     3034                                         (expr->string/C++ b fv)))
     3035                                     rate-eq-defs))
     3036                   ))
     3037           ))
     3038
     3039      (instantiate-template dynamics-template tmpl-env)
     3040      ))
     3041  )
    30563042
    30573043
    30583044(define (output-residual sysname method imports const-defs state-index-map
    30593045                         external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    3060                          pool-ions i-eqs v-eq constraints indent indent+)
    3061   (case method
    3062       ((ida)
    3063        (begin
    3064          (pp indent ,nl (,(sprintf "extern \"C\" int ~A_residual" sysname)
    3065                          (,(slp ", " `("double t"
    3066                                        "N_Vector y"
    3067                                        "N_Vector yp"
    3068                                        "N_Vector f"
    3069                                        "void* pnode"
    3070                                        )))
    3071                          #\{
    3072                          ))
    3073 
    3074          (pp indent+ ,nl
    3075              (int status #\; )
    3076 
    3077              ,nl
    3078 
    3079              ("// cast the node ptr to an object of the proper type")
    3080              ("assert(pnode);")
    3081              ("const " ,sysname "& node =  *(reinterpret_cast<" ,sysname "*>(pnode));")
    3082              (,sysname "& vnode =  *(reinterpret_cast<" ,sysname "*>(pnode));")
    3083              ("N_Vector y1 = vnode.B_.y1;")
    3084              
    3085              ,nl
    3086 
    3087              (,(sprintf "status = ~A_dynamics (t, y, y1, pnode);" sysname))
    3088 
    3089              ,nl)
    3090              
    3091          (for-each (lambda (def)
    3092                      (let* ((n (first def))
    3093                             (i (lookup-def n state-index-map))
    3094                             (fv (ith 'f i))
    3095                             (y1v (ith 'y1 i))
    3096                             (ypv (ith 'yp i))
    3097                             )
    3098                        (pp indent+
    3099                            ,(expr->string/C++ `(- ,y1v ,ypv) fv))))
    3100                    rate-eq-defs)
    3101 
    3102          (if v-eq
    3103              (let ((vi (lookup-def 'v state-index-map)))
    3104                (if vi
    3105                    (let ((v1 (ith 'y1 vi))
    3106                          (vp (ith 'yp vi)))
    3107                      (pp indent+ ,(expr->string/C++ `(- ,v1 ,vp) (ith 'f vi))))
     3046                         pool-ions i-eqs constraints indent indent+)
     3047
     3048  (let (
     3049        (residual-rate-eq-defs
     3050         (map (lambda (def)
     3051                (let* ((n (first def))
     3052                       (i (lookup-def n state-index-map))
     3053                       (fv (ith 'f i))
     3054                       (y1v (ith 'y1 i))
     3055                       (ypv (ith 'yp i))
     3056                       )
     3057                  (expr->string/C++ `(- ,y1v ,ypv) fv)))
     3058              rate-eq-defs))
     3059        )
     3060
     3061    (let (
     3062          (tmpl-env
     3063           (fold tenv-enter '()
     3064                 `(
     3065                   (sysname       . ,sysname)
     3066                   (ODEmethod     . ,method)
     3067                   (residualRateEqDefs . ,residual-rate-eq-defs)
    31083068                   )))
    3109 
    3110 
    3111          (pp indent
    3112              ("return status; ")
    3113              #\})
    3114          ))
     3069          )
     3070
     3071      (instantiate-template residual-template tmpl-env)
    31153072      ))
     3073  )
    31163074
    31173075
     
    33903348                              nest-name))
    33913349
    3392              (external-eq-defs   (sys->external-eq-defs sys nest-name rhsexpr/C++ canonicalize-expr/C++
    3393                                                         namespace-filter: (lambda (x) (not (equal? x 'event)))))
    3394 
    3395              (event-external-eq-defs   (sys->external-eq-defs sys nest-name rhsexpr/C++ canonicalize-expr/C++
    3396                                                               namespace-filter: (lambda (x) (equal? x 'event))))
    3397 
    3398              (asgn-eq-defs       (poset->asgn-eq-defs* poset sys nest-name rhsexpr/C++ canonicalize-expr/C++ builtin-fns))
    3399              
    3400              (rate-eq-defs       (reverse (poset->rate-eq-defs* poset sys method nest-name nest-state-name rhsexpr/C++ canonicalize-expr/C++ builtin-fns)))
    3401              
    3402              (reaction-eq-defs   (poset->reaction-eq-defs* poset sys nest-name nest-state-name rhsexpr/C++ canonicalize-expr/C++))
    3403 
    3404              (transient-event-defs  (poset->transient-event-defs poset sys method nest-name nest-state-name rhsexpr/C++ canonicalize-expr/C++ builtin-fns))
    3405              
    3406              (init-eq-defs       (poset->init-defs* poset sys nest-name nest-state-name rhsexpr/C++ canonicalize-expr/C++ builtin-fns))
    3407              
    3408              (conserve-eq-defs   (map (lambda (eq) (list 0 `(- ,(second eq) ,(first eq))))
    3409                                       (poset->state-conserve-eq-defs poset sys nest-name nest-state-name)))
    3410              
    3411              (imports-sans-v (filter (lambda (x) (not (equal? 'v (first x)))) imports))
    3412 
    34133350             (v-eq    (and (not (null? i-names))
    34143351                           (let ((istim "(node.B_.I_stim_)" ))
     
    34313368                           ))
    34323369
     3370             (v-eq
     3371              (and v-eq
     3372                   (list (first v-eq)
     3373                         (add-params-to-fncall (canonicalize-expr/C++ (second v-eq)) builtin-fns))))
     3374
     3375             (external-eq-defs   (sys->external-eq-defs sys nest-name rhsexpr/C++ canonicalize-expr/C++
     3376                                                        namespace-filter: (lambda (x) (not (equal? x 'event)))))
     3377
     3378             (event-external-eq-defs   (sys->external-eq-defs sys nest-name rhsexpr/C++ canonicalize-expr/C++
     3379                                                              namespace-filter: (lambda (x) (equal? x 'event))))
     3380
     3381             (asgn-eq-defs       (poset->asgn-eq-defs* poset sys nest-name rhsexpr/C++ canonicalize-expr/C++ builtin-fns))
    34333382             
     3383             (rate-eq-defs       (let ((eqs0 (poset->rate-eq-defs* poset sys method nest-name nest-state-name
     3384                                                                   rhsexpr/C++ canonicalize-expr/C++ builtin-fns)))
     3385                                   (if v-eq
     3386                                       (cons v-eq (reverse eqs0))
     3387                                       (reverse eqs0))))
     3388
    34343389             (state-index-map  (let ((acc (fold (lambda (def ax)
    34353390                                                  (let ((st-name (first def)))
     
    34373392                                                          (cons `(,st-name ,(first ax)) (second ax)))))
    34383393                                                (list 0 (list))
    3439                                                 (if (lookup-def 'v imports)
    3440                                                     (cons (list 'v) rate-eq-defs)
    3441                                                     rate-eq-defs)
     3394                                                rate-eq-defs
    34423395                                                )))
    34433396                                 (second acc)))
    34443397             
     3398             
     3399             (reaction-eq-defs   (poset->reaction-eq-defs* poset sys nest-name nest-state-name rhsexpr/C++ canonicalize-expr/C++))
     3400
     3401             (transient-event-defs  (poset->transient-event-defs poset sys method nest-name nest-state-name rhsexpr/C++ canonicalize-expr/C++ builtin-fns))
     3402             
     3403             (init-eq-defs       (let ((eqs0 (poset->init-defs* poset sys nest-name nest-state-name
     3404                                                                rhsexpr/C++ canonicalize-expr/C++ builtin-fns))
     3405                                       (vi (lookup-def 'v state-index-map))
     3406                                       (vrest (or (and (lookup-def 'Vrest const-defs) 'Vrest) -65.0)))
     3407                                     (if (and vi vrest)
     3408                                         (cons (list 'v vrest) eqs0)
     3409                                         eqs0)))
     3410
    34453411             (steady-state-index-map  (let ((acc (fold (lambda (def ax)
    34463412                                                         (let ((st-name (first def)))
     
    34533419                                        (second acc)))
    34543420             
     3421             (conserve-eq-defs   (map (lambda (eq) (list 0 `(- ,(second eq) ,(first eq))))
     3422                                      (poset->state-conserve-eq-defs poset sys nest-name nest-state-name)))
     3423             
     3424             (imports-sans-v (filter (lambda (x) (not (equal? 'v (first x)))) imports))
     3425
     3426             
     3427             
    34553428             (dfenv
    34563429              (map (lambda (x) (let ((n (first x))) (list n (nest-name (sprintf "d_~A" n )))))
    34573430                   defuns))
    34583431
    3459              )
     3432             (tmpl-env
     3433              (fold tenv-enter '()
     3434                    `(
     3435                      (indent            . ,indent+)
     3436                      (modelName         . ,sysname)
     3437                      (ODEmethod         . ,method)
     3438                      (SSmethod          . ,ss-method)
     3439                      (currentTimestamp  . ,(seconds->string (current-seconds)))
     3440                      (nemoVersionString . ,(nemo:version-string))
     3441                      (hasEvents         . ,(not (null? transient-event-defs)))
     3442                      (exports           . ,(map nest-name exports))
    34603443       
     3444                      )
     3445                    ))
     3446             )
     3447
    34613448        (for-each
    34623449         (lambda (a)
     
    34823469                 ))
    34833470
    3484               ))
    3485 
    3486           (if (not (null? steady-state-index-map))
    3487               (with-output-to-port cpp-output
    3488                 (lambda ()
    3489                   (pp indent ,(fsolve-prelude ss-method)))
    3490                 ))
    3491 
    3492           ;; user-defined functions
    3493           (let ((define-fn  (make-fn-translator sysname))
    3494                 (define-fn-header (make-define-fn-header sysname)))
    3495            
    3496             (for-each (lambda (fndef)
    3497                         (if (not (member (car fndef) builtin-fns))
    3498                             (with-output-to-port cpp-output
    3499                               (lambda ()
    3500                                 (apply define-fn-header (cons indent fndef))
    3501                                 (pp indent ,nl)))
    3502                             ))
    3503                       defuns)
    3504 
    3505             (for-each (lambda (fndef)
    3506                         (if (not (member (car fndef) builtin-fns))
    3507                             (with-output-to-port cpp-output
    3508                               (lambda ()
    3509                                 (apply define-fn (cons indent fndef))
    3510                                 (pp indent ,nl)))
    3511                             ))
    3512                       defuns)
    3513             )
    3514          
    3515          
    3516           ;; derivative function
    3517           (with-output-to-port cpp-output
    3518             (lambda ()
     3471              (instantiate-template fsolve-prelude-template tmpl-env)
     3472
     3473              ;; user-defined functions
     3474              (let ((define-fn  (make-fn-translator sysname))
     3475                    (define-fn-header (make-define-fn-header sysname)))
     3476               
     3477                (for-each (lambda (fndef)
     3478                            (if (not (member (car fndef) builtin-fns))
     3479                                (begin
     3480                                  (apply define-fn-header (cons indent fndef))
     3481                                  (pp indent ,nl))
     3482                                ))
     3483                          defuns)
     3484
     3485                (for-each (lambda (fndef)
     3486                            (if (not (member (car fndef) builtin-fns))
     3487                                (begin
     3488                                  (apply define-fn (cons indent fndef))
     3489                                  (pp indent ,nl))
     3490                                ))
     3491                          defuns)
     3492                )
     3493
     3494              ;; derivative function
    35193495              (output-dy sysname method imports-sans-v const-defs state-index-map
    35203496                         external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    3521                          pool-ions i-eqs v-eq constraints
     3497                         pool-ions i-eqs constraints
    35223498                         indent indent+)
    3523               ))
    3524 
    3525           ;; residual function (used by IDA only)
    3526           (with-output-to-port cpp-output
    3527             (lambda ()
     3499             
     3500              ;; residual function (used by IDA only)
    35283501              (output-residual sysname method imports-sans-v const-defs state-index-map
    35293502                               external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    3530                                pool-ions i-eqs v-eq constraints
     3503                               pool-ions i-eqs constraints
    35313504                               indent indent+)
    3532               ))
     3505
     3506              ))
    35333507
    35343508          ;; steady state function
     
    35453519          (with-output-to-port cpp-output
    35463520            (lambda ()
    3547               (output-jac  sysname method state-index-map pool-ions i-eqs v-eq indent indent+)
     3521              (output-jac  sysname method state-index-map pool-ions i-eqs indent indent+)
    35483522              ))
    35493523
     
    35533527              (output-recordables
    35543528               sysname state-index-map
    3555                const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     3529               const-defs asgn-eq-defs init-eq-defs
    35563530               reaction-eq-defs i-eqs pool-ions perm-ions indent indent+)
    35573531              (pp indent ,nl)
     
    35803554              (output-accessors+modifiers
    35813555               sysname imports-sans-v defaults state-index-map
    3582                const-defs asgn-eq-defs rate-eq-defs
     3556               const-defs asgn-eq-defs
    35833557               reaction-eq-defs i-eqs pool-ions perm-ions
    35843558               constraints
     
    35933567              (output-buffers
    35943568               sysname method state-index-map
    3595                const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     3569               const-defs asgn-eq-defs init-eq-defs
    35963570               reaction-eq-defs i-eqs pool-ions perm-ions
    35973571               synapse-info defaults
     
    36143588                 )
    36153589               sysname method state-index-map
    3616                const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     3590               const-defs asgn-eq-defs init-eq-defs
    36173591               reaction-eq-defs i-eqs pool-ions perm-ions
    36183592               synapse-info defaults abstol reltol maxstep
     
    36283602                  (output-cvode-event
    36293603                   sysname method imports const-defs state-index-map
    3630                    external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    3631                    defaults i-eqs v-eq indent indent+)
     3604                   external-eq-defs reaction-eq-defs asgn-eq-defs
     3605                   defaults i-eqs indent indent+)
    36323606                  (pp indent ,nl)
    36333607                  )))
     
    36373611                  (output-ida-event
    36383612                   sysname method imports const-defs state-index-map
    3639                    external-eq-defs rate-eq-defs reaction-eq-defs asgn-eq-defs
    3640                    defaults i-eqs v-eq indent indent+)
     3613                   external-eq-defs reaction-eq-defs asgn-eq-defs
     3614                   defaults i-eqs indent indent+)
    36413615                  (pp indent ,nl)
    36423616                  )))
     
    36603634              (output-update
    36613635               sysname method state-index-map
    3662                const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     3636               const-defs asgn-eq-defs init-eq-defs
    36633637               reaction-eq-defs transient-event-defs i-eqs
    36643638               pool-ions perm-ions synapse-info
     
    36743648              (output-event-handle
    36753649               sysname state-index-map
    3676                const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     3650               const-defs asgn-eq-defs init-eq-defs
    36773651               reaction-eq-defs i-eqs pool-ions perm-ions
    36783652               synapse-info
     
    36893663                 (output-header
    36903664                  sysname method ss-method state-index-map steady-state-index-map defaults
    3691                   external-eq-defs const-defs asgn-eq-defs init-eq-defs rate-eq-defs
     3665                  external-eq-defs const-defs asgn-eq-defs init-eq-defs
    36923666                  reaction-eq-defs i-eqs pool-ions perm-ions
    36933667                  synapse-info
  • release/4/nemo/trunk/nemo-nmodl.scm

    r31400 r31426  
    790790
    791791
     792(define breakpoint-template
     793  (ersatz:statements-from-string
     794   (ersatz:template-std-env autoescape: #f)
     795#<<EOF
     796
     797BREAKPOINT {
     798{% if (!(currentEqLocals == [])) %}
     799  LOCAL {{join(", ", currentEqLocals)}}
     800{% endif %}
     801
     802{% if (!(rateEqDefs == [])) %}
     803  SOLVE states METHOD {{ODEmethod}}
     804{% endif %}
     805
     806{% if (!(kineticEqDefs == [])) %}
     807  SOLVE kstates METHOD sparse
     808{% endif %}
     809
     810{% if (!(poolIons == [])) %}
     811   pools()
     812{% endif %}
     813
     814{% if (!(reactionEqDefs == [])) %}
     815   reactions()
     816{% endif %}
     817
     818{% for eq in currentEqDefs %}
     819{{pad(indent,eq)}}
     820
     821{% endfor %}
     822
     823}
     824
     825
     826EOF
     827))
     828
     829
    792830(define initial-template
    793831  (ersatz:statements-from-string
     
    816854{% endfor %}
    817855
    818 {% if (hasKinetic) %}
     856{% if (!(kineticEqDefs == [])) %}
    819857  SOLVE kstates STEADYSTATE sparse
    820858  reactions()
     
    934972
    935973
    936              (has-kinetic?  (or (not (null? (filter (lambda (x) (member (car x) kinetic)) states)))))
    937              (has-ode?      (or (not (null? (filter (lambda (x) (not (member (car x) kinetic))) states)))
    938                                 (not (null? pool-ions))))
    939 
    940974             (parameter-defs (filter-map
    941975                              (lambda (nv)
     
    9941028
    9951029             (transient-event-defs  (poset->transient-event-defs poset sys method nmodl-name nmodl-state-name rhsexpr/NMODL canonicalize-expr/NMODL builtin-fns))
    996              (has-events?           (not (null? transient-event-defs)))
    9971030
    9981031             (useions   (append
     
    13131346                `(
    13141347                  (indent            . ,indent+)
     1348                  (ODEmethod         . ,method)
    13151349                  (modelName         . ,sysname)
    13161350                  (currentTimestamp  . ,(seconds->string (current-seconds)))
    13171351                  (nemoVersionString . ,(nemo:version-string))
    1318                   (hasEvents         . ,has-events?)
    1319                   (hasKinetic        . ,has-kinetic?)
     1352                  (hasEvents         . ,(not (null? transient-event-defs)))
    13201353                  (exports           . ,(map nmodl-name exports))
    13211354                  (currents          . ,(append
    13221355                                         (map (lambda (gate-complex) (nmodl-name (s+ 'i_ (first gate-complex)))) gate-complexes )
    13231356                                         (map (lambda (i-gate) (nmodl-name (s+ 'i_ (second i-gate)))) i-gates )))
     1357                  (currentEqLocals   . ,current-locals)
     1358                  (currentEqDefs     . ,(map (lambda (p) (expr->string/NMODL (second p) (first p))) i-eqs))
    13241359                  (permeatingIons    . ,(map
    13251360                                         (match-lambda
     
    15571592          (instantiate-template reactions-template tmpl-env)
    15581593          (instantiate-template pools-template tmpl-env)
     1594          (instantiate-template breakpoint-template tmpl-env)
    15591595          (instantiate-template rate-template tmpl-env)
    15601596          (instantiate-template kstates-template tmpl-env)
Note: See TracChangeset for help on using the changeset viewer.