High frequency oscillations in a hippocampal computational model (Stacey et al. 2009)

 Download zip file   Auto-launch 
Help downloading and running models
"... Using a physiological computer model of hippocampus, we investigate random synaptic activity (noise) as a potential initiator of HFOs (high-frequency oscillations). We explore parameters necessary to produce these oscillations and quantify the response using the tools of stochastic resonance (SR) and coherence resonance (CR). ... Our results show that, under normal coupling conditions, synaptic noise was able to produce gamma (30–100 Hz) frequency oscillations. Synaptic noise generated HFOs in the ripple range (100–200 Hz) when the network had parameters similar to pathological findings in epilepsy: increased gap junctions or recurrent synaptic connections, loss of inhibitory interneurons such as basket cells, and increased synaptic noise. ... We propose that increased synaptic noise and physiological coupling mechanisms are sufficient to generate gamma oscillations and that pathologic changes in noise and coupling similar to those in epilepsy can produce abnormal ripples."
1 . Stacey WC, Lazarewicz MT, Litt B (2009) Synaptic noise and physiological coupling generate high-frequency oscillations in a hippocampal computational model. J Neurophysiol 102:2342-57 [PubMed]
Citations  Citation Browser
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism: Hippocampus;
Cell Type(s): Hippocampus CA1 pyramidal GLU cell; Hippocampus CA3 pyramidal GLU cell; Hippocampus CA1 interneuron oriens alveus GABA cell; Hippocampus CA1 basket cell;
Channel(s): I Na,t; I A; I K; I h;
Gap Junctions: Gap junctions;
Receptor(s): GabaA; AMPA; NMDA;
Simulation Environment: NEURON;
Model Concept(s): Oscillations;
Implementer(s): Lazarewicz, Maciej [mlazarew at gmu.edu]; Stacey, William [wstacey at med.umich.edu];
Search NeuronDB for information about:  Hippocampus CA1 pyramidal GLU cell; Hippocampus CA3 pyramidal GLU cell; Hippocampus CA1 interneuron oriens alveus GABA cell; GabaA; AMPA; NMDA; I Na,t; I A; I K; I h;
SR and CR net: HFOs in Hippocampus Model README file

This model creates the 100-cell hippocampal model in:

Stacey WC, Lazarewicz MT, and Litt B. Synaptic Noise and Physiological
Coupling Generate High Frequency Oscillations in a Hippocampal
Computational Model.  Journal of neurophysiology 102: 2342-2357, 2009.

To run the simulation

1. Should be run in the normal (serial) installation of NEURON 6.1 or
above.  Most of the code is actually written for parallel
implementation, but several functions were added that are not able to
run in parallel.

2. Unpack the zip file, keeping the file structure intact (see below)

3. Compile the nrnmech file within the \mod directory according to
your system's requirements.  Move the nrnmech file to the root

4. Run netrun.hoc.

5. Currently the network creates the three files demonstrated in
Fig. 5A.  Other specific parameters to simulate different conditions
need to be set as follows :

        within netrun.hoc

                Tstop           length of simulation in ms
                pyrthr          the threshold to which the random
                                number (0-100) is compared.  rnd >
                                pyrthr will create a noise event
                basketthr       same as above for synapses to basket
                gapstyle        whenever you alter the files in
                                \parameters, change this number and
                                record what the changes were
                sigfreq                frequency of periodic signal.  Will
                                have to be placed with 
                                pr.signalSynapse(Tstop, 0, sigfreq, 
                                cell#that_receives_stim).  Cells 
                                0-80 are the pyramidal cells
        within \parameters\conn.dat

                this file lists all synaptic and gap junctional
                connections, based on the parameters of synapses.par
                the current conn.dat has the full feedback network of
                pyr - basket - pyr connections described.  It also has
                gap junctions between the basket cells (but these are
                currently "turned off" because the conductance is 0 in
                synapses.par) there are several additional conn.dat
                files in the attached folder.  These simply need to be
                moved to the \parameters directory and renamed

                Here the gmax of the synapses is changed.  For Figure
                5B, the "5.5" in the "Bask, Pyr" line was changed to
                various levels. NOTE: that due to scaling, this gmax
                is divided by 20 in the network, thus "5.5" is
                actually 0.275 nS I did not change the amplitude of
                any other "synapses" (noise was altered by rate of
                firing, not amplitude) The gap junctions at the end
                have altered gmax in the same fashion.  In this case
                there is no scaling, and the gmax's indicated are what
                are reported.


Program run in the root directory, and calls files in several branched
directories as listed below.  The program is run from a batch file
that saves several parameters into the file names

Note that the program was originally written in parallel format, and
is based on legacy code written by Maciej Lazarewicz that was some of
the first parallel code used in NEURON, before the parallel version
was out of alpha.  There have been many modifications since then, some
of which do not work in parallel.  It is for this reason that the gap
junctions were done with the parallel format directly in the TGnet.tem
rather than the pointer method.

Unfortunately, the parallel idiom, which is slightly different even
than the current standard parallel idiom, can make this code difficult
to follow.  Because of several reasons, this code is not ready for
parallel implementation.  However, it is an excellent candidate for
the "bulletin board" style parallel that is currently being developed.

root folders:

                ****TGnet.tem  //main program to build the network and
                    generate stimuli and noise 
                ****PYRkop.tem //template for the pyramidal cells 
                ****Bwb.tem    //template for basket cells
                Ok.tem         // Okn cells not used
                several others //not used

                has all the channels, synapses, and gap(not used) .mod

                // this folder is where the connectivity and
                conductance values are changed for different runs has
                .dat and .par files that contain the parameters that
                will be read in These files must be manually altered
                to change the parameters.  I used the parameter
                "gapstyle" in the netrun.hoc to indicate which
                parameter set I had used for gmax's (had to keep track
                of this separately" also have .tem files for cells and

                //not used
                // all data saved here.  Each run creates a different
                filename to be saved

The main folder has the .hoc executable (there are many different
versions, all variations of below)
          *****netrun.hoc   //main .hoc file
                loads in /templates/TGnet.tem
                sets many flags and parameters
                DoRun() is the main executable

                        pr = new TGnet() //from template folder which
                                contains all functions in TGnet.tem,
                                as well as having .pnm. class
                        pr.activeSynapsesRandom(.....)  generates
                                random synaptic events in all the
                        pr.signalSynapse(....)  adds a periodic input
                                to a specific pyramidal cell
                        writes files per flags

                I make runs of files by changing parameters then
                calling DoRun(), over and over

Note that, although written in pnm.pc format, I have never compiled
NEURON that way--I've just run it in basic serial format.