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;
// ExciThresh_Detection-2sAlgo-BS_div-Erev_dif-gGABA_2_0.hoc
// Simulation to determine the excitation theshold for synaptic GABAergic inputs
// Variabel g_GABA up to 10 nS to check when AP are evoked
// Detection of AP within  2s
// 
// Author: Werner Kilb
// Version 2.0
// Date: 2-Aug-2021
//--------------------------------------------------
strdef VERSION, CELL, AP
VERSION = "2.0-Fine"
CELL = "BS"
AP = "ndrf"
printf("ExciThresh_Detection-2sAlgo_%s_%s_div-Erev_dif-gGABA, Version %s \n", CELL, AP, VERSION)

// 1. Parameters to adjust for simulation of sweep -------------------------------------------

    // ------- 1.1 GABAergic Parameters (tonic) ----------------------------------------------------------
    GABA_Rise = 0.5         // ms arbitraray Value
    GABA_Decay = 37         // ms from Lombardi et a. (2018)
    GABA_Time = 10

    RevPotNorm = -42.6        // Maximal Value of Reversal potential - Start from depolarized ! responses to estimate excitation
    RevPotSteps =  51       // Number of steps in reversal potential
    RevPotStepSize = -0.002   // Increase in rev Pot per step    


                            

    // ----- 1.3 Excitation Thresold Detection Parameters --------------------------------------------------------
    // --- We use a 15 step process to determine the fine-scale value for threshold GABAergic synaptic strength
    // --- Increase by Amplstep1 until AP, then decrease by AmplStep 2 until no AP, increase by 
    // --- Amplstep3 until AP, decrease by AmplStep 4 until no AP, increase by Amplstep5 until AP etc.
    AmplStep1 =   1            // increase in Injection current in third sweep
    AmplStep2 =   0.33         // decrease in Injection current in forth sweep
    AmplStep3 =   0.1          // increase in Injection current in fifth sweep
    AmplStep4 =   0.033        // decrease in Injection current in sixth sweep
    AmplStep5 =   0.01         // increase in Injection current in seventh sweep
    AmplStep6 =   0.0033       // decrease in Injection current in eigths sweep
    AmplStep7 =   0.001        // increase in Injection current in nineth sweep
    AmplStep8 =   0.00033      // decrease in Injection current in tenth sweep
    AmplStep9 =   0.0001       // increase in Injection current in eleventh sweep
    AmplStep10 =  0.000033     // decrease in Injection current in 12th sweep
    AmplStep11 =  0.00001      // increase in Injection current in 13th sweep
    AmplStep12 =  0.0000033    // decrease in Injection current in 14th sweep
    AmplStep13 =  0.000001     // increase in Injection current in 15th sweep
    AmplStep14 =  0.00000033   // decrease in Injection current in 16th sweep
    AmplStep15 =  0.0000001    // increase in Injection current in 17th sweep
    
    MaxAmpl = 10            // Maximal possible ampliutude 

    AP_Thres = -25          // Detection Threshold for APs (in mV) for Function Detect_APs()
    AP_Threshold = 0        // Valiable required to return AP-Threshold from Function Detect_ExThr_AP()
    NonAnalLatency = 5      // Latency after Start of Synaptic Pulse not analyzed 
    Anal_Interval = 990     // Max Timepoint after Synaptic Input Start analyzed for AP 


// 2. Define Variables and outputs ---------------------------------------------------------------

    ExThr_Value=0     //required to store ExThr to share between single runs of ExThr-detection algorithm

    // ----- 2.1 Runtime Variables --------------------------------------------------------------------------
    tstop = 1000          // Duration
    v_init = -50.5       // Initial voltage
    dt = 0.025            // Step Interval in ms
    steps_per_ms = 1     // Plot 5 points per ms
    celsius = 31         // measured at°C
    if (Anal_Interval >= tstop-GABA_Time){  // to prevent subscipt out of range errors
       printf("Adapted Anal_Inteval from %g",Anal_Interval)
       Anal_Interval = tstop-GABA_Time-1
       printf(" to %g \n",Anal_Interval)
    }
    ON = 1
    OFF = 0

    RepetitionIndex = 0

    // --- 2.2 Initialize Synapses ----------------------------------------------------------------------
       // Definition of synapse objects
       objref  GABA_Syn_Soma  

    // distribute synapses  -----------------------------------------------------------
       soma {
         GABA_Syn_Soma = new Exp2Syn(0.5)
         GABA_Syn_Soma.tau1 = GABA_Rise
         GABA_Syn_Soma.tau2 = GABA_Decay
//         GABA_Syn_Soma.e = GABA_Rev
       }
                                          

    // generate and link netstim object -----------------------------------------------
      objref GABA_Stim                             //generate Netstim object for synaptic stimulation
         GABA_Stim = new NetStim(0.5)
         GABA_Stim.number = 1
         GABA_Stim.start = GABA_Time
         GABA_Stim.noise = 0


      objref Net_GABA_Syn_Soma   //Generate Netcon objects to connect Stim with the synapse   
         soma{ 
            Net_GABA_Syn_Soma = new NetCon(GABA_Stim, GABA_Syn_Soma, 0, 0, 0)
            activestate = Net_GABA_Syn_Soma.active(OFF)                             //deactivate Netcon by default
                                                                                    // Value of activestate not used
         }



    // ----- 2.3. Data vectors ----------------------------------------------------------------------------------------------
    // ---- Input vectors and files ---------------------------------------------------------------------------------
    objref voltvec                                             // Vectors linked to parameter pointers
    objref dvdt_volt, d2vdt2_volt, d3vdt3_volt                 // Vectors with voltage derivatives to determine AP threshold

    voltvec = new Vector()
    voltvec.record(&v(.5))                                     // Link Volt vector (mesured in soma) to Output-Vectors

    dvdt_volt = new Vector()
    d2vdt2_volt = new Vector()
    d3vdt3_volt = new Vector()

    // ---- Output vectors and files ---------------------------------------------------------------------------------
    objref ExThrShiftResults, APThrResults, SubThrResults       // Matrices for outputs
                                                               // Definition of the output matrix
                                                               // ExThrCtrl  Index of synapse location[0] ISL[1] . . . . [ISL n+1]
                                                               // ERev[0]   ExThrShift [0,0]              RS[0,1] . . .  RS[0  , n+1] 
                                                               // ERev[1]          RS [1,0]              RS[1,1] . . .  RS[1  , n+1]
                                                               // .
                                                               // ERev[i]          RS [i,0]              RS[i,1] . . .  RS[i  , n+1]
    ExThrShiftResults = new Matrix() 
    strdef OutExThrName                                         // Define Name of Output-File for ExThr-Shift Matrix
    objref OutExThrFile                                         // Define Output File for ExThr-Shift Matrix

    APThrResults = new Matrix()
    strdef OutAPThrName                                         // Define Name of Output-File for AP-Thresold Matrix
    objref OutAPThrFile                                         // Define Output File for AP-Thresold Matrix

    SubThrResults = new Matrix()
    strdef OutSubThrName                                         // Define Name of Output-File for AP-Thresold Matrix
    objref OutSubThrFile                                         // Define Output File for AP-Thresold Matrix


    // ----------- Initialize OutputMatrixes -------------------------------------------------------------------------------
    ExThrShiftResults.resize(RevPotSteps + 3, 3)                    // Note that in addition to n_snapse * dendritic synapses there is one somatic synapse, therefore N_SYNAPSES + 2
    APThrResults.resize(RevPotSteps + 3, 3)
    SubThrResults.resize(RevPotSteps + 3, 3)


    objref RepetitionFile
    strdef ReptFileName


// ------------Procedures and Functions ---------------------------------------------------------
// ----------------------------------------------------------------------------------------------

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

// Procedure Init_Matrix ------------------------------------------------------------------------//
// Inputs: none                                                                                  //
// Call: Init_Matrix()                                                                           //
// Empties Matrix and put line/column identifier                                                  //
// ----------------------------------------------------------------------------------------------//
proc Init_Matrix(){
    ExThrShiftResults.zero()
    APThrResults.zero()
    for i=1, RevPotSteps {                                                // write line Identifier
        ExThrShiftResults.x(i , 0) =  RevPotNorm + (i-1)*RevPotStepSize
        APThrResults.x(i , 0) =  RevPotNorm + (i-1)*RevPotStepSize
        SubThrResults.x(i , 0) =  RevPotNorm + (i-1)*RevPotStepSize
    }
}    


// Procedure Change_Synap_Ampl ------------------------------------------------------------------//
// Inputs: $1 Objref to NetCon Object                                                            //
//         $2 ObjRef to NetStim Object                                                           //
//         $3 Objref to Synpase (Exp2Syn)                                                        //
//         $4 Amplitude of GABA response in nS                                                   //
//                                                                                               //
// call Change_Synap_Ampl(Net_GABA, GABA_Stim, GABA_Synapse, GABA_Ampl)                          //
// Generates a new NetCon Object with the actual Amplitude                                       //
// ----------------------------------------------------------------------------------------------//
proc Change_Synap_Ampl (){
      $o1 = new NetCon($o2, $o3, 0, 0, $4)
} 


// GABA_Hyperpol --------------------------------------------------------------------------------//
// Checks whether GABA induced a hyperpol response i.e. can not be excitatory                    //
// Inputs: $1 Objref to NetCon Object                                                            //
//         $2 ObjRef to NetStim Object                                                           //
//         $3 Objref to Synpase (Exp2Syn)                                                        //
// Call:   GABA_Hyperpol(Net_GABA_Syn_Soma, GABA_Stim, GABA_Syn_Soma)                            //     
// Other Variables are  global variables                                                         //
// returns   Rheobase as double                                                                  //
// ----------------------------------------------------------------------------------------------//
func GABA_Hyperpol(){local TestAmpl 
   TestAmpl = 0.05                                            //strong stimulus
   $o3.e = RevPot
   Change_Synap_Ampl($o1, $o2, $o3, TestAmpl)
   run()
   RepetitionIndex +=1
   pause(0.1)
   if (voltvec.min((GABA_Time)/dt,(GABA_Time + NonAnalLatency)/dt-1) < v_init) {
      return 1
   }else{
      return 0
   }
}


// Function Detect_APs --------------------------------------------------------------------------//
// Inputs: $1 Objref to Inputvector                                                              //
//         $2 Begin analysis interval                                                            //
//         $3 End Analysis interval                                                              //
//         $4 Theshold in mV                                                                     //
//                                                                                               //
// call Detect_APs(voltvec, beginindex, endindex, threshold)                                     //
// returns   Number of APs as double                                                             //
//                                                                                               //
// Detets the numer of APs in a voltvector                                                       //
// ----------------------------------------------------------------------------------------------//
func Detect_APs() {local i, Refract, APs
  Refract = 0
  APs = 0
  for i=$2, $3-1 {
    if (Refract == 0 && $o1.x[i]>$4){            //look for v crossing threshold in depolarizing direction
         APs = APs + 1           // increase number of APs by one
         Refract = 1           // switch to refractory period
    }
    if (Refract == 1 && $o1.x[i]<$4-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
     }        
  }
  return APs
}   //  End of function


// Function Detect_AP_Theshold ------------------------------------------------------------------//
// Inputs: $1 Objref to Inputvector                                                              //
//                                                                                               //
// call Detect_APs(voltvec, beginindex, endindex)                                                //
// returns AP threshold in mVs as double                                                         //
//                                                                                               //
// Detecs the threshold of an APs in a voltvector                                                //
// Definition of Threshold is the voltage when d3v/dt3 is maximal                                //
// Detects the treshold of the Ap with the highest depolarization rate                           //
// Works properly only if called for a trace with only one AP                                    //
// ----------------------------------------------------------------------------------------------//
func Detect_AP_Theshold() {local i 
  dvdt_volt.deriv($o1,1)                           //first derivative of Voltvector
                                                   // dt-stepsize not considered, as rel. values are sufficient
  d2vdt2_volt.deriv(dvdt_volt, 1)                  //second derivative of Voltvector
  d3vdt3_volt.deriv(d2vdt2_volt, 1)                //third derivative of Voltvector

  i = d3vdt3_volt.max_ind                          // look backward from max for first element < 20% of Maximum Value
  if (i < $o1.size) {
     return $o1.x[i+2]                                // d3vdt3_volt is missing the first 2 elements 
  }else{
     return $o1.x[i]                                  // casts a doofus solution for index out of range :-( 
  }
} // end of function


// Function Detect_ExThr_AP ---------------------------------------------------------------------//
// Detects the ExThr with a 11 step algorithm                                                //
// Inputs: $1 Objref to NetCon Object                                                            //
//         $2 ObjRef to NetStim Object                                                           //
//         $3 Objref to Synpase (Exp2Syn)                                                        //
// Call:   Detect_ExThr_AP_Full(Net_GABA, GABA_Stim, GABA_Synapse)                               //     
// Other Variables are  global variables                                                         //
// returns   Exitation-Threshold as double                                                       //
//                                                                                               //
// ----------------------------------------------------------------------------------------------//
func Detect_ExThr_AP() {local PulseAmpl, NumberOfAPs, AP_Threshold
   PulseAmpl = 0
   NumberOfAPs = 0
   
   //first loop with large steps to detect suprathreshold injection current
   while (NumberOfAPs == 0 && PulseAmpl < MaxAmpl) {    
      PulseAmpl = PulseAmpl + AmplStep1                                          // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      // run Simulation
      run()
      RepetitionIndex +=1
       // identify Number of APs
       NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)                 // End of Interval delayed by 2 ms to detect AP that are triggered at the very end of the stim
    }

   //second loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0  && PulseAmpl < MaxAmpl && (PulseAmpl - AmplStep2 > 0)) {         
      PulseAmpl = PulseAmpl - AmplStep2                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //third loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0  && PulseAmpl < MaxAmpl) {    
       PulseAmpl = PulseAmpl + AmplStep3                   // increase PulseAmpl until AP was detected
       Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
       run()
       RepetitionIndex +=1
       NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //forth loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0 && PulseAmpl < MaxAmpl && (PulseAmpl - AmplStep4 > 0)) {         
      PulseAmpl = PulseAmpl - AmplStep4                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //fifth loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0  && PulseAmpl < MaxAmpl) {    
      PulseAmpl = PulseAmpl + AmplStep5              // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      run()
      RepetitionIndex +=1
       NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //sixth loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0  && PulseAmpl < MaxAmpl && (PulseAmpl - AmplStep6 > 0)) {         
      PulseAmpl = PulseAmpl - AmplStep6                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //seventh loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0 && PulseAmpl < MaxAmpl) {    
      PulseAmpl = PulseAmpl + AmplStep7              // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //eigth loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0  && PulseAmpl < MaxAmpl && (PulseAmpl - AmplStep8 > 0)) {         
      PulseAmpl = PulseAmpl - AmplStep8                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //nineth loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0 && PulseAmpl < MaxAmpl) {    
      PulseAmpl = PulseAmpl + AmplStep9              // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //10th loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0  && PulseAmpl < MaxAmpl && (PulseAmpl - AmplStep2 > 10)) {         
      PulseAmpl = PulseAmpl - AmplStep10                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //11th loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0 && PulseAmpl < MaxAmpl) {
      PulseAmpl = PulseAmpl + AmplStep11             // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //12th loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0  && PulseAmpl < MaxAmpl && (PulseAmpl - AmplStep12 > 0)) {         
      PulseAmpl = PulseAmpl - AmplStep12                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //13th loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0 && PulseAmpl < MaxAmpl) {
      PulseAmpl = PulseAmpl + AmplStep13             // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //14th loop with middle step decrease to detect subthreshold injection current
   while (NumberOfAPs > 0  && PulseAmpl < MaxAmpl) {         
      PulseAmpl = PulseAmpl - AmplStep14                    // decrease PulseAmpl until no AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("-")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }

   //15th loop with small step increase to detect suprathreshold injection current
   while (NumberOfAPs == 0 && PulseAmpl < MaxAmpl) {
      // store subtreshold values from previous sweep (voltvec hat did not contain APs)
      SubAPThr = voltvec.max((GABA_Time + NonAnalLatency)/dt,(GABA_Time + Anal_Interval)/dt-1) 
      PulseAmpl = PulseAmpl + AmplStep15             // increase PulseAmpl until AP was detected
      Change_Synap_Ampl($o1, $o2, $o3, PulseAmpl)
        printf("+")
      run()
      RepetitionIndex +=1
      NumberOfAPs = Detect_APs(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
    }


    // Detect and Store AP Threshold 
    if (PulseAmpl < MaxAmpl) {
       dvdt_volt.fill(0)
       d2vdt2_volt.fill(0) 
       d3vdt3_volt.fill(0)
       AP_Threshold = Detect_AP_Theshold(voltvec, (GABA_Time + NonAnalLatency)/dt, (GABA_Time + Anal_Interval)/dt, AP_Thres)
       APThrResults.x(RevPotStep+1, 1) = AP_Threshold
       SubThrResults.x(RevPotStep+1, 1) = SubAPThr
       printf(" - AP-Thres=%g (mV); Sub-Thres=%g (mV); Thres-Curr=%g (pA) \n",AP_Threshold, SubAPThr, (PulseAmpl*1000))
       return PulseAmpl*1000   //pulse amplitude in pA!
    } else {                                            //Return Error Code
       APThrResults.x(RevPotStep+1, 1) = 999
       SubThrResults.x(RevPotStep+1, 1) = 999
       printf(" no Spike detected (insufficient injection current) \n")
       return 999
    }         
}


// Procedure Analysze_Synapse -------------------------------------------------------------------//
// Analyte the Effect of one GABA synapse                                                        //
// Loops through all GABA Synapses and detects the ExThr of them                                 //  
// Inputs: no input                                                                              //
// Call:   Analysze_Synapse()                                                                    //     
// Variables are  global variables                                                               //
// ----------------------------------------------------------------------------------------------//
proc Analyze_Synapse(){

        activestate = Net_GABA_Syn_Soma.active(ON)
        printf("\n Start simulation of GABA synapse at soma \n")

        // ---------------- inner loop ------------------------------------------------------------------------------------------------------------------------------------
        for RevPotStep = 0, RevPotSteps -1 {
            RevPot = RevPotNorm + RevPotStep * RevPotStepSize
            GABA_Syn_Soma.e = RevPot
            printf("%s-%s Sweep %g of %g: ERev=%g(mV) ",CELL,AP,RevPotStep, RevPotSteps, RevPot)
            ExThr_Value = Detect_ExThr_AP(Net_GABA_Syn_Soma, GABA_Stim, GABA_Syn_Soma)   
            ExThrShiftResults.x(RevPotStep+1, 1) = ExThr_Value                   //store value in output Matrix           
        } // end of inner loop (RevPot stepping)
     
}     // end of function Analyse Synapses



// xxxxxxxx Simulation starts here xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

     // ---- initialize the data matrices
    Init_Matrix()  

    // ---- generate output files                       
                                          
    OutExThrFile = new File()                                              
    sprint(OutExThrName, "ExThr-2sAlgo_%s-%s_div-Erev_div-gGABA_%s.asc", CELL, AP, VERSION)
    OutExThrFile.wopen(OutExThrName)

    OutAPThrFile = new File()
    sprint(OutAPThrName, "APThreshold-2sAlgo_%s-%s_div-Erev_div-gGABA_%s.asc", CELL, AP, VERSION)
    OutAPThrFile.wopen(OutAPThrName)

    OutSubThrFile = new File()
    sprint(OutSubThrName, "SubThreshold-2sAlgo_%s-%s_div-Erev_div-gGABA_%s.asc", CELL, AP, VERSION)
    OutSubThrFile.wopen(OutSubThrName)

   RepetitionFile = new File()
   sprint(ReptFileName, "ExThr-2sAlgo_%s-%s_div-Erev_div-gGABA_%s_NrRept.asc", CELL, AP, VERSION)
   RepetitionFile.wopen(ReptFileName)

    // --- Now analyse the excitation threshold of all GABA synapses
    Analyze_Synapse()
 
    // ---- Save Dataset for these synapses  
    ExThrShiftResults.fprint(OutExThrFile, "\t%g")     
    OutExThrFile.close 
    printf("ExThr shift data stored\n")
    APThrResults.fprint(OutAPThrFile, "\t%g")     
    OutAPThrFile.close
    printf("AP-threshold data stored \n") 
    SubThrResults.fprint(OutSubThrFile, "\t%g")
    OutSubThrFile.close
    printf("Sub-threshold data stored Synapse \n") 

    RepetitionFile.printf("For this Simulation %g repetitions are required!", RepetitionIndex)
    RepetitionFile.close()
     

    // End of Programm
    printf("Program terminated regularily\n")    

Loading data, please wait...