Auditory cortex layer IV network model (Beeman 2013)

 Download zip file 
Help downloading and running models
"... The primary objective of this modeling study was to determine the effects of axonal conduction velocity (often neglected, but significant), as well as synaptic time constants, on the ability of such a network to create and propagate cortical waves. ... The model is also being used to study the interaction between single and two-tone input and normal background activity, and the effects of synaptic depression from thalamic inputs. The simulation scripts have the additional purpose of serving as tutorial examples for the construction of cortical networks with GENESIS. The present model has fostered the development of the G-3 Python network analysis and visualization tools used in this study... It is my hope that this short tutorial and the example simulation scripts can provide a head start for a graduate student or postdoc who is beginning a cortical modeling project. "
1 . Beeman D (2013) A modeling study of cortical waves in primary auditory cortex BMC Neuroscience 14(Supl 1):P23
Citations  Citation Browser
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism: Auditory cortex;
Cell Type(s): Neocortex L5/6 pyramidal GLU cell; Neocortex V1 interneuron basket PV GABA cell;
Gap Junctions:
Simulation Environment: GENESIS;
Model Concept(s): Activity Patterns; Tutorial/Teaching;
Implementer(s): Beeman, Dave;
Search NeuronDB for information about:  Neocortex L5/6 pyramidal GLU cell; Neocortex V1 interneuron basket PV GABA cell;
// basic_inputs.g - used by ACnet2-batch.g
// stripped down MGBv_input-simple.g -  an array of pulsed spiketrains is used for the inputs.

str input_source = "/MGBv" // Name of the array of input elements

/* The following global variables are defined in the ACnet network script:

   int Ninputs // number of auditory inputs
   // approx 1 mm/octave - gives integer rows/octave
   float octave_distance = 0.96e-3
   float Ex_SEP_Y // separation between rows of Ex cells
   int input_spread // input to row_num +/- input_spread

   float spike_jitter = 0.0005 // 0.5 msec jitter in thalamic inputs
       or spike_jitter = 0.0

   float input_delay = 0.0	 // seconds
   float input_jitter = 0.0

   str input_type // "pulsed_spiketrain", "pulsed_randomspike", "MGBv"
   str input_pattern  // == "row", "line", "box", "MGBv"

   Some versions require Ex_SEP_X, Inh_SEP_X, Inh_SEP_Y

   This basic version does not use all of the above options.

// Pulsed spike generator -- for constant input, use pulsewidth >= tmax
float pulse_width =  0.05    // width of pulse
float pulse_delay = 0.05        // delay before start of pulse
float pulse_interval = 0.15 // time from start of pulse to next (period)
float spikefreq = 220          // just to initialize the dialog

/* Default input conduction delay and jitter - the many targets of a single
   MGBv cell will receive a spike with delay ranging from
   input_delay*(1 - input_jitter) to input_delay*(1 + input_jitter)

   This may be used to reduce the correlation between the inputs to the
   target rows.


//      Function Definitions

/* Functions to create the MGBv cells that will provide the inputs 
   In this case the "cells" are spikegens controlled by pulsegens

function make_MGBvcell(path)
    str path
    // The full MGBvcell model would have  MGBvcell parameters here

    // Pulsed spike generator -- for constant input, use pulsewidth >= tmax
    // these will get changed
    float pulse_width = {tmax}     // width of pulse
    float pulse_delay = 0          // delay before start of pulse
    float pulse_interval = {tmax}  // interval before next pulse
    float spikefreq = 110 // Hz.   // initial value of frequency

    // This parameter is used for the full MGBvcell model
    // float spike_weight = 8

    /* Create the basic cell as a container for the pulsegen and spikegen */
    create neutral {path}
    // add fields to keep the target row, frequency and weight
    addfield {path} input_row
    setfield {path} input_row 0 // just to initialize it
    addfield {path} dest_row
    setfield {path} dest_row 0 // just to initialize it
    addfield {path} input_freq
    setfield {path} input_freq {spikefreq}
    addfield {path} output_weight
    setfield {path} output_weight 1.0

    create pulsegen {path}/spikepulse // Make a periodic pulse to control spikes

        // create a spikegen with a refractory period = 1/freq
        create spikegen {path}/spikepulse/spike
        setfield {path}/spikepulse/spike thresh 0.5
        setfield {path}/spikepulse width1 {pulse_width} delay1 {pulse_delay}  \
          baselevel 0.0 trig_mode 0 delay2 {pulse_interval - pulse_delay} width2 0
        setfield {path}/spikepulse/spike abs_refract {1.0/spikefreq}
        addmsg {path}/spikepulse {path}/spikepulse/spike INPUT output
end // function make_MGBvcell

 function set_input_freq(cell, input_freq)
    str cell; float freq, input_freq
    setfield {cell} input_freq {input_freq}
    freq = input_freq
    if ({input_freq} > 1000)
        freq = 1000
    float abs_refract = 1e6 // A very low frequency
    if ({freq} > 1.0e-6)
       abs_refract = 1.0/freq
        setfield {cell}/spikepulse/spike abs_refract {abs_refract}
end // set_input_freq(cell, freq)

// Set parameters for spike train pulses
function set_pulse_params(input_num, frequency, delay, width, interval)
    int input_num
    float frequency, delay, width, interval, abs_refract
    setfield {input_source}[{input_num}]/spikepulse width1 {width} delay1 \
        {delay} baselevel 0.0 trig_mode 0 delay2 {interval - delay} width2 0
    // free run mode with very long delay for 2nd pulse (non-repetitive)
    // level1 is set by GUI spiketoggle function, or by a batch mode command
    // set the abs_refract of the spikegen to spike every 1/frequency
    set_input_freq {input_source}[{input_num}] {frequency}

function set_spiketrain_weight(input_num, weight)
    int input_num
    float weight
    setfield {input_source}[{input_num}] output_weight {weight}
    // Now set the weights of all network cell targets (not Inh feedback)
    // The optional 2nd arg for target is useful here
    planarweight {input_source}[{input_num}]/spikepulse/spike  \
        /Ex_layer/{Ex_cell_name}[]/{Ex_drive_synpath} -fixed {weight}
    planarweight {input_source}[{input_num}]/spikepulse/spike  \
        /Inh_layer/{Inh_cell_name}[]/{Inh_drive_synpath} -fixed {weight}

function setall_driveweights(weight)
    int i
    float weight
    for (i=1; i <= {Ninputs}; i=i+1)
        set_spiketrain_weight {i} {weight}

/* Set up the circuitry to provide spike trains to the network */
function make_input_src_dest(input_num, dest_row)
    int input_num, dest_row
    float x0, y0, z0
    // Set the separations of the vertical array of inputs to that of network
    x0 = 0; y0 = dest_row*Ex_SEP_Y; z0 = 0;
    make_MGBvcell {input_source}[{input_num}]
    setfield {input_source}[{input_num}] x {x0} y {y0} z {z0}
    setfield {input_source}[{input_num}] dest_row {dest_row}
end // function make_input_src_dest

/* make_inputs and connect_inputs are the two functions called by ACnet2
   to set up the inputs to the network

// Make array of pulsed inputs ({input_source}[{input_num}]) and initialize
function make_inputs(f0)
    // Special case for ACnet2 default inputs - typically Ninputs = 2
    int first_row = 12
    int row_sep = 24
    int i
    float f0, freq
    f0 = 220.0
    if ({argc} == 1)
        f0 = {argv 1}

    for (i=1; i <= {Ninputs}; i=i+1)
        // This assignment can be changed as needed
        freq = f0*i
        make_input_src_dest {i} {first_row + (i-1)*row_sep}
        set_pulse_params {i} {freq} {pulse_delay} {pulse_width} {pulse_interval}
end // function make_inputs

function connect_inputs
    /* For input_pattern = "row", connections will be made to all
       cells on the specified row.  If input_spread > 0, connections
       with an exponentially decay probablility will be made to
       adjacent rows +/- input_spread.

       For special cases "line" or "box", I want connections from the one
       input channel to go to all cells in a rectangular block defined by
       (Ex_NX0_in, Ex_NY0_in, Ex_NXlen_in, Ex_NYlen_in

       Note that the Inh cells are displaced from Ex by Ex_SEP_X/2,
       Ex_SEP_Y/2, with twice the spacing.

       The x coord of the Ex_cell apical1 compartment (Ex_drive_synpath)
       is displaced from the grid location by -125 um, as it is at the end
       of the oblique apical dendrite.  For the symmetric compartment version
       of the cell, it is at -75 um.

       For "row" input, all cells on the row will be targets, so
       apical1_x_offset is not needed.

       Also, note the that '-relative' option is not used here.

    float apical1_x_offset = -125e-6
    float xmin, ymin, xmax, ymax

    if (input_pattern == "row")
      /* Use code from MGBv_input2-5.g to provide input_spread */
      int i
      float target_y, y, ymin, ymax, prob
      // number of rows below and above "target row" of input spread
      /*  Target rows are numbered 1 through Ninputs, and cell rows are
          numbered 0 through Ex_NY - 1.  The first and last one-third
	  octave of the cell rows do not receive MGBv input, so the cell
	  row number is offset from the input row by input_offset.

          In addition, the y coord of the Ex_cell apical1 compartment
	  (Ex_drive_synpath) is displaced from the grid location by 17 um
	  for the symmetric compartment version of the cell, but not for
	  the asymmetric.

	  basic_inputs.g does not use input_offset, nor have a general
	  mapping between input number, frequency and pulse parameters, and
	  the destination row.
      float apical1_offset = 0.0
      prob = 1.1 // just to be sure that all target row cells get input

      for (i=1; i <= {Ninputs}; i=i+1) // loop over inputs
        target_y = {getfield {input_source}[{i}] dest_row} * Ex_SEP_Y
        // Now set the input_row number for the source to target_y
        setfield {input_source}[{i}] input_row {i}
        // There will be no spread of inputs above or below target row
          y = target_y
          ymin = target_y - 0.2*Ex_SEP_Y
          ymax = target_y + 0.2*Ex_SEP_Y
          planarconnect {input_source}[{i}]/spikepulse/spike \
            /Ex_layer/{Ex_cell_name}[]/{Ex_drive_synpath} \
            -sourcemask box -1 -1 1 1 \
            -destmask box -1 {ymin + apical1_offset} 1 {ymax + apical1_offset} \
            -probability {prob}

          planarconnect {input_source}[{i}]/spikepulse/spike \
            /Inh_layer/{Inh_cell_name}[]/{Inh_drive_synpath} \
            -sourcemask box -1 -1 1 1 \ // be sure that I include the source
            -destmask box -1 {ymin + 0.5*Ex_SEP_Y} 1 {ymax + 0.5*Ex_SEP_Y} \
            -probability 0 // {0.65*prob}
      end // for i
    end // if (input_pattern == "row")

end // function connect_inputs