Glutamate mediated dendritic and somatic plateau potentials in cortical L5 pyr cells (Gao et al '20)

 Download zip file 
Help downloading and running models
Our model was built on a reconstructed Layer 5 pyramidal neuron of the rat medial prefrontal cortex, and constrained by 4 sets of experimental data: (i) voltage waveforms obtained at the site of the glutamatergic input in distal basal dendrite, including initial sodium spikelet, fast rise, plateau phase and abrupt collapse of the plateau; (ii) a family of voltage traces describing dendritic membrane responses to gradually increasing intensity of glutamatergic stimulation; (iii) voltage waveforms of backpropagating action potentials in basal dendrites (Antic, 2003); and (iv) the change of backpropagating action potential amplitude in response to drugs that block Na+ or K+ channels (Acker and Antic, 2009). Both, synaptic AMPA/NMDA and extrasynaptic NMDA inputs were placed on basal dendrites to model the induction of local regenerative potentials termed "glutamate-mediated dendritic plateau potentials". The active properties of the cell were tuned to match the voltage waveform, amplitude and duration of experimentally observed plateau potentials. The effects of input location, receptor conductance, channel properties and membrane time constant during plateau were explored. The new model predicted that during dendritic plateau potential the somatic membrane time constant is reduced. This and other model predictions were then tested in real neurons. Overall, the results support our theoretical framework that dendritic plateau potentials bring neuronal cell body into a depolarized state ("UP state"), which lasts 200 - 500 ms, or more. Plateau potentials profoundly change neuronal state -- a plateau potential triggered in one basal dendrite depolarizes the soma and shortens membrane time constant, making the cell more susceptible to action potential firing triggered by other afferent inputs. Plateau potentials may allow cortical pyramidal neurons to tune into ongoing network activity and potentially enable synchronized firing, to form active neural ensembles.
1 . Gao PP, Graham JW, Zhou WL, Jang J, Angulo SL, Dura-Bernal S, Hines ML, Lytton W, Antic SD (2020) Local Glutamate-Mediated Dendritic Plateau Potentials Change the State of the Cortical Pyramidal Neuron. J Neurophysiol [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Dendrite; Neuron or other electrically excitable cell;
Brain Region(s)/Organism: Prefrontal cortex (PFC); Neocortex;
Cell Type(s): Neocortex L5/6 pyramidal GLU cell;
Channel(s): I A; I K; I h; I K,Ca;
Gap Junctions:
Receptor(s): Glutamate; NMDA;
Transmitter(s): Glutamate;
Simulation Environment: NEURON; Python;
Model Concept(s): Action Potentials; Active Dendrites; Calcium dynamics; Axonal Action Potentials; Dendritic Bistability; Detailed Neuronal Models; Membrane Properties; Synaptic Integration;
Implementer(s): Antic, Srdjan [antic at]; Gao, Peng [peng at];
Search NeuronDB for information about:  Neocortex L5/6 pyramidal GLU cell; NMDA; Glutamate; I A; I K; I h; I K,Ca; Glutamate;
/* Created by Language version: 7.5.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"
extern int _method3;

#undef exp
#define exp hoc_Exp
extern double hoc_Exp(double);
#define nrn_init _nrn_init__VecStim
#define _nrn_initial _nrn_initial__VecStim
#define nrn_cur _nrn_cur__VecStim
#define _nrn_current _nrn_current__VecStim
#define nrn_jacob _nrn_jacob__VecStim
#define nrn_state _nrn_state__VecStim
#define _net_receive _net_receive__VecStim 
#define element element__VecStim 
#define play play__VecStim 
#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 delay _p[0]
#define index _p[1]
#define etime _p[2]
#define space _p[3]
#define _tsav _p[4]
#define _nd_area  *_ppvar[0]._pval
#if MAC
#if !defined(v)
#define v _mlhv
#if !defined(h)
#define h _mlhh
#if defined(__cplusplus)
extern "C" {
 static int hoc_nrnpointerindex =  -1;
 /* external NEURON variables */
 /* declaration of user functions */
 static double _hoc_element();
 static double _hoc_play();
 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;
 /* connect user functions to hoc names */
 static VoidFunc hoc_intfunc[] = {
 static Member_func _member_func[] = {
 "loc", _hoc_loc_pnt,
 "has_loc", _hoc_has_loc,
 "get_loc", _hoc_get_loc_pnt,
 "element", _hoc_element,
 "play", _hoc_play,
 0, 0
 /* declare global and static user variables */
 /* some parameters have upper and lower limits */
 static HocParmLimits _hoc_parm_limits[] = {
 static HocParmUnits _hoc_parm_units[] = {
 static double v = 0;
 /* connect global user variables to hoc */
 static DoubScal hoc_scdoub[] = {
 static DoubVec hoc_vdoub[] = {
 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; {
 /* connect range variables in _p that hoc is supposed to know about */
 static const char *_mechanism[] = {
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;
 	_p = nrn_prop_data_alloc(_mechtype, 5, _prop);
 	/*initialize range parameters*/
 	_prop->param = _p;
 	_prop->param_size = 5;
  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 _vecstim_reg() {
	int _vectorized = 0;
 	_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, 5, 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);
 pnt_receive[_mechtype] = _net_receive;
 pnt_receive_size[_mechtype] = 1;
 	hoc_register_var(hoc_scdoub, hoc_vdoub, hoc_intfunc);
 	ivoc_help("help ?1 VecStim /Users/Penny/Dropbox/ModelDB/mod/x86_64/vecstim.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 element();
static int play();
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  == 1.0 ) {
     net_event ( _pnt, t ) ;
     element ( _threadargs_ ) ;
     if ( index > 0.0 ) {
       artcell_net_send ( _tqitem, _args, _pnt, t +  delay + etime - t , 1.0 ) ;
   } }
extern double* vector_vec();
extern int vector_capacity();
extern void* vector_arg();
static int  element (  ) {

  { void* vv; int i, size; double* px;
	i = (int)index;
	if (i >= 0) {
		vv = *((void**)(&space));
		if (vv) {
			size = vector_capacity(vv);
			px = vector_vec(vv);
			if (i < size) {
				etime = px[i];
				index += 1.;
				index = -1.;
			index = -1.;
  return 0; }
static double _hoc_element(void* _vptr) {
 double _r;
 _r = 1.;
 element (  );
static int  play (  ) {
	void** vv;
	vv = (void**)(&space);
	*vv = (void*)0;
	if (ifarg(1)) {
		*vv = vector_arg(1);
  return 0; }
static double _hoc_play(void* _vptr) {
 double _r;
 _r = 1.;
 play (  );

static void initmodel() {
  int _i; double _save;_ninits++;
   index = 0.0 ;
   element ( _threadargs_ ) ;
   if ( index > 0.0 ) {
     artcell_net_send ( _tqitem, (double*)0, _ppvar[1]._pvoid, t +  delay + etime - t , 1.0 ) ;


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

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;
    _ni = _ml->_nodeindices;
_cntml = _ml->_nodecount;
for (_iml = 0; _iml < _cntml; ++_iml) {
 _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml];
 _nd = _ml->_nodelist[_iml];


static void terminal(){}

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

Loading data, please wait...