Lateral dendrodenditic inhibition in the Olfactory Bulb (David et al. 2008)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:116094
Mitral cells, the principal output neurons of the olfactory bulb, receive direct synaptic activation from primary sensory neurons. Shunting inhibitory inputs delivered by granule cell interneurons onto mitral cell lateral dendrites are believed to influence spike timing and underlie coordinated field potential oscillations. Lateral dendritic shunt conductances delayed spiking to a degree dependent on both their electrotonic distance and phase of onset. Recurrent inhibition significantly narrowed the distribution of mitral cell spike times, illustrating a tendency towards coordinated synchronous activity. This result suggests an essential role for early mechanisms of temporal coordination in olfaction. The model was adapted from Davison et al, 2003, but include additional noise mechanisms, long lateral dendrite, and specific synaptic point processes.
Reference:
1 . David F, Linster C, Cleland TA (2008) Lateral dendritic shunt inhibition can regularize mitral cell spike patterning. J Comput Neurosci 25:25-38 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network; Neuron or other electrically excitable cell;
Brain Region(s)/Organism: Olfactory bulb;
Cell Type(s): Olfactory bulb main mitral cell; Olfactory bulb main interneuron granule MC cell;
Channel(s): I Na,t; I L high threshold; I A; I K; I K,Ca;
Gap Junctions:
Receptor(s): GabaA; AMPA;
Gene(s):
Transmitter(s):
Simulation Environment: NEURON; MATLAB;
Model Concept(s): Temporal Pattern Generation; Synchronization; Simplified Models; Active Dendrites; Olfaction;
Implementer(s):
Search NeuronDB for information about:  Olfactory bulb main mitral cell; Olfactory bulb main interneuron granule MC cell; GabaA; AMPA; I Na,t; I L high threshold; I A; I K; I K,Ca;
/
DendroDendriticInhibition
ShortDendrite
cadecay.mod *
currentGauss.mod
flushf.mod *
GradGABAa.mod
ipscGauss.mod
kA.mod *
kca.mod *
kfasttab.mod *
kM.mod *
kslowtab.mod *
lcafixed.mod *
nafast.mod *
nagran.mod *
shuntInhib.mod *
stim2.mod
bulb.hoc
experiment_fig1cde.hoc
experiment_fig1fg.hoc
experiment_fig2bdf.hoc
experiment_fig3.hoc
experiment_fig4.hoc
experiment_fig5.hoc
experiment_fig6.hoc
fig1cde.ses
fig1fg.ses
fig2bdf.ses
fig3.ses
fig4.ses
fig5.ses
fig6.ses
figure1cde.m
figure1fg.m
figure2bdf.m
figure3.m
figure4abcd.m
figure4ef.m
figure5.m
figure6.asv
figure6.m
fit_ML_normal.m
granule.tem
init.hoc
mathslib.hoc *
mitral.tem
mosinit.hoc *
parameters_fig1cde.hoc
parameters_fig1fg.hoc
parameters_fig2bdf.hoc
parameters_fig3.hoc
parameters_fig4.hoc
parameters_fig5.hoc
parameters_fig6.hoc
plot_normal.m
tabchannels.dat *
tabchannels.hoc
                            
TITLE Internal and synaptic noise


: Include internal noisy channels with density form
: With cut off frequency

: in=-norm(mean,std)

: written by Francois David and Yi Zhou 2005


INDEPENDENT {t FROM 0 TO 1 WITH 1 (ms)}

NEURON {
	POINT_PROCESS  current_gauss
	
	NONSPECIFIC_CURRENT  in  : negative current depolarizes the membrane
	RANGE del,dur
        
	RANGE in
	RANGE rand
	RANGE mean, std0, std
	RANGE f0  : the sampling frequency
	RANGE N_smooth : =1000/f0/dt
	RANGE count
	RANGE noise_seed
	RANGE tau_f	
	RANGE indic_max,indic_sim,indic_kern
}

UNITS {
	(nA) = (nanoamp)
	(mV) = (millivolt)
}

PARAMETER {
	del=0 (ms)
	dur=100 (ms) <0,1e9>
	dt    = 0.01 (ms) 
	mean=0         (nA)  : default
	std0=1e-4       (nA)  : default
	std=1e-4
	noise_seed = 1
    
	f0=4000   (1/s)   : default 4000Hz
	tau_f = 5 (ms)    : low pass filter
	t_kern = 20 (ms)  : length of filter
	t_sim = 1000 (ms) : length of stimulus 
}

ASSIGNED {
	v      (mV)

	in	(nA)
	in_temp	(nA)
	rand
	count
        N_smooth
	noise[29000]
	filter[1000]
	current[28000]
	indic_kern
	indic_sim
	indic_max
	uu

	current_total
	noise_total
	current_mean
	noise_mean
	current_var
	noise_var
	power_ratio
}

PROCEDURE seed(x) {
	set_seed(x)
}
 
LOCAL u,w

BREAKPOINT {

	if (t<del+dur-.1 && t>=del) {
		if(count/N_smooth==1){
			in = -current[uu]
			uu=uu+1
			count = 0
		}else{
			count = count+1
                        
		}
	} else {
	  in=0 
		:printf("uu=%g\n",uu)
	}
:printf("count=%g\n",count)
}

INITIAL {

	N_smooth=floor(1000/f0/dt)*2  : break point called twice,here 1000 is a scalar

		:### equalize the power of the sampled white noise2
		:### std_a/std_b=sqrt(f_a/f_b) with f_a=4000 and std0=std_a : see notebook p186

	std=std0/sqrt(4000/f0)  
        	:###note that for Wiener process should be std_a/std_b=sqrt(f_b/f_a)
	
	rand = normrand(mean, std)
	in  = -rand

	count=0
	uu=0
	w =0
	u = 0
 	power_ratio = 0

	indic_kern = t_kern*f0/1000
	indic_sim = dur*f0/1000
	indic_max = indic_sim+indic_kern  : useful for the the convolution product

	FROM u=0 TO indic_kern-1 {
        	filter[u] = exp(-u*(1000/f0)/tau_f)
	}

	FROM u=0 TO indic_max-1 {
		noise[u] = normrand(mean, std)
	}

	FROM u=0 TO indic_sim-1 {
		current[u] = 0
		FROM w=0 TO indic_kern-1 {
			current[u] = current[u] + noise[w+u] * filter[indic_kern-w-1] 
		}
	}

	current_total=0
	noise_total=0

	FROM u=0 TO indic_sim-1 {
		current_total = current_total + current[u]
		noise_total   = noise_total + noise[u]
	}

	current_mean = current_total/(dur*f0/1000)
	noise_mean = noise_total/(dur*f0/1000)
	printf("current_mean= %g\n",current_mean)
	printf("noise_mean= %g\n",noise_mean)


	current_var=0
	noise_var = 0
	FROM u=0 TO indic_sim-1 {
		current_var = current_var + pow(current[u]-current_mean,2)
		noise_var = noise_var + pow(noise[u]-noise_mean,2)
	}
	current_var = current_var/(dur*f0/1000)
	noise_var = noise_var/(dur*f0/1000)

	:printf("current_var1= %g\n",current_var)
	:printf("noise_var1= %g\n",noise_var)
	power_ratio = current_var/noise_var
	:printf("power_ratio= %g\n",power_ratio)

	:Normalization
	FROM u=0 TO indic_sim-1 {
		current[u] = (current[u]-current_mean+noise_mean)/sqrt(current_var/noise_var)
	}
	count = 0

	:OPTIONS -Checking
	:	current_total=0
	:	noise_total=0
	:	FROM u=0 TO indic_sim-1 {
	:		current_total = current_total + current[u]
	:		noise_total   = noise_total + noise[u]
	:	}
	:	current_mean = current_total/(dur*f0/1000)
	:	noise_mean = noise_total/(dur*f0/1000)
	:	printf("current_mean= %g\n",current_mean)
	:	printf("noise_mean= %g\n",noise_mean)
	:	current_var=0
	:	noise_var = 0
	:	FROM u=0 TO indic_sim-1 {
	:		current_var =current_var+ pow(current[u]-current_mean,2)
	:		noise_var = noise_var+pow(noise[u]-noise_mean,2)
	:	}
	:	current_var = current_var/(dur*f0/1000)
	:	noise_var = noise_var/(dur*f0/1000)
	:	printf("current_var2= %g\n",current_var)

	:	printf("noise_var2= %g\n\n",noise_var)
	:	power_ratio = current_var/noise_var
	:	printf("power_ratio2= %g\n",power_ratio)
}

UNITSON

Loading data, please wait...