Spatial constrains of GABAergic rheobase shift (Lombardi et al., accepted)

 Download zip file 
Help downloading and running models
Accession:267142
In this models we investigated how the threshold eGABA, at which GABAergic inhibition switches to excitation, depends on the spatiotemporal constrains in a ball-and-stick neurons and a neurons with a topology derived from an reconstructed neuron.
Reference:
1 . Lombardi A, Luhmann HJ, Kilb W (accepted) Modelling the spatial and temporal constrains of the GABAergic influence on neuronal excitability PLoS Computational Biology
Model Information (Click on a link to find other models with that property)
Model Type: Synapse; Neuron or other electrically excitable cell;
Brain Region(s)/Organism: Hippocampus;
Cell Type(s): Hippocampus CA3 pyramidal GLU cell;
Channel(s):
Gap Junctions:
Receptor(s): AMPA; GabaA;
Gene(s):
Transmitter(s): Glutamate; Gaba;
Simulation Environment: NEURON;
Model Concept(s): Development; Action Potentials;
Implementer(s): Kilb, Werner [wkilb at uni-mainz.de];
Search NeuronDB for information about:  Hippocampus CA3 pyramidal GLU cell; GabaA; AMPA; Gaba; Glutamate;
// Det_GABAtonic on gAMPA-Spike_Probability 8x seed_1_4.hoc
// Determine the effect of GABA at deifferent EGABA on spike probability during gAMPA Inputs 
//
// GABA Synapses are Exp2-Synapses with physiological kinetic properties and
// a variable reversal potential and a defined conductance
//
// AMPA Synapses are Exp2-Synapses with physiological kinetic properties and
// a fixed reversal potential of -12 mV (from pAMPA = 0.5, e(Na) = 66, e(K) = -90) and fixed conductance
// Conductance determined with Det_gAMPA-Spike_Probability_1_2.hoc
// set at 0.15345 pS gives ca. 50% spike probability with the AMPA train (301 repetitions, seed-AMPA = 0)
// 
// Author: Werner Kilb
// Version 1.4
// Date: 16-Apr-2021
//--------------------------------------------------

// Header Values ------------------------------------------------------
    strdef VERSION, CELL, AP, DENOM, PROGRAM
    PROGRAM = "AMPA_GABA_SpikeProbab_Raster"
    VERSION = "2.0"
    CELL = "Real"
    AP = "ndrf"
    gKaMax_ndrfAP = 0.0018    // adapt gK to prevent depolarization block during EPSPs
    DENOM = "A"
    VARIABLE = 0

    //Parameters to define the frequency
    StimStart = 50         //- Fixed
    StimDuration = 2000
    StimNumber = 20 
    StimFreq = StimNumber/StimDuration * 1000
    tstop = StimStart+StimDuration+50 

    // Facor to calculate gAMPA with 50% Spike Probability according to Det_Spike_Probabl_gAMPA.hoc
    if (StimFreq == 1)  { gAMPAfact = 3.02 }
    if (StimFreq == 2)  { gAMPAfact = 2.43 }
    if (StimFreq == 3)  { gAMPAfact = 2.14 }
    if (StimFreq == 5)  { gAMPAfact = 1.81 }
    if (StimFreq == 10) { gAMPAfact = 1.29 }
    if (StimFreq == 20) { gAMPAfact = 0.90 } 

// ------------Definition of Parameters -------------------------------
    // seed Values for random generator
    seed_GABA = 0               // seed for random function
    seed_AMPA = seed_AMPA+3

    // Determining Parameters GABA ---------------------------
    gGABAfact = 1               // factor to adjust GABAergic effects
    gGABA = 0.000789*gGABAfact  // µS synaptic weight according to miniature events
    GABA_Rise = 0.5             // ms arbitraray Value
    GABA_Decay = 37             // ms from Lombardi et a. (2018)
    GABA_Rev = -40.0            // Reversal Potential will be changed manually
    nGABAsyn = StimNumber       // Number of GABA synapses 
    nGABAinputs = 1             // number of inputs per synapse

    // Determination Parameters AMPA ------------------------------------
    gAMPA = 0.000305 * gAMPAfact// µS synaptic weight for ca. 50% Spike Probability
    AMPA_Rise = 0.5             // ms arbitraray Value
    AMPA_Decay = 11             // ms from Lombardi et a. (2018)
    AMPA_Rev = -12              // mV Estmated reversal potential 
    nAMPAsyn = StimNumber       // Number of GABA synapses 
    nAMPAinputs = 1             // number of inputs per synapse

    // Definition of various runtime parameters --------------------------
    v_init = -50.5              // Initial voltage
    dt = 0.025                  // Step Interval in ms
    steps_per_ms = 2
    celsius = 31                // measured at°C
    ndend=56                    // Number of dendrites
    NumberRept = 300
    APThresh = -10              // mV Thresholf for AP-detection algorithm

    RunIndex = VARIABLE         // counter for number or repetitions
    LineInd = VARIABLE          // Index for the element in output vectors

    ON = 1
    OFF = 0
       

// Define vectors to link modelled parameter output ---------------------------------
    objref voltvec, timevec                                            
    voltvec = new Vector()                                     // Vector used fors torage of voltage trace for further analysis
    timevec = new Vector()                                     // Vector
    voltvec.record(&v(.5))                                     // Link Volt vector (mesured in soma) to Output-Vectors
    timevec.record(&t)                                         // Link time vector

// ---------Definition of synaptic objects -------------------------------------
    // Objects for Synapses ---------------------------------------------------------
    objref GABAsyn[nGABAsyn]                            
    objref AMPAsyn[nAMPAsyn]

    nDistDend = 17           // Number or Perisomatic dendrites
    objref DistDend
    DistDend = new Vector(nDistDend)            // List of the perisomatic dendrites
        DistDend.x[0] = 20
        DistDend.x[1] = 30
        DistDend.x[2] = 32
        DistDend.x[3] = 34
        DistDend.x[4] = 37
        DistDend.x[5] = 38
        DistDend.x[6] = 39
        DistDend.x[7] = 43
        DistDend.x[8] = 44
        DistDend.x[9] = 47
        DistDend.x[10] = 49
        DistDend.x[11] = 50
        DistDend.x[12] = 51
        DistDend.x[13] = 52
        DistDend.x[14] = 53
        DistDend.x[15] = 54
        DistDend.x[16] = 55

    nProxDend = 12           // Number or Proximal dendrites
    objref ProxDend
    ProxDend = new Vector(nProxDend)            // List of the Proximal dendrites
        ProxDend.x[0] = 0
        ProxDend.x[1] = 1
        ProxDend.x[2] = 2
        ProxDend.x[3] = 3
        ProxDend.x[4] = 4
        ProxDend.x[5] = 5
        ProxDend.x[6] = 8
        ProxDend.x[7] = 9
        ProxDend.x[8] = 10
        ProxDend.x[9] = 13
        ProxDend.x[10] = 14
        ProxDend.x[11] = 18

    // random function for synapse definition
    objref randAMPAloc, randGABAloc        // random function for determination of dendrite number
    objref randAMPAdend, randGABAdend      // random function for localization of synapses in which dendrite 
    objref randGABAt, randGABAg            // random function for synaptip parameters (timing and g)
    objref randAMPAt, randAMPAg

    // definition of Vectors for Gaba-Stimulation (t_vec = timestamps t_vecr = sorted timestamps, g_vec = rel conductance)
    objref GABA_Stim[nGABAsyn], GABA_t_vec[nGABAsyn], GABA_t_vecr[nGABAsyn], NetCon_GABA[nGABAsyn], GABA_g_vec[nGABAsyn]
    // definition of Vectors for AMPA-Stimulation
    objref AMPA_Stim[nAMPAsyn], AMPA_t_vec[nAMPAsyn], AMPA_t_vecr[nAMPAsyn], NetCon_AMPA[nAMPAsyn], AMPA_g_vec[nAMPAsyn]




// ---- Output vectors and files ---------------------------------------------------------------------------------
    objref TimeStamp_List 
    TimeStamp_List = new Vector()                             // Output Vector for one run() of the simulation, variable length

    objref TimeStamp_Results                                  // Matrix for outputs
                                                               // Definition of the output matrix
                                                               //                                   Col[0]          Col[1]      Col[2]       ...  Repeated for each repitition
                                                               // Line[0]                            gAMPA          gAMPA       gAMPA
                                                               // Line[1]                            gGABA          gGABA       gGABA
                                                               // Line[2]                            seed           seed        seed      
                                                               // Line[3]                            GABA_Rev       GABA_Rev    GABA_Rev
                                                               // Line[4]                            Rept1          Rept 2      Rept3
                                                               // Line[5]                             t[1st AP]
                                                               //  ..                                 t[n. AP]
                                                               // Variable length!!
    

    TimeStamp_Results = new Matrix()
    OutCol = VARIABLE                                          // Set of Columns in the Results-Array
    strdef OutSPRName                                          // Define Name of Output-File for Rheo-Shift Matrix
    objref OutSPRFile                                          // Define Output File for Rheo-Shift Matrix



// ------- Init_Random() ------------------------------------------------------------------//
// Initializes the Random Functions                                                        //
// Input: seed_AMPA                                                                        //
// Call: Init_Random()                                                            //
// Output: None                                                                            // 
//-----------------------------------------------------------------------------------------//
proc Init_Random() {
    // Initialize Random Functions -----------
    randAMPAloc = new Random(seed_AMPA+1)
    randGABAloc = new Random(seed_GABA+2)
    randAMPAdend = new Random(seed_AMPA+3)
    randGABAdend = new Random(seed_GABA+4)
    randAMPAt = new Random(seed_AMPA+5)
    randAMPAg = new Random(seed_AMPA+6)
    randGABAt = new Random(seed_GABA+7)
    randGABAg = new Random(seed_GABA+8)
 


    //Define properties of random Function 
    randGABAt.uniform(50, tstop - 50)
    randGABAg.normal(1, 0.28) //rel variance of GABA according to results
    randAMPAt.uniform(50, tstop - 50)
    randAMPAg.normal(1, 0.26) //rel variance of AMPA according to results


    // generate Vectors --- (nGABAinputs, nAMPAinputs defines number of inputs per synapse) ------
    for i = 0, nGABAsyn-1 {
      GABA_t_vec[i] = new Vector(nGABAinputs)
      GABA_t_vecr[i] = new Vector(nGABAinputs)
      GABA_g_vec[i] = new Vector(nGABAinputs)
    }

    for i = 0, nAMPAsyn-1 {
       AMPA_t_vec[i] = new Vector(nAMPAinputs)
       AMPA_t_vecr[i] = new Vector(nAMPAinputs)
       AMPA_g_vec[i] = new Vector(nAMPAinputs)
    }
} // end of proc InitRandom

// ------- Procedure Distr_GABA_Synapses --------------------------------------------------//
// Distributes the GABA synpases across the dendrite                                       //
// Input: None                                                                             //
// Uses global variables: GABA_Rise, GABA_Decay, GABA_Rev                                  //
// Call: Distr_GABA_Synapses()                                                             //
// Output: None                                                                            // 
// Note that in this project GABA synapses were simulated as Exp2Syn with variable eRev    //
//-----------------------------------------------------------------------------------------//
proc Distr_GABA_Synapses(){local k
  for k=0, nGABAsyn-1 {
      pos = randGABAloc.uniform(0,ndend-1)
      pos2 = randGABAdend.uniform (0.0001, 0.999)
      dend_0[pos]{
        GABAsyn[k] = new Exp2Syn(pos2)
        GABAsyn[k].tau1 = GABA_Rise
        GABAsyn[k].tau2 = GABA_Decay
        GABAsyn[k].e = GABA_Rev
        }
      }
}   // end of proc Distr_GABA_Synapses()


// ------- Procedure Distr_AMPA_Synapses --------------------------------------------------//
// Distributes the AMPA synpases across the dendrite                                       //
// Input: None                                                                             //
// Uses global constants: AMPA_Rise, AMPA_Decay                                            //
// Call: Distr_AMPA_Synapses()                                                             //
// Output: None                                                                            // 
// Note that in this project AMPA synapses were simulated as Exp2Syn                       //
//-----------------------------------------------------------------------------------------//
proc Distr_AMPA_Synapses(){local k
  for k=0, nAMPAsyn-1 {
    pos = randAMPAloc.uniform(0,ndend-1)
    pos3 = randAMPAdend.uniform (0.5, 0.999)
    dend_0[pos]{
      AMPAsyn[k] = new Exp2Syn(pos3)
      AMPAsyn[k].tau1 = AMPA_Rise
      AMPAsyn[k].tau2 = AMPA_Decay
      AMPAsyn[k].e = AMPA_Rev
    }                                              
  }
}   // end of proc Distr_AMPA_Synapses()


// ------- Procedure generateGABAinputs  --------------------------------------------------//
// Generates the random inputs to the GABA synapses                                        //
// Input: $1 = gGABA                                                                       //
//        $2 = GABA_Rev                                                                    //
// Call: generateGABAinputs(gGABA*gGABAfact, GABA_Rev)                                     //
// Output: None                                                                            // 
//-----------------------------------------------------------------------------------------//
proc generateGABAinputs(){local f, i, g
   // pick random values for time t and conductance g
    for f=0, nGABAsyn-1 {
    GABAsyn[f].e = $2  
      for i=0, nGABAinputs-1 {
          t = randGABAt.repick()
          g = abs(randGABAg.repick()*$1)
          GABA_t_vec[f].x[i]= t
          GABA_g_vec[f].x[i]= g
      }
    }
    // sort the timestamps 
    for f=0, nGABAsyn-1 {
      GABA_t_vecr[f] = GABA_t_vec[f].sort()
    }
    // generate vecstim-Element from the sorted timestamp-vectors -------------------------------
    for f=0, nGABAsyn-1 {
      GABA_Stim[f] = new VecStim()
      GABA_Stim[f].play(GABA_t_vecr[f])    
    }
    // link GABA-vecstim object via NetCon objects to the synapses ---------------------------------------------
    for f=0, nGABAsyn-1 {
      NetCon_GABA[f] = new NetCon(GABA_Stim[f], GABAsyn[f], 0, 0, GABA_g_vec[f].x[0])
    }                                                 
}  // end of generateGABAinputs()


// ------- Procedure generateAMPAinputs  --------------------------------------------------//
// Generates the random inputs to the AMPA synapses                                        //
// Input: $1 = gAMPAvalue                                                                  //
// Call: generateAMPAinputs(gAMPA)                                                         //
// Output: None                                                                            // 
//-----------------------------------------------------------------------------------------//
proc generateAMPAinputs(){local f, i, g
    // pick random values for time t and conductance g
    for f=0, nAMPAsyn-1 {
      for i=0, nAMPAinputs-1 {
          t = randAMPAt.repick()
          g = abs(randAMPAg.repick()*$1)
          AMPA_t_vec[f].x[i]= t
          AMPA_g_vec[f].x[i]= g
      }
    }
    for f=0, nAMPAsyn-1 {                     
      AMPA_t_vecr[f] = AMPA_t_vec[f].sort()        // sort the timestamps 
    }
    // generate vecstim-elements from the sorted timestamp-vectors -------------------------------   
    for i=0, nAMPAsyn-1{
      AMPA_Stim[i] = new VecStim()
      AMPA_Stim[i].play(AMPA_t_vecr[i])    // AMPA stimulator
    } 
    // link GABA-vecstim object via NetCon objects to the synapses ---------------------------------------------   
    for i=0, nAMPAsyn-1 {
       NetCon_AMPA[i] = new NetCon(AMPA_Stim[i], AMPAsyn[i], 0, 0, AMPA_g_vec[i].x[0])
    }    
}  // end of generateAMPAinputs()


// Procedure Pause -----------------------------------------------------------------------------//
// Inputs: none                                                                                 //
// Call: Pause(s)                                                                               //
// stops excecution fo s seconds                                                                //
// ---------------------------------------------------------------------------------------------//
proc pause() { local t0
  t0 = startsw()
  while (startsw()-t0 < $1) { }
}

// Function Detect_APs --------------------------------------------------------------------------//
// Inputs: $1 Objref to voltvec                                                                  //
//         $2 Theshold in mV                                                                     //
//         $3 Objref to timevec                                                                  //
//                                                                                               //
// call Detect_APs(voltvec, APThresh, timevec)                                                   //
// returns   Number of APs as double                                                             //
//                                                                                               //
// Detets the numer of APs in a voltvector                                                       //
// ----------------------------------------------------------------------------------------------//
proc Detect_APs() {local i, Refract, APs
  Refract = 0
  for i=0, $o1.size-1 {
    if (Refract == 0 && $o1.x[i]>$2){            //look for v crossing threshold in depolarizing direction for whole voltvec
         // AP detected by one
         TimeStamp_List.append($o3.x[i])  
         Refract = 1           // switch to refractory period
    }
    if (Refract == 1 && $o1.x[i]<$2-5){            //look for v crossing threshold in hyperpolarizing direction
                                                   // implemented 5 mV security interval here to omit triggering by noise  
              Refract = 0          // refractory period ends
     }        
  }
}   //  End of function



//--DetermineSpikeProbab--------------------------------------------------------------------------// 
// Determines the Spike Probability for the n= IntSteps gAMPA Steps between gMin and gMax         //
// Stores the spike Probability in the OutMatrix (global)                                         //
// Actualized new gMin and gMax values (the two values closest to 50% spike Probability           //
// Input: $1  conductance of the AMPA synapse                                                     //
//        $2  seed Value for seed AMPA                                                            //
// Uses the global variable LineInd for output in vectors                                         //
// Call:  DetermineSpikeProbab(gAMPA*gAMPAfact, seed_AMPA)                                        //
// Output: None                                                                                   //
//------------------------------------------------------------------------------------------------//  
proc DetermineSpikeProbab(){local Rept, SumAPs, NumberSupra
       Init_Random($2)                                           // induce repetitions with different seed values
       SumAPs = 0                                                // reset AP number counter
       NumberSupra = 0                                           // reset number of suprathreshold repetitions

       for Rept = 1, NumberRept{ 
          // redistribute the synapses
          Distr_AMPA_Synapses()                            // distribute AMPA synapses randomly
          generateAMPAinputs($1)                           // generate random glutamatergic inputs
          Distr_GABA_Synapses()
          generateGABAinputs(gGABA, GABA_Rev)
          Init_Out_Vector(TimeStamp_List,gAMPA,seed_AMPA,Rept)
          // run and analyse the simulation
          run()                       
          Detect_APs(voltvec, APThresh, timevec)          // put stike times in TimeStamp_List
          printf("Spike times for repetition %g ",Rept)
          TimeStamp_List.printf()
          Add_To_Results(TimeStamp_List)
        } // end of for (Rept...)
       // store the information
        
}// End of procedure DetermineSpikeProbab()


// Procedure Init_Out_Vector  ------------------------------------------------------------------------//
// Clears the three data-output vectors                                                               //
// Inputs: $1 ObjRef to ERev_List                                                                     //
//         $2 gAMPA                                                                                   //
//         $3 Seed                                                                                    //
//         $4 Rept                                                                                    //
// Call:   Init_Out_Vector(TimeStamp_List,gAMPA,gGABA_List.x[gGABA_Step -1],Seed_AMPA,GABA_Rev,Rept)  //     
// ---------------------------------------------------------------------------------------------------//
proc Init_Out_Vector() {
   $o1.resize(5)
   $o1.x[0] = $2*1000
   $o1.x[1] = $3
   $o1.x[2] = $4
} // end of proc

// Function Max() ---------------------------------------------------------------------//
// Provides the larger Values of 2 elements                                            //
// Inputs: $1 Element 1                                                                //
//         $2 Element 2                                                                //
// Call  : Max(TimeStamp_List.size(), TimeStamp_Results.nrow())                       //
// Output: The larger of the two input values                                          //
// ------------------------------------------------------------------------------------//
func Max(){
    if ($1 > $2){
        return $1
    } else {
        return $2
    }
}

// Procedure Add_To_Results ---------------------------------------------------------------------//
// Transferes the results from one Synapse position (in One-Parameter Vector) to Results array   //
// Inputs: $1 ObjRef to TimeStamp_List                                                           //
// Call:   Add_To_Results(TimeStamp_List)                                                        //     
// Other Variables are  global variables                                                         //
// ----------------------------------------------------------------------------------------------//
proc Add_To_Results() {local MaxRow
   MaxRow = Max(TimeStamp_List.size(), TimeStamp_Results.nrow())     // Determines if Time Stap list has more elements that rows in output array
   TimeStamp_Results.resize(MaxRow, TimeStamp_Results.ncol()+1)      // New colums, ev new lines to output array
   TimeStamp_Results.setcol(TimeStamp_Results.ncol()-1, $o1)         // copy TimeStamp_List in the last Column of the TimeStamp_Results Array
} // end of proc


//--savedata-------------------------------------------------------------------------------// 
// Stores the results array TimeStamp_Results in a File                                   //
// Input: Result Array                                                                     //
// Call:  savedata(TimeStamp_Results)                                                     //
// Output: None                                                                            //
// Globals: OutRow will be actualized                                                      //
//-----------------------------------------------------------------------------------------// 
proc savedata(){
   OutSPRFile = new File()
   sprint(OutSPRName, "Results_%s-%s%s-%s-%s_AMPA%gpS_GABA%gpS_E-GABA%gmV-%gHz.asc", PROGRAM, VERSION, DENOM, CELL, AP, gAMPA*1000, gGABA*1000, GABA_Rev, StimFreq)
   OutSPRFile.wopen(OutSPRName) 
   $o1.fprint(OutSPRFile, "\t%g")     
   OutSPRFile.close
}


// ________________________________________________________________________________________________
// ---- Start of Simulation -----------------------------------------------------------------------
// ________________________________________________________________________________________________


printf("Start Program_%s-%s%s-%s-%s_AMPA%gpS_GABA%gpS-_E-GABA%gmV-%gHz", PROGRAM, VERSION, DENOM, CELL, AP, gAMPA*1000, gGABA*1000, GABA_Rev, StimFreq)

// determine spike probability performed n = NumberRept repition of the simulations, each with random location/timing/strength of AMPA synapses
DetermineSpikeProbab(gAMPA, seed_AMPA) 

printf("\n -- Simulation finished -- \n\n")
savedata(TimeStamp_Results)
printf("Program_%s-%s%s-%s-%s_AMPA%gpS_GABA%gpS_eGABA%gmV)", PROGRAM, VERSION, DENOM, CELL, AP, gAMPA*1000, gGABA*1000,GABA_Rev)
printf(" terminated")
printf(" sucesfully")


Loading data, please wait...