Mitral cell activity gating by respiration and inhibition in an olfactory bulb NN (Short et al 2016)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:183300
To explore interactions between respiration, inhibition, and olfaction, experiments using light to active channel rhodopsin in sensory neurons expressing Olfactory Marker Protein were performed in mice and modeled in silico. This archive contains NEURON models that were run on parallel computers to explore the interactions between varying strengths of respiratory activity and olfactory sensory neuron input and the roles of periglomerular, granule, and external tufted cells in shaping mitral cell responses.
Reference:
1 . Short SM, Morse TM, McTavish TS, Shepherd GM, Verhagen JV (2016) Respiration Gates Sensory Input Responses in the Mitral Cell Layer of the Olfactory Bulb. PLoS One 11:e0168356 [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 GLU cell; Olfactory bulb main interneuron periglomerular GABA cell; Olfactory bulb main interneuron granule MC GABA cell; Olfactory bulb main tufted cell external;
Channel(s):
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: NEURON;
Model Concept(s): Activity Patterns; Sensory processing; Sensory coding; Bursting; Oscillations; Olfaction;
Implementer(s): Morse, Tom [Tom.Morse at Yale.edu];
Search NeuronDB for information about:  Olfactory bulb main mitral GLU cell; Olfactory bulb main interneuron periglomerular GABA cell; Olfactory bulb main interneuron granule MC GABA cell;
Files displayed below are from the implementation
: thetastim.mod derived from:
: $Id: netstim.mod 2212 2008-09-08 14:32:26Z hines $
: comments at end

NEURON	{ 
  ARTIFICIAL_CELL ThetaStim_reject
  RANGE outer_interval, outer_number, outer_start
  RANGE outer_noise
  RANGE interval, number, start
  RANGE noise
  THREADSAFE : only true if every instance has its own distinct Random
  POINTER donotuse
}

PARAMETER {
	outer_interval	= 1000 (ms) <1e-9,1e9>: time between spikes (msec)
	outer_number	= 10 <0,1e9>	: number of spikes (independent of noise)
	outer_start		= 50 (ms)	: start of first spike
	outer_noise		= 0 <0,1>	: amount of randomness (0.0 - 1.0)
	interval	= 10 (ms) <1e-9,1e9>: time between spikes (msec)
	number	= 10 <0,1e9>	: number of spikes (independent of noise)
:	start		= 50 (ms)	: start of first spike
	noise		= 0 <0,1>	: amount of randomness (0.0 - 1.0)
}

ASSIGNED {
	outer_event (ms)
	outer_on
	outer_ispike
	event (ms)
	on
	ispike
	donotuse
        : note that outer_start is a parameter (not assigned during integration)
        start : start used to be a parameter however now gets assigned        
}

PROCEDURE seed(x) {
	set_seed(x)
}

INITIAL {
	on = 0 : off
	ispike = 0
	if (outer_noise < 0) {
		outer_noise = 0
	}
	if (outer_noise > 1) {
		outer_noise = 1
	}
	if (noise < 0) {
		noise = 0
	}
	if (noise > 1) {
		noise = 1
	}
	if ((outer_start >= 0 && outer_number > 0) && (number > 0)) {
		outer_on = 1
		: randomize the first spike so on average it occurs at
		: start + noise*interval
		outer_event = outer_start + invl(outer_interval) - outer_interval*(1. - outer_noise)
		: but not earlier than 0
		if (outer_event < 0) {
			event = 0
		}
		net_send(outer_event, 4) // flag=4 starts a net_send to send flag=3 to start the spikes
	}
}	

PROCEDURE outer_init_sequence(t(ms)) {
	if (outer_number > 0) {
		outer_on = 1
		outer_event = 0
		outer_ispike = 0
	}
}

PROCEDURE init_sequence(t(ms)) {
	if (number > 0) {
		on = 1
		event = 0
		ispike = 0
	}
}

FUNCTION invl(mean (ms)) (ms) {
	if (mean <= 0.) {
		mean = .01 (ms) : I would worry if it were 0.
	}
	if (noise == 0) {
		invl = mean
	}else{
		invl = (1. - noise)*mean + noise*mean*erand()
	}
}
VERBATIM
double nrn_random_pick(void* r);
void* nrn_random_arg(int argpos);
ENDVERBATIM

FUNCTION erand() {
VERBATIM
	if (_p_donotuse) {
		/*
		:Supports separate independent but reproducible streams for
		: each instance. However, the corresponding hoc Random
		: distribution MUST be set to Random.negexp(1)
		*/
		_lerand = nrn_random_pick(_p_donotuse);
	}else{
		/* only can be used in main thread */
		if (_nt != nrn_threads) {
hoc_execerror("multithread random in ThetaStim"," only via hoc Random");
		}
ENDVERBATIM
		: the old standby. Cannot use if reproducible parallel sim
		: independent of nhost or which host this instance is on
		: is desired, since each instance on this cpu draws from
		: the same stream
		erand = exprand(1)
VERBATIM
	}
ENDVERBATIM
}

PROCEDURE noiseFromRandom() {
VERBATIM
 {
	void** pv = (void**)(&_p_donotuse);
	if (ifarg(1)) {
		*pv = nrn_random_arg(1);
	}else{
		*pv = (void*)0;
	}
 }
ENDVERBATIM
}

PROCEDURE next_invl() {
	if (number > 0) {
		event = invl(interval)
	}
	if (ispike >= number) {
		on = 0
	}
}

NET_RECEIVE (w) {
	if (flag == 0) { : external event
		if (w > 0 && on == 0) { : turn on spike sequence
			: but not if a netsend is on the queue
			init_sequence(t)
			: randomize the first spike so on average it occurs at
			: noise*interval (most likely interval is always 0)
			next_invl()
			event = event - interval*(1. - noise)
			net_send(event, 1)
		}else if (w < 0) { : turn off spiking definitively
			on = 0
		}
	}
	if (flag == 4) { : from INITIAL or outer event
	  if (start >= 0 && number > 0) {
		on = 1
		: randomize the first spike so on average it occurs at
		: start + noise*interval
		event = start + invl(interval) - interval*(1. - noise)
		: but not earlier than 0
		if (event < 0) {
			event = 0
		}
		net_send(event, 3) // flag=4 starts a net_send to send flag=3 to start the spikes
	  }
	}
	if (flag == 3) { : to initialize the inner spikes
		if (on == 1) { : but ignore if turned off by external event
			init_sequence(t)
			net_send(0, 1)
		}
	}
	if (flag == 1 && on == 1) {
		ispike = ispike + 1
		net_event(t)
		next_invl()
		if (on == 1) {
			net_send(event, 1)
		}
	}
}

COMMENT
Presynaptic spike generator
---------------------------

This mechanism has been written to be able to use synapses in a single
neuron receiving various types of presynaptic trains.  This is a "fake"
presynaptic compartment containing a spike generator.  The trains
of spikes can be either periodic or noisy (Poisson-distributed)

Parameters;
   noise: 	between 0 (no noise-periodic) and 1 (fully noisy)
   interval: 	mean time between spikes (ms)
   number: 	number of spikes (independent of noise)

Written by Z. Mainen, modified by A. Destexhe, The Salk Institute

Modified by Michael Hines for use with CVode
The intrinsic bursting parameters have been removed since
generators can stimulate other generators to create complicated bursting
patterns with independent statistics (see below)

Modified by Michael Hines to use logical event style with NET_RECEIVE
This stimulator can also be triggered by an input event.
If the stimulator is in the on==0 state (no net_send events on queue)
 and receives a positive weight
event, then the stimulator changes to the on=1 state and goes through
its entire spike sequence before changing to the on=0 state. During
that time it ignores any positive weight events. If, in an on!=0 state,
the stimulator receives a negative weight event, the stimulator will
change to the on==0 state. In the on==0 state, it will ignore any ariving
net_send events. A change to the on==1 state immediately fires the first spike of
its sequence.

Modified by Tom Morse to be ThetaStim which is essentially two NetStim's
where the outter NetStim triggers the inner NetStim to make what is
traditionally called a theta stimulation (i.e. a stimulation pattern where
a burst of spikes is repeated at regular intervals. An example of this would
be three pulses at 50 Hz (corresponds to a period of 20 ms) repeated every
200 ms (which corresponds to a frequency of 5 Hz): this would be pulses at
t=0, 20, 40, 200, 220, 240, ... ms)

ENDCOMMENT


Loading data, please wait...