Fast Spiking Basket cells (Tzilivaki et al 2019)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:237595
"Interneurons are critical for the proper functioning of neural circuits. While often morphologically complex, dendritic integration and its role in neuronal output have been ignored for decades, treating interneurons as linear point neurons. Exciting new findings suggest that interneuron dendrites support complex, nonlinear computations: sublinear integration of EPSPs in the cerebellum, coupled to supralinear calcium accumulations and supralinear voltage integration in the hippocampus. These findings challenge the point neuron dogma and call for a new theory of interneuron arithmetic. Using detailed, biophysically constrained models, we predict that dendrites of FS basket cells in both hippocampus and mPFC come in two flavors: supralinear, supporting local sodium spikes within large-volume branches and sublinear, in small-volume branches. Synaptic activation of varying sets of these dendrites leads to somatic firing variability that cannot be explained by the point neuron reduction. Instead, a 2-stage Artificial Neural Network (ANN), with both sub- and supralinear hidden nodes, captures most of the variance. We propose that FS basket cells have substantially expanded computational capabilities sub-served by their non-linear dendrites and act as a 2-layer ANN."
Reference:
1 . Tzilivaki A, Kastellakis G, Poirazi P (2019) Challenging the point neuron dogma: FS basket cells as 2-stage nonlinear integrators Nature Communications 10(1):3664 [PubMed]
Citations  Citation Browser
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell;
Brain Region(s)/Organism: Hippocampus; Prefrontal cortex (PFC);
Cell Type(s): Hippocampus CA3 interneuron basket GABA cell; Neocortex layer 5 interneuron;
Channel(s):
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: NEURON; MATLAB; Python;
Model Concept(s): Active Dendrites; Detailed Neuronal Models;
Implementer(s): Tzilivaki, Alexandra [alexandra.tzilivaki at charite.de]; Kastellakis, George [gkastel at gmail.com];
Search NeuronDB for information about:  Hippocampus CA3 interneuron basket GABA cell;
/
TzilivakiEtal_FSBCs_model
Multicompartmental_Biophysical_models
mechanism
x86_64
.libs
ampa.mod *
ampain.mod *
cadyn.mod *
cadynin.mod *
cal.mod *
calc.mod *
calcb.mod *
can.mod *
cancr.mod *
canin.mod *
car.mod *
cat.mod *
catcb.mod *
cpampain.mod *
gabaa.mod *
gabaain.mod *
gabab.mod *
h.mod *
hcb.mod *
hin.mod *
ican.mod *
iccb.mod *
iccr.mod *
icin.mod *
iks.mod *
ikscb.mod *
ikscr.mod *
iksin.mod *
kadist.mod *
kadistcr.mod *
kadistin.mod *
kaprox.mod *
kaproxcb.mod *
kaproxin.mod *
kca.mod *
kcain.mod *
kct.mod *
kctin.mod *
kdr.mod *
kdrcb.mod *
kdrcr.mod *
kdrin.mod *
naf.mod *
nafcb.mod *
nafcr.mod *
nafin.mod *
nafx.mod *
nap.mod *
netstim.mod *
NMDA.mod *
NMDAIN.mod *
sinclamp.mod *
vecstim.mod *
ampa.c
ampa.lo
ampain.c
ampain.lo
cadyn.c
cadyn.lo
cadynin.c
cadynin.lo
cal.c
cal.lo
calc.c
calc.lo
calcb.c
calcb.lo
can.c
can.lo
cancr.c
cancr.lo
canin.c
canin.lo
car.c
car.lo
cat.c
cat.lo
catcb.c
catcb.lo
cpampain.c
cpampain.lo
gabaa.c
gabaa.lo
gabaain.c
gabaain.lo
gabab.c
gabab.lo
h.c
h.lo
hcb.c
hcb.lo
hin.c
hin.lo
ican.c
ican.lo
iccb.c
iccb.lo
iccr.c
iccr.lo
icin.c
icin.lo
iks.c
iks.lo
ikscb.c
ikscb.lo
ikscr.c
ikscr.lo
iksin.c
iksin.lo
kadist.c
kadist.lo
kadistcr.c
kadistcr.lo
kadistin.c
kadistin.lo
kaprox.c
kaprox.lo
kaproxcb.c
kaproxcb.lo
kaproxin.c
kaproxin.lo
kca.c
kca.lo
kcain.c
kcain.lo
kct.c
kct.lo
kctin.c
kctin.lo
kdr.c
kdr.lo
kdrcb.c
kdrcb.lo
kdrcr.c
kdrcr.lo
kdrin.c
kdrin.lo
libnrnmech.la *
mod_func.c
mod_func.lo
naf.c
naf.lo
nafcb.c
nafcb.lo
nafcr.c
nafcr.lo
nafin.c
nafin.lo
nafx.c
nafx.lo
nap.c
nap.lo
netstim.c
netstim.lo
NMDA.c
NMDA.lo
NMDAIN.c
NMDAIN.lo
sinclamp.c
sinclamp.lo
special
vecstim.c
vecstim.lo
                            
/* Created by Language version: 6.2.0 */
/* VECTORIZED */
#define NRN_VECTORIZED 1
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "scoplib_ansi.h"
#undef PI
#define nil 0
#include "md1redef.h"
#include "section.h"
#include "nrniv_mf.h"
#include "md2redef.h"
 
#if METHOD3
extern int _method3;
#endif

#if !NRNGPU
#undef exp
#define exp hoc_Exp
extern double hoc_Exp(double);
#endif
 
#define nrn_init _nrn_init__iCcb
#define _nrn_initial _nrn_initial__iCcb
#define nrn_cur _nrn_cur__iCcb
#define _nrn_current _nrn_current__iCcb
#define nrn_jacob _nrn_jacob__iCcb
#define nrn_state _nrn_state__iCcb
#define _net_receive _net_receive__iCcb 
#define rate rate__iCcb 
#define states states__iCcb 
 
#define _threadargscomma_ _p, _ppvar, _thread, _nt,
#define _threadargsprotocomma_ double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt,
#define _threadargs_ _p, _ppvar, _thread, _nt
#define _threadargsproto_ double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt
 	/*SUPPRESS 761*/
	/*SUPPRESS 762*/
	/*SUPPRESS 763*/
	/*SUPPRESS 765*/
	 extern double *getarg();
 /* Thread safe. No static _p or _ppvar. */
 
#define t _nt->_t
#define dt _nt->_dt
#define gkcbar _p[0]
#define ik _p[1]
#define gk _p[2]
#define c _p[3]
#define cai _p[4]
#define Dc _p[5]
#define cinf _p[6]
#define ctau _p[7]
#define ek _p[8]
#define ki _p[9]
#define ko _p[10]
#define v _p[11]
#define _g _p[12]
#define _ion_ki	*_ppvar[0]._pval
#define _ion_ko	*_ppvar[1]._pval
#define _ion_ik	*_ppvar[2]._pval
#define _ion_dikdv	*_ppvar[3]._pval
#define _ion_cai	*_ppvar[4]._pval
 
#if MAC
#if !defined(v)
#define v _mlhv
#endif
#if !defined(h)
#define h _mlhh
#endif
#endif
 
#if defined(__cplusplus)
extern "C" {
#endif
 static int hoc_nrnpointerindex =  -1;
 static Datum* _extcall_thread;
 static Prop* _extcall_prop;
 /* external NEURON variables */
 /* declaration of user functions */
 static void _hoc_cbet(void);
 static void _hoc_calf(void);
 static void _hoc_rate(void);
 static int _mechtype;
extern void _nrn_cacheloop_reg(int, int);
extern void hoc_register_prop_size(int, int, int);
extern void hoc_register_limits(int, HocParmLimits*);
extern void hoc_register_units(int, HocParmUnits*);
extern void nrn_promote(Prop*, int, int);
extern Memb_func* memb_func;
 extern void _nrn_setdata_reg(int, void(*)(Prop*));
 static void _setdata(Prop* _prop) {
 _extcall_prop = _prop;
 }
 static void _hoc_setdata() {
 Prop *_prop, *hoc_getdata_range(int);
 _prop = hoc_getdata_range(_mechtype);
   _setdata(_prop);
 hoc_retpushx(1.);
}
 /* connect user functions to hoc names */
 static VoidFunc hoc_intfunc[] = {
 "setdata_iCcb", _hoc_setdata,
 "cbet_iCcb", _hoc_cbet,
 "calf_iCcb", _hoc_calf,
 "rate_iCcb", _hoc_rate,
 0, 0
};
#define cbet cbet_iCcb
#define calf calf_iCcb
 extern double cbet( _threadargsprotocomma_ double , double );
 extern double calf( _threadargsprotocomma_ double , double );
 /* declare global and static user variables */
 /* some parameters have upper and lower limits */
 static HocParmLimits _hoc_parm_limits[] = {
 0,0,0
};
 static HocParmUnits _hoc_parm_units[] = {
 "gkcbar_iCcb", "mho/cm2",
 "ik_iCcb", "mA/cm2",
 "gk_iCcb", "mho/cm2",
 0,0
};
 static double c0 = 0;
 static double delta_t = 1;
 /* connect global user variables to hoc */
 static DoubScal hoc_scdoub[] = {
 0,0
};
 static DoubVec hoc_vdoub[] = {
 0,0,0
};
 static double _sav_indep;
 static void nrn_alloc(Prop*);
static void  nrn_init(_NrnThread*, _Memb_list*, int);
static void nrn_state(_NrnThread*, _Memb_list*, int);
 static void nrn_cur(_NrnThread*, _Memb_list*, int);
static void  nrn_jacob(_NrnThread*, _Memb_list*, int);
 
static int _ode_count(int);
static void _ode_map(int, double**, double**, double*, Datum*, double*, int);
static void _ode_spec(_NrnThread*, _Memb_list*, int);
static void _ode_matsol(_NrnThread*, _Memb_list*, int);
 
#define _cvode_ieq _ppvar[5]._i
 static void _ode_matsol_instance1(_threadargsproto_);
 /* connect range variables in _p that hoc is supposed to know about */
 static const char *_mechanism[] = {
 "6.2.0",
"iCcb",
 "gkcbar_iCcb",
 0,
 "ik_iCcb",
 "gk_iCcb",
 0,
 "c_iCcb",
 0,
 0};
 static Symbol* _k_sym;
 static Symbol* _ca_sym;
 
extern Prop* need_memb(Symbol*);

static void nrn_alloc(Prop* _prop) {
	Prop *prop_ion;
	double *_p; Datum *_ppvar;
 	_p = nrn_prop_data_alloc(_mechtype, 13, _prop);
 	/*initialize range parameters*/
 	gkcbar = 0.0022;
 	_prop->param = _p;
 	_prop->param_size = 13;
 	_ppvar = nrn_prop_datum_alloc(_mechtype, 6, _prop);
 	_prop->dparam = _ppvar;
 	/*connect ionic variables to this model*/
 prop_ion = need_memb(_k_sym);
 nrn_promote(prop_ion, 1, 0);
 	_ppvar[0]._pval = &prop_ion->param[1]; /* ki */
 	_ppvar[1]._pval = &prop_ion->param[2]; /* ko */
 	_ppvar[2]._pval = &prop_ion->param[3]; /* ik */
 	_ppvar[3]._pval = &prop_ion->param[4]; /* _ion_dikdv */
 prop_ion = need_memb(_ca_sym);
 nrn_promote(prop_ion, 1, 0);
 	_ppvar[4]._pval = &prop_ion->param[1]; /* cai */
 
}
 static void _initlists();
  /* some states have an absolute tolerance */
 static Symbol** _atollist;
 static HocStateTolerance _hoc_state_tol[] = {
 0,0
};
 static void _update_ion_pointer(Datum*);
 extern Symbol* hoc_lookup(const char*);
extern void _nrn_thread_reg(int, int, void(*)(Datum*));
extern void _nrn_thread_table_reg(int, void(*)(double*, Datum*, Datum*, _NrnThread*, int));
extern void hoc_register_tolerance(int, HocStateTolerance*, Symbol***);
extern void _cvode_abstol( Symbol**, double*, int);

 void _iccb_reg() {
	int _vectorized = 1;
  _initlists();
 	ion_reg("k", -10000.);
 	ion_reg("ca", -10000.);
 	_k_sym = hoc_lookup("k_ion");
 	_ca_sym = hoc_lookup("ca_ion");
 	register_mech(_mechanism, nrn_alloc,nrn_cur, nrn_jacob, nrn_state, nrn_init, hoc_nrnpointerindex, 1);
 _mechtype = nrn_get_mechtype(_mechanism[1]);
     _nrn_setdata_reg(_mechtype, _setdata);
     _nrn_thread_reg(_mechtype, 2, _update_ion_pointer);
  hoc_register_prop_size(_mechtype, 13, 6);
  hoc_register_dparam_semantics(_mechtype, 0, "k_ion");
  hoc_register_dparam_semantics(_mechtype, 1, "k_ion");
  hoc_register_dparam_semantics(_mechtype, 2, "k_ion");
  hoc_register_dparam_semantics(_mechtype, 3, "k_ion");
  hoc_register_dparam_semantics(_mechtype, 4, "ca_ion");
  hoc_register_dparam_semantics(_mechtype, 5, "cvodeieq");
 	hoc_register_cvode(_mechtype, _ode_count, _ode_map, _ode_spec, _ode_matsol);
 	hoc_register_tolerance(_mechtype, _hoc_state_tol, &_atollist);
 	hoc_register_var(hoc_scdoub, hoc_vdoub, hoc_intfunc);
 	ivoc_help("help ?1 iCcb /home/cluster/aleka/MainPath/Desktop/FSBC_model/Multicompartmental_Biophysical_models/mechanism/x86_64/iccb.mod\n");
 hoc_register_limits(_mechtype, _hoc_parm_limits);
 hoc_register_units(_mechtype, _hoc_parm_units);
 }
static int _reset;
static char *modelname = "";

static int error;
static int _ninits = 0;
static int _match_recurse=1;
static void _modl_cleanup(){ _match_recurse=1;}
static int rate(_threadargsproto_);
 
static int _ode_spec1(_threadargsproto_);
/*static int _ode_matsol1(_threadargsproto_);*/
 static int _slist1[1], _dlist1[1];
 static int states(_threadargsproto_);
 
/*CVODE*/
 static int _ode_spec1 (double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt) {int _reset = 0; {
   rate ( _threadargs_ ) ;
   Dc = ( cinf - c ) / ctau ;
   }
 return _reset;
}
 static int _ode_matsol1 (double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt) {
 rate ( _threadargs_ ) ;
 Dc = Dc  / (1. - dt*( ( ( ( - 1.0 ) ) ) / ctau )) ;
 return 0;
}
 /*END CVODE*/
 static int states (double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt) { {
   rate ( _threadargs_ ) ;
    c = c + (1. - exp(dt*(( ( ( - 1.0 ) ) ) / ctau)))*(- ( ( ( cinf ) ) / ctau ) / ( ( ( ( - 1.0 ) ) ) / ctau ) - c) ;
   }
  return 0;
}
 
double calf ( _threadargsprotocomma_ double _lv , double _lcai ) {
   double _lcalf;
 double _lvs , _lva ;
 _lvs = _lv + 40.0 * log10 ( 1000.0 * _lcai ) ;
   _lva = _lvs + 18.0 ;
   if ( fabs ( _lva ) < 1e-04 ) {
     _lva = _lva + 0.0001 ;
     }
   _lcalf = ( - 0.00642 * _lvs - 0.1152 ) / ( - 1.0 + exp ( - _lva / 12.0 ) ) ;
   
return _lcalf;
 }
 
static void _hoc_calf(void) {
  double _r;
   double* _p; Datum* _ppvar; Datum* _thread; _NrnThread* _nt;
   if (_extcall_prop) {_p = _extcall_prop->param; _ppvar = _extcall_prop->dparam;}else{ _p = (double*)0; _ppvar = (Datum*)0; }
  _thread = _extcall_thread;
  _nt = nrn_threads;
 _r =  calf ( _p, _ppvar, _thread, _nt, *getarg(1) , *getarg(2) );
 hoc_retpushx(_r);
}
 
double cbet ( _threadargsprotocomma_ double _lv , double _lcai ) {
   double _lcbet;
 double _lvs , _lvb ;
 _lvs = _lv + 40.0 * log10 ( _lcai * 1000.0 ) ;
   _lvb = _lvs + 152.0 ;
   if ( fabs ( _lvb ) < 1e-04 ) {
     _lvb = _lvb + 0.0001 ;
     }
   _lcbet = 1.7 * exp ( - _lvb / 30.0 ) ;
   
return _lcbet;
 }
 
static void _hoc_cbet(void) {
  double _r;
   double* _p; Datum* _ppvar; Datum* _thread; _NrnThread* _nt;
   if (_extcall_prop) {_p = _extcall_prop->param; _ppvar = _extcall_prop->dparam;}else{ _p = (double*)0; _ppvar = (Datum*)0; }
  _thread = _extcall_thread;
  _nt = nrn_threads;
 _r =  cbet ( _p, _ppvar, _thread, _nt, *getarg(1) , *getarg(2) );
 hoc_retpushx(_r);
}
 
static int  rate ( _threadargsproto_ ) {
   double _lcsum , _lca , _lcb ;
 _lca = calf ( _threadargscomma_ v , cai ) ;
   _lcb = cbet ( _threadargscomma_ v , cai ) ;
   _lcsum = _lca + _lcb ;
   cinf = _lca / _lcsum ;
   if ( ( 1.0 / _lcsum ) > 1.1 ) {
     ctau = 1.0 / _lcsum ;
     }
   else {
     ctau = 1.1 ;
     }
    return 0; }
 
static void _hoc_rate(void) {
  double _r;
   double* _p; Datum* _ppvar; Datum* _thread; _NrnThread* _nt;
   if (_extcall_prop) {_p = _extcall_prop->param; _ppvar = _extcall_prop->dparam;}else{ _p = (double*)0; _ppvar = (Datum*)0; }
  _thread = _extcall_thread;
  _nt = nrn_threads;
 _r = 1.;
 rate ( _p, _ppvar, _thread, _nt );
 hoc_retpushx(_r);
}
 
static int _ode_count(int _type){ return 1;}
 
static void _ode_spec(_NrnThread* _nt, _Memb_list* _ml, int _type) {
   double* _p; Datum* _ppvar; Datum* _thread;
   Node* _nd; double _v; int _iml, _cntml;
  _cntml = _ml->_nodecount;
  _thread = _ml->_thread;
  for (_iml = 0; _iml < _cntml; ++_iml) {
    _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
    _nd = _ml->_nodelist[_iml];
    v = NODEV(_nd);
  ki = _ion_ki;
  ko = _ion_ko;
  cai = _ion_cai;
     _ode_spec1 (_p, _ppvar, _thread, _nt);
  }}
 
static void _ode_map(int _ieq, double** _pv, double** _pvdot, double* _pp, Datum* _ppd, double* _atol, int _type) { 
	double* _p; Datum* _ppvar;
 	int _i; _p = _pp; _ppvar = _ppd;
	_cvode_ieq = _ieq;
	for (_i=0; _i < 1; ++_i) {
		_pv[_i] = _pp + _slist1[_i];  _pvdot[_i] = _pp + _dlist1[_i];
		_cvode_abstol(_atollist, _atol, _i);
	}
 }
 
static void _ode_matsol_instance1(_threadargsproto_) {
 _ode_matsol1 (_p, _ppvar, _thread, _nt);
 }
 
static void _ode_matsol(_NrnThread* _nt, _Memb_list* _ml, int _type) {
   double* _p; Datum* _ppvar; Datum* _thread;
   Node* _nd; double _v; int _iml, _cntml;
  _cntml = _ml->_nodecount;
  _thread = _ml->_thread;
  for (_iml = 0; _iml < _cntml; ++_iml) {
    _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
    _nd = _ml->_nodelist[_iml];
    v = NODEV(_nd);
  ki = _ion_ki;
  ko = _ion_ko;
  cai = _ion_cai;
 _ode_matsol_instance1(_threadargs_);
 }}
 extern void nrn_update_ion_pointer(Symbol*, Datum*, int, int);
 static void _update_ion_pointer(Datum* _ppvar) {
   nrn_update_ion_pointer(_k_sym, _ppvar, 0, 1);
   nrn_update_ion_pointer(_k_sym, _ppvar, 1, 2);
   nrn_update_ion_pointer(_k_sym, _ppvar, 2, 3);
   nrn_update_ion_pointer(_k_sym, _ppvar, 3, 4);
   nrn_update_ion_pointer(_ca_sym, _ppvar, 4, 1);
 }

static void initmodel(double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt) {
  int _i; double _save;{
  c = c0;
 {
   rate ( _threadargs_ ) ;
   c = cinf ;
   }
 
}
}

static void nrn_init(_NrnThread* _nt, _Memb_list* _ml, int _type){
double* _p; Datum* _ppvar; Datum* _thread;
Node *_nd; double _v; int* _ni; int _iml, _cntml;
#if CACHEVEC
    _ni = _ml->_nodeindices;
#endif
_cntml = _ml->_nodecount;
_thread = _ml->_thread;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
#if CACHEVEC
  if (use_cachevec) {
    _v = VEC_V(_ni[_iml]);
  }else
#endif
  {
    _nd = _ml->_nodelist[_iml];
    _v = NODEV(_nd);
  }
 v = _v;
  ki = _ion_ki;
  ko = _ion_ko;
  cai = _ion_cai;
 initmodel(_p, _ppvar, _thread, _nt);
 }
}

static double _nrn_current(double* _p, Datum* _ppvar, Datum* _thread, _NrnThread* _nt, double _v){double _current=0.;v=_v;{ {
   gk = gkcbar * c * c ;
   ek = 25.0 * log ( ko / ki ) ;
   ik = gk * ( v - ek ) ;
   }
 _current += ik;

} return _current;
}

static void nrn_cur(_NrnThread* _nt, _Memb_list* _ml, int _type) {
double* _p; Datum* _ppvar; Datum* _thread;
Node *_nd; int* _ni; double _rhs, _v; int _iml, _cntml;
#if CACHEVEC
    _ni = _ml->_nodeindices;
#endif
_cntml = _ml->_nodecount;
_thread = _ml->_thread;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
#if CACHEVEC
  if (use_cachevec) {
    _v = VEC_V(_ni[_iml]);
  }else
#endif
  {
    _nd = _ml->_nodelist[_iml];
    _v = NODEV(_nd);
  }
  ki = _ion_ki;
  ko = _ion_ko;
  cai = _ion_cai;
 _g = _nrn_current(_p, _ppvar, _thread, _nt, _v + .001);
 	{ double _dik;
  _dik = ik;
 _rhs = _nrn_current(_p, _ppvar, _thread, _nt, _v);
  _ion_dikdv += (_dik - ik)/.001 ;
 	}
 _g = (_g - _rhs)/.001;
  _ion_ik += ik ;
#if CACHEVEC
  if (use_cachevec) {
	VEC_RHS(_ni[_iml]) -= _rhs;
  }else
#endif
  {
	NODERHS(_nd) -= _rhs;
  }
 
}
 
}

static void nrn_jacob(_NrnThread* _nt, _Memb_list* _ml, int _type) {
double* _p; Datum* _ppvar; Datum* _thread;
Node *_nd; int* _ni; int _iml, _cntml;
#if CACHEVEC
    _ni = _ml->_nodeindices;
#endif
_cntml = _ml->_nodecount;
_thread = _ml->_thread;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml];
#if CACHEVEC
  if (use_cachevec) {
	VEC_D(_ni[_iml]) += _g;
  }else
#endif
  {
     _nd = _ml->_nodelist[_iml];
	NODED(_nd) += _g;
  }
 
}
 
}

static void nrn_state(_NrnThread* _nt, _Memb_list* _ml, int _type) {
double* _p; Datum* _ppvar; Datum* _thread;
Node *_nd; double _v = 0.0; int* _ni; int _iml, _cntml;
#if CACHEVEC
    _ni = _ml->_nodeindices;
#endif
_cntml = _ml->_nodecount;
_thread = _ml->_thread;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
 _nd = _ml->_nodelist[_iml];
#if CACHEVEC
  if (use_cachevec) {
    _v = VEC_V(_ni[_iml]);
  }else
#endif
  {
    _nd = _ml->_nodelist[_iml];
    _v = NODEV(_nd);
  }
 v=_v;
{
  ki = _ion_ki;
  ko = _ion_ko;
  cai = _ion_cai;
 {   states(_p, _ppvar, _thread, _nt);
  } }}

}

static void terminal(){}

static void _initlists(){
 double _x; double* _p = &_x;
 int _i; static int _first = 1;
  if (!_first) return;
 _slist1[0] = &(c) - _p;  _dlist1[0] = &(Dc) - _p;
_first = 0;
}

#if defined(__cplusplus)
} /* extern "C" */
#endif