ACnet23 primary auditory cortex model (Beeman et al 2019)

 Download zip file 
Help downloading and running models
Accession:261423
These scripts were used to model a patch of layer 2/3 primary auditory cortex, making use of the the improvements to PGENESIS by Crone, et al. (2019). This single layer model contains a 48 x 48 grid of pyramidal cells (PCs) and a 24 x 24 grid of basket cells (BCs). The reduced PC models have 17 compartments with dimensions and passive properties that were fit to human cortical PC reconstructions. This parallel version of the simulation was used by Beeman, et al. (2019) to understand the effects of inhibition of PCs by BCs on auditory evoked potentials.
References:
1 . Beeman D, Yu A, Crone J (2019) Studying evoked potentials in large cortical networks with PGENESIS 2.4 BMC Neuroscience 20 Suppl 1:P46
2 . Crone JC, Vindiola MM, Yu AB, Boothe DL, Beeman D, Oie KS, Franaszczuk PJ (2019) Enabling Large-Scale Simulations With the GENESIS Neuronal Simulator Frontiers in Neuroinformatics 13:69
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 L2/3 pyramidal GLU cell; Neocortex fast spiking (FS) interneuron;
Channel(s):
Gap Junctions:
Receptor(s): GabaA; AMPA;
Gene(s):
Transmitter(s): Gaba; Glutamate;
Simulation Environment: PGENESIS; GENESIS;
Model Concept(s):
Implementer(s): Beeman, Dave;
Search NeuronDB for information about:  Neocortex L2/3 pyramidal GLU cell; GabaA; AMPA; Gaba; Glutamate;
//genesis

/**********************************************************************
** This simulation script and the files included in this package
** are Copyright (C) 2013 by David Beeman (dbeeman@colorado.edu)
** and are made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file copying.txt for the full notice.
*********************************************************************/

/*======================================================================

  Summary of function definitions for the "ACnet2-9" series of simulations

  * functions to set synchan gmax and tau1, tau2 parameters. e.g.
    set_Ex_ex_gmax, set_Inh_ex_gmax, set_Ex_bg_gmax, etc.
    set_all_gmax -- set all gmax to Ex_ex_gmax, ..., Ex_bg_gmax
    set_all_taus -- set all synchan tau1,tau2 to values 'tau1_ex', etc.

  * functions for setting FACDEP parameters for the Ex and Inh
    facdep_rules elements, e.g.
    set_facdep_dt, set_Ex_dD1, set_Ex_D1_tau, ..., set_Inh_D1_tau

  * functions to output results
    make_output, make_header, do_disk_out, do_network_out, ...

  * functions for applying 'oddball' stimuli
    make_trial_params, apply_oddball_inputs, setup_oddball_output,
    setup_oddball_inputs(input1, input2, prob1)

  * functions to calculate and output the summed Ex_ex synaptic currents
    make_EPSCsummer, do_EPSCsum_out

    Note that functions for calculating local field potentials are in
    LFPfuncs.g. Network creation functions are in ACnet2-9_netfuncs.g.

  * functions for post-run output
    do_run_summary

  * functions that are usually invoked by the GUI
    change_RUNID, do_reset, step_tmax


  * functions to set up FACDEP 
    setup_depdep_Ex_ex, setup_depdep_Inh_ex

 ======================================================================*/

// =============================
//   Function definitions
// =============================

/**** set synchan parameters ****/

function set_Ex_ex_gmax(value)  // excitatory synchan gmax in Ex_cell
   float value                  // value in nA
    str Ex_layer = "Ex_" @ {default_layer}
   Ex_ex_gmax = {value}*1e-9	// use this for driver input also
   setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_ex_synpath} gmax {Ex_ex_gmax}
end

function set_Ex_drive_gmax(value)  // thalamic drive synchan gmax in Ex_cell
   float value                  // value in nA
    str Ex_layer = "Ex_" @ {default_layer}
   Ex_drive_gmax = {value}*1e-9
   setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_drive_synpath} gmax {Ex_drive_gmax}
end

function set_Ex_bg_gmax(value)  // background ex  synchan gmax in Ex_cell
   float value                  // value in nA
    str Ex_layer = "Ex_" @ {default_layer}
   Ex_bg_gmax = {value}*1e-9
   setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_bg_synpath} gmax {Ex_bg_gmax}
end

function set_Inh_ex_gmax(value)   // excitatory synchan gmax in Inh_cell
   float value			  // value in nA
   str Inh_layer = "Inh_" @ {default_layer}
   Inh_ex_gmax = {value}*1e-9	  // use this for driver input also
   setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_ex_synpath} gmax {Inh_ex_gmax}
end

function set_Inh_drive_gmax(value) // thalamic drive synchan gmax in Inh_cell
   float value			  // value in nA
   str Inh_layer = "Inh_" @ {default_layer}
   Inh_drive_gmax = {value}*1e-9
   setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_drive_synpath} gmax {Inh_drive_gmax}
end

function set_Ex_inh_gmax(value)  // inhibitory synchan gmax in Ex_cell
   float value			  // value in nA
   str Ex_layer = "Ex_" @ {default_layer}
   Ex_inh_gmax = {value}*1e-9
   setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_inh_synpath} gmax {Ex_inh_gmax}
end

function set_Inh_inh_gmax(value)  // inhibitory synchan gmax in Inh_cell
   float value			  // value in nA
   str Inh_layer = "Inh_" @ {default_layer}
   Inh_inh_gmax = {value}*1e-9
   setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_inh_synpath} gmax {Inh_inh_gmax}
end

function set_all_gmax // set all gmax to Ex_ex_gmax, ..., Ex_bg_gmax
    str Ex_layer = "Ex_" @ {default_layer}
    str Inh_layer = "Inh_" @ {default_layer}

    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_ex_synpath} gmax \
        {Ex_ex_gmax}
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_inh_synpath} gmax \
        {Ex_inh_gmax}
    setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_ex_synpath} gmax \
        {Inh_ex_gmax}
    setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_inh_synpath}  gmax \
        {Inh_inh_gmax}
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_drive_synpath} gmax \
        {Ex_drive_gmax}
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_bg_synpath} gmax \
        {Ex_bg_gmax}
    setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_drive_synpath}  gmax \
        {Inh_drive_gmax}
end

/* NOTE: Functions to set synchan tau1 and tau2 values should be called
   only prior to hsolve SETUP.  Unlike the case with gmax, which may be
   changed if followed by a reset, changing the taus of hsolved synchans
   causes erroneous results.
*/
function set_all_taus  // assume all AMPA synchans have same taus
    str Ex_layer = "Ex_" @ {default_layer}
    str Inh_layer = "Inh_" @ {default_layer}

    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_ex_synpath} tau1 {tau1_ex} \
        tau2 {tau2_ex}
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_drive_synpath} tau1 {tau1_ex} \
        tau2 {tau2_ex}
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_bg_synpath} tau1 {tau1_ex} \
        tau2 {tau2_ex}
    setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_ex_synpath} tau1 {tau1_Inh_ex} \
        tau2 {tau2_Inh_ex}
    // GABA inhibition from Inh (basket) cells 
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_inh_synpath} tau1 {tau1_inh} \
        tau2 {tau2_inh}
    setfield /{Inh_layer}/{Inh_cell_name}[]/{Inh_inh_synpath} tau1 {tau1_inh} \
        tau2 {tau2_inh}

end

/***** functions for setting FACDEP parameters *****/

extern setup_depdep_Ex_ex // defined later belowx
extern setup_depdep_Inh_ex // defined later below

/* Be sure that the strings for the default facdep applier element
   and synchan path has been set before using these, which are
   invoked by the GUI.
*/

function set_facdep_dt(value)
    float value
    facdep_dt = value
    setclock 3 {facdep_dt}
end


/* set facdep  (dep+dep) parameters for the Ex (pyramidal) cells */

function set_Ex_dD1(value)
    float value
    Ex_dD1 = value
    if ({exists /depdep_Ex_ex})
        setup_depdep_Ex_ex
    end
end

function set_Ex_tau_D1(value)
    float value
    Ex_tau_D1 = value
    if ({exists /depdep_Ex_ex})
        setup_depdep_Ex_ex
    end
end

function set_Ex_dD2(value)
    float value
    Ex_dD2 = value
    if ({exists /depdep_Ex_ex})
        setup_depdep_Ex_ex
    end
end

function set_Ex_tau_D2(value)
    float value
    Ex_tau_D2 = value
    if ({exists /depdep_Ex_ex})
        setup_depdep_Ex_ex
    end
end


/* set facdep parameters for the Inh (basket) cells */
function set_Inh_dD1(value)
    float value
    Inh_dD1 = value
    if ({exists /depdep_Inh_ex})
        setup_depdep_Inh_ex
    end
end

function set_Inh_tau_D1(value)
    float value
    Inh_tau_D1 = value
    if ({exists /depdep_Inh_ex})
        setup_depdep_Inh_ex
    end
end

function set_Inh_dD2(value)
    float value
    Inh_dD2 = value
    if ({exists /depdep_Inh_ex})
        setup_depdep_Inh_ex
    end
end

function set_Inh_tau_D2(value)
    float value
    Inh_tau_D2 = value
    if ({exists /depdep_Inh_ex})
        setup_depdep_Inh_ex
    end
end

function set_frequency(value) // set Ex_ex average random firing freq
    float value
    str Ex_layer = "Ex_" @ {default_layer}
    frequency = value
    setfield /{Ex_layer}/{Ex_cell_name}[]/{Ex_bg_synpath} frequency {frequency}
end

/**** functions to output results ****/

function make_output(rootname) // asc_file to {rootname}_{RUNID}.txt
    str rootname, filename
    if ({exists {rootname}})
        call {rootname} RESET // this closes and reopens the file
        delete {rootname}
    end
    filename = {rootname} @ "_" @ {RUNID} @ ".txt"
    create asc_file {rootname}
    setfield ^    flush 0  leave_open 1 filename {filename} float_format %0.8g
    setclock 1 {out_dt}
    useclock {rootname} 1
end

/* This function returns a string to be used for a one-line header at the
   beginning of an ascii file that contains values of Vm or Ik for each
   cell in the network, at time steps netview_dt. When binary file output
   is used with the disk_out object, the file contains information on the
   network dimensions that are needed for the xview object display.  When
   asc_file is used to generate the network data, this information is
   provided in a header of the form:

   #optional_RUNID_string Ntimes start_time dt NX NY SEP_X SEP_Y x0 y0 z0

cell in the network, at time steps netview_dt.

   This header may be read by a data analysis script, such as netview.py.

   The line must start with "#" and can optionally be followed immediately
   by any string.  Typically this is some identification string generated
   by the simulation run.  The following parameters, separated by blanks or
   any whitespace, are:

   * Ntimes - the number of lines in the file, exclusive of the header

   * start_time - the simulation time for the first data line (default 0)

   * dt - the time step used for output (netview_dt)

   * NX, NY - the integer dimensions of the network

   *  SEP_X, SEP_Y - the x,y distances between cells (optional)

   * x0, y0, z0 - the location of the compartment (data source) relative to
     the cell origin (often ignored)

   A typical header generated by this simulation is:

   #B0003	5000 0.0 0.0002	 48 48 4e-05  4e-05 0.0	 0.0	0.0
*/

function make_header(diskpath)
    str diskpath
    int Ntimes = {round {tmax/netview_dt}} // outputs t = 0 thru tmax - netview_dt
    str header_str = "#" @ {RUNID} @ "  " @ {Ntimes} @ " 0.0 " @ {netview_dt} @ "  "
    if(diskpath == {net_efile})
        header_str = {header_str} @ {Ex_NX} @ " " @ {Ex_NY} @ " " @ {Ex_SEP_X} @ \
        "  " @ {Ex_SEP_Y} @ " 0.0  0.0  0.0"
    elif(diskpath == {net_ifile})
        header_str = {header_str} @ {Inh_NX} @ " " @ {Inh_NY} @ " " @ {Inh_SEP_X} @ \
        "  " @ {Inh_SEP_Y} @ " 0.0  0.0  0.0"
    elif(diskpath == {net_EPSC_file})
	header_str = {header_str} @ {Ex_NX} @ " " @ {Ex_NY} @ " " @ {Ex_SEP_X} @ \
	"  " @ {Ex_SEP_Y} @ " 0.0  0.0	0.0"
    else
        echo "Wrong file name root!"
        header_str = ""
    end    
    return {header_str}
end

/* Create disk_out element to write netview data to a binary or ascii  file */
function make_disk_out(diskpath)
    str diskpath, filename
    if ({exists /output/{diskpath}})
            delete /output/{diskpath}
    end
    if(binary_file==0) // use asc_file
	filename = {diskpath}  @ "_" @ {RUNID} @ ".txt"
        create par_asc_file /output/{diskpath}
        setfield /output/{diskpath} leave_open 1 flush 0 filename {filename}
        setfield /output/{diskpath} float_format %.3g notime 1
        if(write_asc_header==1)
            setfield /output/{diskpath} append 1
            call /output/{diskpath} OUT_OPEN
            call /output/{diskpath} OUT_WRITE {make_header {diskpath}}
            call /output/{diskpath} RESET
        end
    else  // use disk_out to make FMT1 binary file
        filename = {diskpath}  @ "_" @ {RUNID} @ ".dat"
        create par_disk_out /output/{diskpath}
	setfield /output/{diskpath} leave_open 1 flush 0 filename {filename}
    end //if(binary_file==0)
end

function make_disk_out_messages(diskpath,srcpath, srcelement, field)
    str name, diskpath, srcpath, srcelement, field
// to be invoked by workers
    if({hflag} && {hsolve_chanmode > 1})
      foreach name ({getelementlist {srcpath}})
        raddmsg {name}/solver /output/{diskpath}@{output_node} \
          SAVE {getfield {name}/soma io_index} \
          {findsolvefield {name}/solver {name}/{srcelement} {field}}
      end
    else
      foreach name ({getelementlist {srcpath}})
         raddmsg {name}/{srcelement} /output/{diskpath}@{output_node} \
           SAVE {getfield {name}/soma io_index} {field}
        end
    end
end

function make_network_out
   str Ex_layer = "Ex_" @ {default_layer}
   if(netview_output)
      setclock 2 {netview_dt}
      make_disk_out {net_efile}
      useclock /output/{net_efile} 2
      make_disk_out {net_ifile}
      useclock /output/{net_ifile} 2
   end
   if (EPSC_output)
      make_disk_out {net_EPSC_file}
      setclock 2 {netview_dt}
      useclock /output/{net_EPSC_file} 2
   end
end

function make_network_out_messages
   str Ex_layer = "Ex_" @ {default_layer}
   str Inh_layer = "Inh_" @ {default_layer}
   if(netview_output)
      make_disk_out_messages {net_efile} /{Ex_layer}/{Ex_cell_name}[] soma Vm
      make_disk_out_messages {net_ifile} /{Inh_layer}/{Inh_cell_name}[] soma Vm
   end
   if (EPSC_output)
      make_disk_out_messages {net_EPSC_file} \
         /{Ex_layer}/{Ex_cell_name}[] {Ex_ex_synpath} Ik
   end
end

/***** functions to provide 'oddball' stimuli *****/

/* These stimulus pulse parameters are set after calling function
   make_inputs in MGBv_input2-7.g or simple_inputs2-7.g
*/
float pulse_delay, pulse_width, pulse_interval

function apply_oddball_inputs
    int ignore_steps = 0 // intials steps to ignore
    int input1 = {getfield  /oddball_inputs input1}
    int input2 = {getfield  /oddball_inputs input2}
    float prob1 = {getfield  /oddball_inputs prob1}
    int freqnum, stim
    float curr_time = {getstat -time}
    int facdep_step = {round {curr_time/pulse_interval}}
    if (use_stim_order >0)
      ignore_steps = 5
    end
    if (facdep_step < ignore_steps) // use input1 and set freqnum = 0
        setfield /MGBv[{input1}]/spikepulse level1 1.0
        setfield /MGBv[{input2}]/spikepulse level1 0.0 
      setfield /oddball_inputs freqnum 0
    else // process following steps
      if (use_stim_order == 1) // read stim from a file
          // 0 i= "oddball" input2; 1 = "frequent" input1
          stim = {readfile {stim_order_file}}
      elif (use_stim_order == 2)
        if ({facdep_step % 5} == 0)   // every 5th trial is infrequent
          stim = 0
        else
          stim = 1
        end
      elif (use_stim_order == 3)
        if ({facdep_step % 6} < 2)   // every 5th and 6th trial is infrequent
          stim = 0
        else
          stim = 1
        end
      else // use probabilities
        if ({rand 0 1} <= {prob1}) // frequent input
           stim = 1
        else
            stim = 0
        end
      end // if (use_stim_order)
      if (stim == 1) // frequent
        setfield /MGBv[{input1}]/spikepulse level1 1.0 
        setfield /MGBv[{input2}]/spikepulse level1 0.0 
        setfield /oddball_inputs freqnum 1
      else // oddball input
        setfield /MGBv[{input1}]/spikepulse level1 0.0 
        setfield /MGBv[{input2}]/spikepulse level1 1.0 
        setfield /oddball_inputs freqnum 2
      end
    end // process following steps
    if (debug_level > 1)
        echo "*** trial " {facdep_step} " stim " {stim} " prob1 " {prob1}
    end
end

function setup_oddball_inputs(input1, input2, prob1)
    int input1, input2
    float prob1 // probability of input1 - passed from global 'input1_prob'
    create script_out /oddball_inputs
    addfield  /oddball_inputs input1
    addfield  /oddball_inputs input2
    addfield  /oddball_inputs prob1
    setfield /oddball_inputs command apply_oddball_inputs
    setfield /oddball_inputs input1 {input1}
    setfield /oddball_inputs input2 {input2}
    setfield /oddball_inputs prob1 {prob1}
    // A place to store the current step input number (1 or 2, or 0 for none)
    addfield  /oddball_inputs freqnum 
    setfield  /oddball_inputs freqnum 0
    setclock 5 {pulse_interval}
    useclock /oddball_inputs 5
	  if (use_stim_order == 1)
		  openfile {stim_order_file} r
	  end
end

function make_oddball_header
    /* create a one line header with the format:

      #RUNID pulse_delay pulse_width pulse_interval sample_duration
       The sample duration and input pulse parameters are used by the
       PSD analysis tools for averaging over trial repetions of the stimulus.
    */
    float sample_duration = 0.5 // default length of sample to be taken
    str  header_str
    header_str = "#" @ {RUNID} @ "  " @ {pulse_delay}  @ "  " \
      @ {pulse_width}  @ "  " @ {pulse_interval}  @ "  " @ {sample_duration}
    return {header_str}
end

function setup_oddball_output
    /* Now create an asc_file to output the information on when the inputs
       input1 and input2 occurred.
    */
    str rootname
    rootname = "oddball_freqs"
    make_output {rootname}
    useclock {rootname} 5
    setfield  {rootname} append 1 flush 1
    call  {rootname} OUT_OPEN
    call  {rootname} OUT_WRITE {make_oddball_header}
    call  {rootname} RESET
    raddmsg@{control_node} /oddball_inputs {rootname}@{output_node} SAVE freqnum
end

/* ------------------------------------------------------------------
 Create a calculator object to hold summed Ex_ex currents, and then
 send all Ex_ex synaptic currents to it for summation

  NOTE:  Previous versions of make_EPSCsummer also summed the excitatory
  currents from the thalamic input drive. Here, the effect of any input
  drive would be indirect through propagation of its effect from cell to
  cell via synaptic connections.
------------------------------------------------------------------- */

function do_EPSCsum_out // called from output_node
    str data_source = "/EPSCsummer" // data_source sums Ex_cell ex currents
    create calculator {data_source}
    useclock {data_source} 1 // the clock for out_dt
    make_output {EPSC_sum_file}
    // should be OK to add the message here
        addmsg {data_source} {EPSC_sum_file} SAVE output
end

function make_EPSCsummer_messages // data_source sums Ex_cell ex currents
    int i
    str data_source = "/EPSCsummer" // data_source sums Ex_cell ex currents
    str Ex_layer = "Ex_" @ {default_layer}
    for (i=0; i < Ex_cells_per_slice; i = i + 1)
        if({hflag} && {hsolve_chanmode > 1})
            raddmsg /{Ex_layer}/{Ex_cell_name}[{i}]/solver {data_source}@{output_node} \
              SUM {findsolvefield /{Ex_layer}/{Ex_cell_name}[{i}]/solver \
              {Ex_ex_synpath} Ik}
        else
            raddmsg /{Ex_layer}/{Ex_cell_name}[{i}]/{Ex_ex_synpath} \
                {data_source}@{output_node} SUM Ik
        end
    end
end // make_EPSCsummer_messages

/*****  Functions for post-run output *****/

function do_run_summary
    str filename = {sum_file} @ "_" @ {RUNID} @ ".txt"
    openfile {filename} w
    writefile {filename} "Script:" {script_name} "  RUNID:" {RUNID} "  seed:" {seed} \
        "  date:" {getdate}
    writefile {filename} "tmax:" {tmax} " dt:" {dt} " out_dt:" {out_dt} \
        " netview_dt:" {netview_dt} 
    writefile {filename} "EPSC_output:" {EPSC_output} "  netview_output:" {netview_output}
    writefile {filename} "Ex_NX:" {Ex_NX} " Ex_NY:" {Ex_NY} " Inh_NX:" \
        {Inh_NX} "  Inh_NY:" {Inh_NY}
    writefile {filename} "Ex_SEP_X:" {Ex_SEP_X} " Ex_SEP_Y:" {Ex_SEP_Y} \
        "  Inh_SEP_X:" {Inh_SEP_X}  "  Inh_SEP_Y:" {Inh_SEP_Y}
    writefile {filename} "Ninputs:" {Ninputs} " bg Ex freq:" {frequency} \
        " bg Ex gmax:" {Ex_bg_gmax}
    writefile {filename} "================== Network parameters ================="
    writefile {filename} "Ex_ex_gmax:" {Ex_ex_gmax} " Ex_inh_gmax:" {Ex_inh_gmax} \
        "  Inh_ex_gmax:" {Inh_ex_gmax} "  Inh_inh_gmax:" {Inh_inh_gmax}
    writefile {filename} "tau1_ex:" {tau1_ex} "  tau2_ex:" {tau2_ex}  \
        "  tau1_inh:" {tau1_inh} "  tau2_inh:" {tau2_inh}
    writefile {filename} "tau1_Inh_ex:" {tau1_Inh_ex} "  tau2_Inh_ex:" {tau2_Inh_ex}
    writefile {filename} "syn_weight: " {syn_weight} \
        " prop_delay:" {prop_delay} " default drive weight:" {drive_weight}
    writefile {filename} "Ex_drive_gmax: " {Ex_drive_gmax} \
        "  Inh_drive_gmax: " {Inh_drive_gmax}
    /* The code below is specific to the input model -- see MGBv_input.g */
    writefile {filename} "MGBv input delay: " {input_delay} \
	"  MGBv input jitter :" {input_jitter}
    writefile {filename} "input_spread : " {input_spread} \
        "  connect_network :" {connect_network} "use_weight_decay: " \
        {use_weight_decay}
    writefile {filename} "change_weights: " {change_weights} \
         " use_Ex_ex_FACDEP: " {use_Ex_ex_FACDEP} \
         " use_Inh_ex_FACDEP: " {use_Inh_ex_FACDEP}
    writefile {filename} "input paradigm: "  {input_paradigm} "input1_prob: " {input1_prob}

    writefile {filename} "================== Thalamic inputs ================="
    writefile {filename} "Input" " Row " "Frequency" "    State" "   Weight" \
        "    Delay" "    Width" " Period"
    int input_num, input_row
    str  input_source = "/MGBv" // Name of the array of input elements
    float input_freq, delay, width, interval, drive_weight
    str pulse_src, spike_out
    str toggle_state
    floatformat %10.3f
    for (input_num = 1; input_num <= {Ninputs}; input_num= input_num +1)
        pulse_src = {input_source} @ "[" @ {input_num} @ "]" @ "/spikepulse"
        spike_out = {input_source} @ "[" @ {input_num} @ "]" @ "/soma/spike"
        input_row  = \
          {getfield {{input_source} @ "[" @ {input_num} @ "]"} input_row}
        input_freq  = \
          {getfield {{input_source} @ "[" @ {input_num} @ "]"} input_freq}
        drive_weight = \
          {getfield {{input_source} @ "[" @ {input_num} @ "]"} output_weight}
        delay = {getfield {pulse_src} delay1 }
        width = {getfield {pulse_src} width1}
        interval = {getfield {pulse_src} delay1} + {getfield {pulse_src} delay2}
        // get the spiketoggle state
        toggle_state = "OFF"
        if ({getfield {pulse_src} level1} > 0.5)
            toggle_state = "ON"
        end
        writefile {filename} {input_num} {input_row} -n -format "%5s"
        writefile {filename} {input_freq} {toggle_state} {drive_weight} \
            {delay} {width} {interval}  -format %10s
    end
    writefile {filename} "----------------------------------------------------------"
    writefile {filename} "Notes:"
    closefile {filename}
    floatformat %0.10g
end

function change_RUNID(value)
    str value, path, new_name, rootname
    RUNID =  value
    // Set up new file names for output
    if (i_am_output_node)
        foreach path ({el /##[OBJECT=asc_file],/##[OBJECT=par_asc_file]})
            rootname = {getfield {path} name} 
            new_name = {rootname} @ "_" @ {RUNID} @ ".txt"
            if (debug_level)
                echo@{control_node} "New filename: " {new_name} "path: " {path}
            end
            setfield {path} append 0 leave_open 0
            call {path} RESET
            setfield {path} filename {new_name}
            setfield {path} append 1 leave_open 1
            if ((rootname == {net_efile}) || (rootname == {net_ifile}) \
              || (rootname == {net_EPSC_file}))
                call {path} OUT_OPEN
                call {path} OUT_WRITE {make_header {rootname}}
            elif (rootname == "oddball_freqs")
                call {path} OUT_OPEN
                call {path} OUT_WRITE {make_oddball_header}
		call {path} RESET
            end
        end
    end // (i_am_output_node)
end

extern reset_freqmons // defined below
function do_reset // from control_node
    if(calc_firing_freqs) // not used here
        reset_freqmons
    end
    reset@all
end

function step_tmax
    echo "dt = "{getclock 0}"   tmax = "{tmax}
    echo "RUNID: " {RUNID}
    echo "START: " {getdate}
    step@all {tmax} -time
    // step@all // do one more step be sure tmax is included
    echo "END  : " {getdate}
    do_run_summary
end

/*** functions to set up FACDEP *****/

function setup_depdep_Ex_ex
    str facdep_applier = "depdep_Ex_ex"
    str cellpath = "/Ex_" @ {default_layer} @ "/" @ {Ex_cell_name} @ "[]"
    str relsynpath = {Ex_ex_synpath}
    if (change_weights < 0) // Don't even make the object
        return
    end
    if (!{exists {facdep_applier}})
            create facdep_rules2 {facdep_applier}
    end
    setfield {facdep_applier} cellpath {cellpath}
    setfield {facdep_applier} synpath {relsynpath}
    setfield {facdep_applier} change_weights {change_weights}
    setfield {facdep_applier} use_depdep 1 // two depression factors
    setfield {facdep_applier} debug_level 0 // {debug_level}
    setfield {facdep_applier} dD1 {Ex_dD1}
    setfield {facdep_applier} dD2 {Ex_dD2}
    setfield {facdep_applier} tau_D1 {Ex_tau_D1}
    setfield {facdep_applier} tau_D2 {Ex_tau_D2}
    setclock 3 {facdep_dt}
    useclock  {facdep_applier} 3
end // function setup_depdep_Ex_ex

function setup_depdep_Inh_ex
    str facdep_applier = "depdep_Inh_ex"
    str cellpath = "Inh_" @ {default_layer} @ "/" @ {Inh_cell_name} @ "[]"
    str relsynpath = {Inh_ex_synpath}
    if (change_weights < 0) // Don't even make the object
        return
    end
    if (!{exists {facdep_applier}})
            create facdep_rules2 {facdep_applier}
    end
    setfield {facdep_applier} cellpath {cellpath}
    setfield {facdep_applier} synpath {relsynpath}
    setfield {facdep_applier} change_weights {change_weights}
    setfield {facdep_applier} use_depdep 1 // two depression factors
    setfield {facdep_applier} debug_level 0 // {debug_level}
    setfield {facdep_applier} dD1 {Inh_dD1}
    setfield {facdep_applier} dD2 {Inh_dD2}
    setfield {facdep_applier} tau_D1 {Inh_tau_D1}
    setfield {facdep_applier} tau_D2 {Inh_tau_D2}
    setclock 3 {facdep_dt}
    useclock  {facdep_applier} 3
end // function setup_depdep_Inh_ex

function make_pyrVm_out(cell_num) // execute from output_node
    int cell_num
    str rootname = {pyrVm_file} @ {cell_num} // string concat, not a node
    // {pyrVm_file} is defined in main script as "pyrVm"
    make_output {rootname}
end

function make_pyrVm_out_messages(cell_num) // execute from node with cell_num 
    int cell_num, index, node
    str Ex_layer = "Ex_" @ {default_layer}
    str rootname = {pyrVm_file} @ {cell_num}
    // {pyrVm_file} is defined in main script as "pyrVm"
    index = {cell_index {cell_num} {Ex_cells_per_slice}}
    node = {cell_node {cell_num} {Ex_cells_per_slice}}
    if ({mynode} != node)
        return
    end
    if({hflag} && {hsolve_chanmode > 1})
        raddmsg /{Ex_layer}/{Ex_cell_name}[{index}]/solver \
          {rootname}@{output_node} SAVE \
          {findsolvefield /{Ex_layer}/{Ex_cell_name}[{index}]/solver \
          soma Vm}
    else
        raddmsg /{Ex_layer}/{Ex_cell_name}[{index}]/soma \
	  {rootname}@{output_node} SAVE  Vm
    end
end // function make_pyrVm_out_messages

function print_Ex_synapse_info(cell_num) // execute from node with cell_num
    int cell_num, index, node
    str Ex_layer = "Ex_" @ {default_layer}
    index = {cell_index {cell_num} {Ex_cells_per_slice}}
    node = {cell_node {cell_num} {Ex_cells_per_slice}}
    if ({mynode} == node)
        synapse_info /{Ex_layer}/{Ex_cell_name}[{index}]/{Ex_ex_synpath}
        synapse_info /{Ex_layer}/{Ex_cell_name}[{index}]/{Ex_inh_synpath}
    end
end

function print_Inh_synapse_info(cell_num) // execute from node with cell_num
    int cell_num, index, node
    str Inh_layer = "Inh_" @ {default_layer}
    index = {cell_index {cell_num} {Inh_cells_per_slice}}
    node = {cell_node {cell_num} {Inh_cells_per_slice}}
    if ({mynode} == node)
        synapse_info /{Inh_layer}/{Inh_cell_name}[{index}]/{Inh_ex_synpath}
    end
end

function reseed_RNG(seed)
    int seed, newseed
    if ({mynode} == 0) // control node (and worker0 if = 0) gets orig seed
        newseed = seed
     else // worker 1 and higher get multiples of 347 added to seed
	newseed = seed + ({mynode} - worker0)*347
     end
     echo@{control_node} "New RNG seed = " {newseed}
     randseed {newseed}
end

// Flush the buffers of all text output elements
function flush_buffers
    str path
    if (i_am_output_node)
        foreach path ({el /##[OBJECT=asc_file],/##[OBJECT=par_asc_file]})
            if(pdebug)
                echo@{control_node} "Final step and flush for: " {path}
            end
	    setfield {path} flush 1
        end
        step@all {netview_dt} -time // add extra steps to flush buffers
    end //  (i_am_output_node)
end

Loading data, please wait...