Synaptic gating at axonal branches, and sharp-wave ripples with replay (Vladimirov et al. 2013)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:150446
The computational model of in vivo sharp-wave ripples with place cell replay. Excitatory post-synaptic potentials at dendrites gate antidromic spikes arriving from the axonal collateral, and thus determine when the soma and the main axon fire. The model allows synchronous replay of pyramidal cells during sharp-wave ripple event, and the replay is possible in both forward and reverse directions.
Reference:
1 . Vladimirov N, Tu Y, Traub RD (2013) Synaptic gating at axonal branches, and sharp-wave ripples with replay: a simulation study. Eur J Neurosci 38:3435-47 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell; Axon; Dendrite; Connectionist Network;
Brain Region(s)/Organism:
Cell Type(s): Hippocampus CA1 pyramidal GLU cell; Hippocampus CA1 basket cell;
Channel(s): I Na,t; I A; I K; I K,leak; I K,Ca; I Calcium; I Potassium; I_AHP;
Gap Junctions: Gap junctions;
Receptor(s): GabaA; AMPA;
Gene(s):
Transmitter(s): Gaba; Glutamate;
Simulation Environment: NEURON;
Model Concept(s): Action Potential Initiation; Oscillations; Synchronization; Axonal Action Potentials; Place cell/field; Conduction failure; Brain Rhythms;
Implementer(s): Vladimirov, Nikita ;
Search NeuronDB for information about:  Hippocampus CA1 pyramidal GLU cell; GabaA; AMPA; I Na,t; I A; I K; I K,leak; I K,Ca; I Calcium; I Potassium; I_AHP; Gaba; Glutamate;
//  This models shows how a sequence of 5 pyramidal cells may be replayed in FORWARD direction during sharp-wave ripples.
// A network of 9 clusters, each of 9 pyramidal cells (PC) and 1 basket cell (IN). The network demonstrates a replay of 5 PCs,
// which are unidirectionally synaptically connected in a sequence: 0->3->30->33->60 (cell indices).
// The "cue" EPSP applied to PC(0) initiates the replay sequence.
// All 81 PCs are connected into an axonal plexus by gap junctions in their proximal collaterals. 
// The collaterals are stimulated at random, once per stim_interval_percell=20 ms on average.
// Please be patient, simulation may take a few hours, because of the fine spatial discretization of the axons.
// author: Nikita Vladimirov, PhD <nikita.vladimirov@gmail.com>

load_file("nrngui.hoc")
load_file("template_PC.hoc")
load_file("template_IN.hoc")
load_file("gap_collat.hoc")
// size of clusters:
W_neighborhood = 3
H_neighborhood = 3
// overall size of the network of pyramidal cells
Nx=W_neighborhood*3
Ny=H_neighborhood*3
ncells=Nx*Ny // pyramidal cells total
Nbaskets = 9 // basket cells total
// parameters of axonal plexus:
gj_per_cell = 3
gj_radius_x = gj_radius_y = Nx
gj_pos_min = 0.25
gj_pos_max = 0.75
gj_conductance = 3e-3 //[mcS]
stim_interval_percell = 20 // [ms], mean interstimulus interval, per cell
// random number seeds:
stim_seed = 1 // seed for axonal stimulation times
gj_radius_seed = 2 // seed for connecting gap junctions
gj_pos_seed = 3 // seed for gap junctions on the collateral
// synaptic weights:
wsyn_2PC = 0.005 //CA3->pyr
wsyn_PC2PC = 0.0045 //pyr->pyr
wsyn_PC2IN = 0.0035 //pyr->bask
wsyn_IN2PC = 0.050 //bask->pyr
objref cells, baskets, gaps // cells are pyramidal cells; baskets are the interneurons;
objref PC2PCsynL, PC2INsynL, P2BaskConL, IN2PCsynL, NetConL 
objref Ipulse3L, RandNetStimL, CA3NetStim
NetConL = new List()
PC2PCsynL = new List()
PC2INsynL = new List()
P2BaskConL = new List()
IN2PCsynL = new List()
CA3NetStim = new NetStim()
Ipulse3L = new List()
RandNetStimL = new List()
// coordinates of the extracellular electrode (um):
Ex = (Nx/2)*40 
Ey = 20
Ez = (Ny/2)*40
//////////////////// procedures and functions //////////////////////	
proc mkcells(){ local i localobj pyr
// $1 is the total number of cells
   cells=new List()
   for i=0,$1-1{
    pyr = new pyramidalCA1()
	pyr.geom_nseg() // this is very important after changing geometry
	forsec pyr.axonal { nseg *= 9 }
	pyr.setcurrentbias_soma(-0.05)
	pyr.setcurrentbias_AIS(-0.1)
	cells.append(pyr)
   }
}

proc mkbaskets(){ local i localobj cell_
// $1 is the total number of basket cells
   baskets = new List()
   for i=0,$1-1{
     cell_ = new basket()
	 baskets.append(cell_)
   }
}

proc setpositions(){ local i, x, y, x_index, y_index
  for i=0,cells.count()-1{
	  x_index =i%Nx+1
	  x = (x_index-1)*40
	  y_index =(i+1-x_index)/Nx+1
	  y = (y_index-1)*40
	  cells.object(i).position(x,0,y)
	  cells.object(i).setindexXY(x_index,y_index)
  }
  for i=0,baskets.count()-1 {
	x = (i%3)*40*3 + 40/2
	y = (i-i%3)*40*3 +40/2
	baskets.o(i).position(x,0,y) 
  }
  
}

proc rotateRandOY(){ local i, choices localobj rand
	choices = 4
	rand = new Random()
	rand.discunif( 0, choices - 1 )
	for i=0,cells.count()-1 {
		cells.o(i).rotateOY(2*PI*rand.repick()/choices)
	}
}

obfunc shuffle(){ local n, rand_ind, a localobj rand, shuff
  rand=new Random()
  shuff=new Vector($o1.size(),0)
  for (n=0; n<=$o1.size()-1;n=n+1){
   shuff.x[n]=$o1.x[n]
  }
  for (n=$o1.size(); n>1; n=n-1){
   rand_ind=rand.discunif(0,n-1)
   a=shuff.x[n-1]
   shuff.x[n-1]=shuff.x[rand_ind]
   shuff.x[rand_ind]=a
   }
  return shuff
}

func round() { return int($1+0.5) }

/////////////// Connect the cells into a network by gap junctions ///////////////
proc connect_gj(){ local i, i_gj, icell, xi, yi, xj, yj, n1, n2, attempt, check1, check2, pos1, pos2 localobj cell_gids, cell_gids_shuffled, gap_, stubs, rand2, rand3, gj_table
ngaps=int(ncells*gj_per_cell/2)
stubs=new Vector(ncells+1)// Fortan-style indexing, 1..ncells
gj_table=new Matrix(ngaps+1,2)
rand2=new Random(gj_radius_seed)
rand3=new Random(gj_pos_seed)
rand2.discunif(-gj_radius_x,gj_radius_x)
rand3.uniform(0,1)
stubs.fill(gj_per_cell) //regular
stubs.x[0]=0 // fortran style

gaps=new List()
cell_gids=new Vector(cells.count())
cell_gids.indgen(1,cells.count(),1)
cell_gids_shuffled=shuffle(cell_gids)

i_gj=0
for i=0,cells.count()-1{
  icell=cell_gids_shuffled.x[i]// icell=1..ncells, Fortran style
  xi=cells.object(icell-1).x_index
  yi=cells.object(icell-1).y_index
  while(stubs.x[icell]>0) {
       xj=xi+rand2.repick()
       yj=yi+rand2.repick()
       n1=icell
       n2=Nx*(yj-1)+xj
       attempt=0
	   check1=((xj<1)||(yj<1)||(xj>Nx)||(yj>Ny)||((xj==xi)&&(yj==yi)))
	   if(check1==0){ //if cell is within range, try its free stubs
			check2=(stubs.x[n2]==0)
		}
       while ((check1 || check2) && (attempt<1000)){
	       attempt=attempt+1
           xj=xi+rand2.repick()
           yj=yi+rand2.repick() 
		   n2=Nx*(yj-1)+xj	
	       check1=((xj<1)||(yj<1)||(xj>Nx)||(yj>Ny)||((xj==xi)&&(yj==yi)))
	       if(check1==0){ //if cell is within range, try its free stubs
	       check2=(stubs.x[n2]==0)
	     }
	   }
	   if(attempt<1000 && i_gj<ngaps) {
 	     i_gj=i_gj+1
         gj_table.x[i_gj][0]=n1
         gj_table.x[i_gj][1]=n2
		 pos1 = rand3.uniform(gj_pos_min,gj_pos_max)
		 pos2 = rand3.uniform(gj_pos_min,gj_pos_max)
		 gap_=new gapjunction(cells.object(n1-1),0,cells.object(n2-1),0,gj_conductance,pos1,pos2)
		 gaps.append(gap_)
		 stubs.x[n1]=stubs.x[n1]-1
         stubs.x[n2]=stubs.x[n2]-1
	   } else {
	     stubs.x[icell]=0
	   }
    }
  }
}

func quotent() {
//finds quotent q of a divided by b:
// a = b*q + rem
// $1 is a, $2 is b
return ($1-$1%$2)/$2
}

func ipyramid() { local icol, jrow
//finds the first i of pyramidal cell in cluster of 9 cells
// $1 is the index of basket cell
icol = ($1%W_neighborhood)*W_neighborhood
jrow = quotent($1,H_neighborhood)*H_neighborhood
return jrow*Nx + icol
}

func ipyramids() {
// returns the absolute indices of pyr. neighbors of $1 = 0..8 basket cell, 
// by using relative index of pyr. cell in neighborhood $2 = 0..8
return ipyramid($1) + $2%3 + quotent($2,W_neighborhood)*Nx
}

proc connectPCs_to_IN() { local i,j,j0 localobj syn_, netcon_
	for i = 0, baskets.count()-1 {
			baskets.o(i).soma syn_ = new AlphaSyn(0.5)
			syn_.tau = 0.8 // 0.8, Traub et al 2005, AMPA pyr->FS
			for j0 = 0, 8 { //run thru all pyrs in the neighborhood
				j = ipyramids(i,j0) 
				cells.o(j).collat[1] netcon_ = new NetCon(&v(1),syn_)
				netcon_.weight = wsyn_PC2IN
				netcon_.delay = 1
				P2BaskConL.append(netcon_)
				PC2INsynL.append(syn_)
			}
			}
}

proc connectIN_to_PCs() { local j localobj syn_, netcon_
		for i = 0, baskets.count()-1 {
			for j0 = 0, 8 { //run thru all pyrs in the neighborhood
			j = ipyramids(i,j0) //retrieve pyr's gloal index
			cells.o(j).soma syn_ = new Exp2Syn(0.5)
			syn_.tau1 = 2
			syn_.tau2 = 5
			syn_.e = -75
			baskets.o(i).soma netcon_ = new NetCon(&v(1),syn_)
			netcon_.weight = wsyn_IN2PC
			netcon_.delay = 1
			NetConL.append(netcon_)
			IN2PCsynL.append(syn_)
			}
		}
}

proc connectPC_to_PC() { local i localobj syn_, netcon_
// $1 is pre-synaptic, $2 is post-synaptic cell
		 cells.o($2).basal[4] syn_=new AlphaSyn(0.5)
		 syn_.tau = 2 //ms
		 cells.o($1).collat[1] netcon_ = new NetCon(&v(1),syn_)
		 netcon_.weight = $3
		 netcon_.delay = 1
		 PC2PCsynL.append(syn_)
		 NetConL.append(netcon_)
}

proc cueEPSP() { local i localobj syn, netcon
		CA3NetStim.interval = 200
		CA3NetStim.number = 1 // 
		CA3NetStim.start = 20
		CA3NetStim.noise = 0 // 0 for deterministic, 1 for negexp
		cells.o(0).shaft syn = new AlphaSyn(0.5)
		syn.tau = 2
		netcon = new NetCon(CA3NetStim,syn)
		netcon.weight = wsyn_2PC
		netcon.delay = 1
		PC2PCsynL.append(syn)
		NetConL.append(netcon)
}

proc stim_all_collat_random() { local i localobj pulse_, netstim_, netcon_
 for i = 0, cells.count()-1 {
	cells.o(i).collat {
		pulse_ = new Ipulse3(0.9)
		pulse_.dur = 1
		pulse_.amp = 0.05
		netstim_ = new NetStim()
		netstim_.interval = stim_interval_percell
		netstim_.number = 1e9 // essentially unlimited
		netstim_.start = 5
		netstim_.noise = 1 // 0 for deterministic, 1 for negexp
		netstim_.seed(i+stim_seed)
		netcon_ = new NetCon(netstim_,pulse_)
		netcon_.threshold = 0
		netcon_.weight = 1
		netcon_.delay = 0
		Ipulse3L.append(pulse_)
		RandNetStimL.append(netstim_)
		NetConL.append(netcon_)
		}
 }
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////   execution   /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////

mkcells(Nx*Ny)
mkbaskets(Nbaskets)
setpositions()
rotateRandOY()
connect_gj()
connectPCs_to_IN()
connectIN_to_PCs()
cueEPSP()
connectPC_to_PC(0,3,wsyn_PC2PC) 
connectPC_to_PC(3,30,wsyn_PC2PC) 
connectPC_to_PC(30,33,wsyn_PC2PC) 
connectPC_to_PC(33,60,wsyn_PC2PC) 
stim_all_collat_random()

load_file("LFP.hoc")
load_file("81PC_9IN.ses")

Loading data, please wait...