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 */
/* NOT VECTORIZED */
#define NRN_VECTORIZED 0
#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__NetStim1
#define _nrn_initial _nrn_initial__NetStim1
#define nrn_cur _nrn_cur__NetStim1
#define _nrn_current _nrn_current__NetStim1
#define nrn_jacob _nrn_jacob__NetStim1
#define nrn_state _nrn_state__NetStim1
#define _net_receive _net_receive__NetStim1 
#define event_time event_time__NetStim1 
#define init_sequence init_sequence__NetStim1 
#define seed seed__NetStim1 
 
#define _threadargscomma_ /**/
#define _threadargsprotocomma_ /**/
#define _threadargs_ /**/
#define _threadargsproto_ /**/
 	/*SUPPRESS 761*/
	/*SUPPRESS 762*/
	/*SUPPRESS 763*/
	/*SUPPRESS 765*/
	 extern double *getarg();
 static double *_p; static Datum *_ppvar;
 
#define t nrn_threads->_t
#define dt nrn_threads->_dt
#define interval _p[0]
#define number _p[1]
#define start _p[2]
#define noise _p[3]
#define burstP _p[4]
#define y _p[5]
#define event _p[6]
#define on _p[7]
#define end _p[8]
#define _tsav _p[9]
#define _nd_area  *_ppvar[0]._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;
 /* external NEURON variables */
 /* declaration of user functions */
 static double _hoc_event_time();
 static double _hoc_init_sequence();
 static double _hoc_invl();
 static double _hoc_seed();
 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 Prop* nrn_point_prop_;
 static int _pointtype;
 static void* _hoc_create_pnt(_ho) Object* _ho; { void* create_point_process();
 return create_point_process(_pointtype, _ho);
}
 static void _hoc_destroy_pnt();
 static double _hoc_loc_pnt(_vptr) void* _vptr; {double loc_point_process();
 return loc_point_process(_pointtype, _vptr);
}
 static double _hoc_has_loc(_vptr) void* _vptr; {double has_loc_point();
 return has_loc_point(_vptr);
}
 static double _hoc_get_loc_pnt(_vptr)void* _vptr; {
 double get_loc_point_process(); return (get_loc_point_process(_vptr));
}
 extern void _nrn_setdata_reg(int, void(*)(Prop*));
 static void _setdata(Prop* _prop) {
 _p = _prop->param; _ppvar = _prop->dparam;
 }
 static void _hoc_setdata(void* _vptr) { Prop* _prop;
 _prop = ((Point_process*)_vptr)->_prop;
   _setdata(_prop);
 }
 /* connect user functions to hoc names */
 static VoidFunc hoc_intfunc[] = {
 0,0
};
 static Member_func _member_func[] = {
 "loc", _hoc_loc_pnt,
 "has_loc", _hoc_has_loc,
 "get_loc", _hoc_get_loc_pnt,
 "event_time", _hoc_event_time,
 "init_sequence", _hoc_init_sequence,
 "invl", _hoc_invl,
 "seed", _hoc_seed,
 0, 0
};
#define invl invl_NetStim1
 extern double invl( double );
 /* declare global and static user variables */
 /* some parameters have upper and lower limits */
 static HocParmLimits _hoc_parm_limits[] = {
 "interval", 1e-09, 1e+09,
 "noise", 0, 1,
 0,0,0
};
 static HocParmUnits _hoc_parm_units[] = {
 "interval", "ms",
 "start", "ms",
 "burstP", "ms",
 0,0
};
 static double v = 0;
 /* 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 _hoc_destroy_pnt(_vptr) void* _vptr; {
   destroy_point_process(_vptr);
}
 /* connect range variables in _p that hoc is supposed to know about */
 static const char *_mechanism[] = {
 "6.2.0",
"NetStim1",
 "interval",
 "number",
 "start",
 "noise",
 "burstP",
 0,
 "y",
 0,
 0,
 0};
 
extern Prop* need_memb(Symbol*);

static void nrn_alloc(Prop* _prop) {
	Prop *prop_ion;
	double *_p; Datum *_ppvar;
  if (nrn_point_prop_) {
	_prop->_alloc_seq = nrn_point_prop_->_alloc_seq;
	_p = nrn_point_prop_->param;
	_ppvar = nrn_point_prop_->dparam;
 }else{
 	_p = nrn_prop_data_alloc(_mechtype, 10, _prop);
 	/*initialize range parameters*/
 	interval = 10;
 	number = 10;
 	start = 100;
 	noise = 0;
 	burstP = 100;
  }
 	_prop->param = _p;
 	_prop->param_size = 10;
  if (!nrn_point_prop_) {
 	_ppvar = nrn_prop_datum_alloc(_mechtype, 3, _prop);
  }
 	_prop->dparam = _ppvar;
 	/*connect ionic variables to this model*/
 
}
 static void _initlists();
 
#define _tqitem &(_ppvar[2]._pvoid)
 static void _net_receive(Point_process*, double*, double);
 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 _netstim_reg() {
	int _vectorized = 0;
  _initlists();
 	_pointtype = point_register_mech(_mechanism,
	 nrn_alloc,(void*)0, (void*)0, (void*)0, nrn_init,
	 hoc_nrnpointerindex, 0,
	 _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 _mechtype = nrn_get_mechtype(_mechanism[1]);
     _nrn_setdata_reg(_mechtype, _setdata);
  hoc_register_prop_size(_mechtype, 10, 3);
  hoc_register_dparam_semantics(_mechtype, 0, "area");
  hoc_register_dparam_semantics(_mechtype, 1, "pntproc");
  hoc_register_dparam_semantics(_mechtype, 2, "netsend");
 add_nrn_artcell(_mechtype, 2);
 add_nrn_has_net_event(_mechtype);
 pnt_receive[_mechtype] = _net_receive;
 pnt_receive_size[_mechtype] = 1;
 	hoc_register_var(hoc_scdoub, hoc_vdoub, hoc_intfunc);
 	ivoc_help("help ?1 NetStim1 /home/cluster/aleka/MainPath/Desktop/FSBC_model/Multicompartmental_Biophysical_models/mechanism/x86_64/netstim.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 event_time();
static int init_sequence(double);
static int seed(double);
 
static int  seed (  double _lx ) {
   set_seed ( _lx ) ;
    return 0; }
 
static double _hoc_seed(void* _vptr) {
 double _r;
    _hoc_setdata(_vptr);
 _r = 1.;
 seed (  *getarg(1) );
 return(_r);
}
 
static int  init_sequence (  double _lt ) {
   if ( number > 0.0 ) {
     on = 1.0 ;
     event = _lt ;
     end = _lt + 1e-6 + invl ( _threadargscomma_ interval ) * ( number - 1.0 ) ;
     }
    return 0; }
 
static double _hoc_init_sequence(void* _vptr) {
 double _r;
    _hoc_setdata(_vptr);
 _r = 1.;
 init_sequence (  *getarg(1) );
 return(_r);
}
 
double invl (  double _lmean ) {
   double _linvl;
 if ( _lmean <= 0. ) {
     _lmean = .01 ;
     }
   if ( noise  == 0.0 ) {
     _linvl = _lmean ;
     }
   else {
     _linvl = ( 1. - noise ) * _lmean + noise * _lmean * exprand ( 1.0 ) ;
     }
   
return _linvl;
 }
 
static double _hoc_invl(void* _vptr) {
 double _r;
    _hoc_setdata(_vptr);
 _r =  invl (  *getarg(1) );
 return(_r);
}
 
static int  event_time (  ) {
   if ( number > 0.0 ) {
     event = event + invl ( _threadargscomma_ interval ) ;
     }
   if ( event > end ) {
     on = 0.0 ;
     }
    return 0; }
 
static double _hoc_event_time(void* _vptr) {
 double _r;
    _hoc_setdata(_vptr);
 _r = 1.;
 event_time (  );
 return(_r);
}
 
static void _net_receive (_pnt, _args, _lflag) Point_process* _pnt; double* _args; double _lflag; 
{    _p = _pnt->_prop->param; _ppvar = _pnt->_prop->dparam;
  if (_tsav > t){ extern char* hoc_object_name(); hoc_execerror(hoc_object_name(_pnt->ob), ":Event arrived out of order. Must call ParallelContext.set_maxstep AFTER assigning minimum NetCon.delay");}
 _tsav = t;   if (_lflag == 1. ) {*(_tqitem) = 0;}
 {
   if ( _lflag  == 0.0 ) {
     if ( _args[0] > 0.0  && on  == 0.0 ) {
       init_sequence ( _threadargscomma_ t ) ;
       artcell_net_send ( _tqitem, _args, _pnt, t +  0.0 , 1.0 ) ;
       }
     else if ( _args[0] < 0.0  && on  == 1.0 ) {
       on = 0.0 ;
       }
     }
   if ( _lflag  == 3.0 ) {
     if ( on  == 0.0 ) {
       init_sequence ( _threadargscomma_ t ) ;
       artcell_net_send ( _tqitem, _args, _pnt, t +  0.0 , 1.0 ) ;
       }
     }
   if ( _lflag  == 1.0  && on  == 1.0 ) {
     y = 2.0 ;
     net_event ( _pnt, t ) ;
     event_time ( _threadargs_ ) ;
     if ( on  == 1.0 ) {
       artcell_net_send ( _tqitem, _args, _pnt, t +  event - t , 1.0 ) ;
       }
     artcell_net_send ( _tqitem, _args, _pnt, t +  .1 , 2.0 ) ;
     }
   if ( _lflag  == 2.0 ) {
     y = 0.0 ;
     }
   } }

static void initmodel() {
  int _i; double _save;_ninits++;
{
 {
   on = 0.0 ;
   y = 0.0 ;
   if ( noise < 0.0 ) {
     noise = 0.0 ;
     }
   if ( noise > 1.0 ) {
     noise = 1.0 ;
     }
   if ( start >= 0.0  && number > 0.0 ) {
     event = start + invl ( _threadargscomma_ interval ) - interval * ( 1. - noise ) ;
     if ( event < 0.0 ) {
       event = 0.0 ;
       }
     artcell_net_send ( _tqitem, (double*)0, _ppvar[1]._pvoid, t +  event , 3.0 ) ;
     artcell_net_send ( _tqitem, (double*)0, _ppvar[1]._pvoid, t +  event + burstP , 3.0 ) ;
     }
   }

}
}

static void nrn_init(_NrnThread* _nt, _Memb_list* _ml, int _type){
Node *_nd; double _v; int* _ni; int _iml, _cntml;
#if CACHEVEC
    _ni = _ml->_nodeindices;
#endif
_cntml = _ml->_nodecount;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
 _tsav = -1e20;
 initmodel();
}}

static double _nrn_current(double _v){double _current=0.;v=_v;{
} return _current;
}

static void nrn_state(_NrnThread* _nt, _Memb_list* _ml, int _type){
Node *_nd; double _v = 0.0; int* _ni; int _iml, _cntml;
#if CACHEVEC
    _ni = _ml->_nodeindices;
#endif
_cntml = _ml->_nodecount;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
 _nd = _ml->_nodelist[_iml];
 v=_v;
{
}}

}

static void terminal(){}

static void _initlists() {
 int _i; static int _first = 1;
  if (!_first) return;
_first = 0;
}