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]
Citations  Citation Browser
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
/
ShortEtAl2016
early_theta_version
event_generator
import
py
run_0
run_1
run_10
run_11
run_12
run_13
run_14
run_15
run_16
run_17
run_2
run_3
run_4
run_5
run_6
run_7
run_8
run_9
run_test
saved_sim_makers
spike_output
stimulation
synaptic_activity
tdt2mat_data
tmp
VecStim
readme.html
readme.louise
readme.NSG
readme.specialcase.txt
ampanmda.mod *
cadecay.mod *
cadecay2.mod *
Caint.mod *
Can.mod *
CaPN.mod *
CaT.mod *
fi.mod
GradeAMPA.mod *
GradeGABA.mod *
GradNMDA.mod *
hpg.mod *
Ih.mod *
kamt.mod *
KCa.mod *
kdrmt.mod *
kfasttab.mod *
kM.mod *
KS.mod *
kslowtab.mod *
LCa.mod *
nafast.mod *
NaP.mod *
naxn.mod
Nicotin.mod *
nmdanet.mod *
OdorInput.mod *
thetastim.mod *
ThreshDetect.mod *
vecstim.mod *
batch_run_first_NSG.py
batch_runs.py
batch_runs.py20150708
batch_runs.py20150808gc_error
batch_runs_first_NSG.py
build_net.hoc
build_net_Shep.hoc
build_net_Shep_NSG.hoc
build_net_Shep_NSG20160825.hoc
build_net_SMS.hoc
build_net_theta.hoc
build_net20150312.hoc
build_pg_net.hoc
cell_properties_for_ET_from_standalone.txt
cells_volt_graphs.ses
cells_volt_graphs_pg.ses
create_arrays.py
documentation.txt
et.hoc
et_rig.ses
et_rig2.ses
Et_start.zip
granule.hoc *
graph_fncs.hoc
graph_fncs_pg.hoc
gui_stim.hoc
how_to_run_pre_init_on_mac.txt
inhib_study.eps
inhib_study.ps
init.hoc
init.py
make_lookup_table.sh
makelib.err
makelib.out
mct_cells.hoc
mitral.hoc
mosinit.hoc
nrnivmodl.out
num_of_columns.hoc
PG_def.hoc
pre_init.py
pre_init_first_NSG.py
pre_init_no_changes_in_weights.py
roberts_python_help.txt
run_on_serial.hoc
runcntrl.ses
sample_gc1_v_graph.ses
sample_mitral_pg_space_plots.ses
screenshot.png
screenshot0.png
tdt2mat_data.hoc
temporary_file.tmp
test_matplotlib.hoc
                            
This is the readme for configuring and running simple circuit
simulations on the NSG for the manuscript under preparation

Short et al. 2015

To configure the simulation to run edit these files in 1) and 2) and
then follow step 3) etc.:

1) create_arrays.py: first edit create_arrays.py to assign values of
the breathing (B) and light-stimulated (S) event peak rates and also
the number of additional columns (add_columns python list). The
"additional" refers to that there is always one glomerular column
containing the mitral cell which has its voltage recorded analagous to
the wetlab experiments.

2) pre_init.py: The basic idea with pre_init.py is that it creates two
python lists "parameters", and "columns", each of length equal to the
number of simulations.  By copying verbatim corresponding elements of
these lists, a parameter.hoc and a num_of_columns.hoc file is written
in each simulation folder run_X, where X=1,2,3, ...,
number_of_simulations.  For example: the run_0 folder gets a
parameter.hoc file assigned from parameters[0] and num_of_columns.hoc
file from columns[0]. The number of simulations is figured out
automatically by taking the create_arrays data into consideration with
a net_type list: Set the net_type list (found near the top of this
program) to something like

net_type=['full_net','pg_net','gc_net']

These variables will trigger network simulations with these types
being created, with each of these network types having the commands to
make them present in the parameters.hoc file.  (See the code that
creates "parameters" elements with an append and then modifies these with
indexed assignments).

Also edit the lines in the parameters.append(""" section which will
look something like:

breath_peak_rate = %d
light1_peak_rate = 0
light2_peak_rate = %d

so that the second %d is either on light1 or light2 depending on
whether you want the light stimulation (S) to fall either on the
primary column being recorded from (light1) or adjacent column(s)
(light2).

3) Run pre_init.py by typing ./pre_init.py on the command line.  run_X
simulation folders will be created.  See what the highest number of
the X is. This is one less than the number of simulations since X
starts at 0.  Check that this number of simulations is present in the
line in init.py that checks id's, for example:

if id<2888:

(This checking is present because there is no gaurentee that you can
ask for the same number of processors (nodes*cores_per_node) as there
number of simulations.)

4) zip the folder containing all these files into an input file for
the NSG.

5) Sign onto the NSG and follow the directions in its help to create a
data folder containing the input file created in step 4) and a task
folder where you select NEURON with Python on a machine that contains
at least as many processors as there are number of simulations as
determined in step 3) (probably stampede which note has 16 cores per
node).  Set the number of nodes to be such that the number of nodes
times the number of cores per node is the smallest number greater than
the number of simulations (there will be left over processors with nothing to do).

6) save and run the task!