//-------------------------------------------------------------------- // Simulation of a single GDP //--------------------------------------------------------------------- // ------------Definition of Parameters ------------------------------- // -------------------------------------------------------------------- // seed for random function seed_AMPA = 8 seed_GABA = seed_AMPA + 2 // Define Cl--Concentration Cl_Steps = 6 // Number of Different [Cl-]i objref Cl_List Cl_List = new Vector(Cl_Steps) Cl_List.x[0] = 5 //mM Cl_List.x[1] = 10 Cl_List.x[2] = 15 Cl_List.x[3] = 25 Cl_List.x[4] = 35 Cl_List.x[5] = 50 // Determining Parameters GABA --------------------------- G_GABA = 0.000789 // synaptic weight according to miniature events DECAY_GABA = 37 P_GABA = 0.18 ngabasyn = 534 gninputs = 1 // number of inputs per synapse // Determination Parameters AMPA ------------------------------------ G_AMPA = 0.000305 * 1 nampasyn = 107 //Number of AMPA-Synapses // calculated was 107 aninputs = 1 // number of inputs per synapse tauAMPA_Steps = 5 // 5 different Permeabilities objref tauAMPA_List tauAMPA_List = new Vector(tauAMPA_Steps) // manually put desired Tau_Values in List tauAMPA_List.x[0] = 2 // in this case g_AMPA = 0 pure GABA Control tauAMPA_List.x[1] = 5 // synaptic decay tauAMPA_List.x[2] = 11 tauAMPA_List.x[3] = 37 tauAMPA_List.x[4] = 50 // Definition of various runtime parameters -------------------------- lenghtoutputvec = 6000 // Number of Lines for output (< 32000 for Excel-Figures) ndend=56 // Number of dendrites tstop = 1500 // Duration v_init = -60 // Initial voltage dt = 0.01 // Step Interval in ms // ------------Procedures and Functions ------------------------------- // -------------------------------------------------------------------- // Function MakeShort ---------------------------------------// // Inputs: $1 Objref to Inputvector // // $2 Objref to Outoutvector // // lenoutvec desired lendth of Outputvector // // // // Reduce Inputvec to Outputvev by averaging n elements // // n (reducing factor) = floor(Inputvec.size() / lenoutvec) // // ----------------------------------------------------------// obfunc MakeShort() {local i, n n = int($o1.size()/$3) $o2.resize($3) for i=0, $3-1 { $o2.x[i] = $o1.mean(i*n, (i+1)*n-1) } return $o2 } // End of function // ---------Definition of objects ------------------------------------- // -------------------------------------------------------------------- // Objects for Synapses --------------------------------------------------------- objref gabasyn[ngabasyn] // Definition of synapse objects objref ampasyn[nampasyn] // random function for localization of synapses objref rand_ampa_loc, rand_gaba_loc // random function for localization of synapses in which dendrite objref rand_ampa_dend, rand_gaba_dend // random function for synapses parameters objref rand_gaba_t, rand_gaba_g objref rand_ampa_t, rand_ampa_g // definition of Vectors for Gaba-Stimulation (t_vec = timestamps t_vecr = sorted timestamps, g_vec = rel conductance) objref gabastim[ngabasyn], gaba_t_vec[ngabasyn], gaba_t_vecr[ngabasyn], synpulsegaba[ngabasyn], gaba_g_vec[ngabasyn] // definition of Vectors for AMPA-Stimulation objref ampastim[nampasyn], ampa_t_vec[nampasyn], ampa_t_vecr[nampasyn], synpulseampa[nampasyn], ampa_g_vec[nampasyn] // Define vectors to link modelled parameter output --------------------------------- objref timevec, voltvec, clivec[ndend] // vectors linked to parameter-pointers objref clivec_aver // vectors for Averagees over all Dendrites objref shorttimevec, shortvoltvec, shortclivec, spacevec // shorter Vectors for output // Matrix for output 0 = time, 1 = Voltage, 2 = average Cli , 3 to 3+ndend, Cli n Dend[i] objref Outmatrix // Define Name of Output-File strdef OutFileName // Define Output File objref OutFile // Generate vectors and matrices ------------------------------------- voltvec = new Vector() timevec = new Vector() clivec_aver = new Vector() shortvoltvec = new Vector() shorttimevec = new Vector() shortclivec = new Vector() spacevec = new Vector() for i=0, ndend-1 { clivec[i] = new Vector() } Outmatrix = new Matrix() // Start of Input generation ------------------------------------------- // Initialize Random Functions ----------- rand_ampa_loc = new Random(seed_AMPA+1) rand_gaba_loc = new Random(seed_GABA+2) rand_ampa_dend = new Random(seed_AMPA+3) rand_gaba_dend = new Random(seed_GABA+4) rand_ampa_t = new Random(seed_AMPA+5) rand_ampa_g = new Random(seed_AMPA+6) rand_gaba_t = new Random(seed_GABA+7) rand_gaba_g = new Random(seed_GABA+8) //Define properties of random Function rand_gaba_t.normal(600, 9000) rand_gaba_g.normal(1, 0.28) //rel variance of GABA according to results rand_ampa_t.normal(650, 8500) rand_ampa_g.normal(1, 0.26) //rel variance of AMPA according to results // generate Vectors --- (gniputs, aninputs defines number of inputs per synapse) ------ for i = 0, ngabasyn-1 { gaba_t_vec[i] = new Vector(gninputs) gaba_t_vecr[i] = new Vector(gninputs) gaba_g_vec[i] = new Vector(gninputs) } for i = 0, nampasyn-1 { ampa_t_vec[i] = new Vector(aninputs) ampa_t_vecr[i] = new Vector(aninputs) ampa_g_vec[i] = new Vector(aninputs) } // Distribute GABA synapses ----------------------------------------------------------- for k=0, ngabasyn-1 { pos = rand_gaba_loc.uniform(0,ndend-1) pos2 = rand_gaba_dend.uniform (0.0001, 0.999) dend_0[pos]{ gabasyn[k] = new gaba(pos2) gabasyn[k].tau1 = 0.1 gabasyn[k].tau2 = DECAY_GABA gabasyn[k].P = P_GABA } } // distribute AMPA synapses ------------------------------------------------------------------------ for k=0, nampasyn-1 { pos = rand_ampa_loc.uniform(0,ndend-1) pos3 = rand_ampa_dend.uniform (0.0001, 0.999) dend_0[pos]{ ampasyn[k] = new Exp2Syn(pos3) ampasyn[k].tau1 = 0.1 } } //-- Simulation starts here ----------------------------------------------------------------- //------------------------------------------------------------------------------------------- //-- Outer Loop Variation of gAMPA ------------------- tauAMPA_Step = 0 while (tauAMPA_Step < tauAMPA_Steps){ //-- Set tau_AMPA of all AMPA synapses --- tau_AMPA = tauAMPA_List.x[tauAMPA_Step] for k=0, nampasyn-1 { ampasyn[k].tau2 = tau_AMPA } // Inner Loop Variation of Cl- -------------------------------------------------- Cl_Step = 0 while (Cl_Step < Cl_Steps){ // 1. define Cl- concentration ---------------------------------------------- forsec all { cli0_cldif_CA3_NKCC1_HCO3 = Cl_List.x[Cl_Step] cli_Start_cldif_CA3_NKCC1_HCO3 = Cl_List.x[Cl_Step] cli_cldif_CA3_NKCC1_HCO3 = Cl_List.x[Cl_Step] } // 2a. Generate timestamps/conductances for GABA synapses -------------------------------------- for f=0, ngabasyn-1 { for i=0, gninputs-1 { t = rand_gaba_t.repick() g = abs(rand_gaba_g.repick()) gaba_t_vec[f].x[i]=t gaba_g_vec[f].x[i]= G_GABA*g } } for f=0, ngabasyn-1 { gaba_t_vecr[f] = gaba_t_vec[f].sort() } // 2b. Generate timestamps/conductances for AMPA synapses -------------------------------------- for f=0, nampasyn-1 { for i=0, aninputs-1 { t = rand_ampa_t.repick() g = abs(rand_ampa_g.repick()) ampa_t_vec[f].x[i]=t if (tauAMPA_Step == 0){ ampa_g_vec[f].x[i]= 0 }else{ ampa_g_vec[f].x[i]= G_AMPA*g } } } for f=0, nampasyn-1 { ampa_t_vecr[f] = ampa_t_vec[f].sort() } // 3. generate Vecstim-vectors from the sorted timestamp-vectors ------------------------------- for i=0, ngabasyn-1 { gabastim[i] = new VecStim() gabastim[i].play(gaba_t_vecr[i]) // GABA stimulator } for i=0, nampasyn-1{ ampastim[i] = new VecStim() ampastim[i].play(ampa_t_vecr[i]) // AMPA stimulator } // 4. Play the Vecstim objects to the synapses --------------------------------------------- for i=0, ngabasyn-1 { synpulsegaba[i] = new NetCon(gabastim[i], gabasyn[i], 0, 0, gaba_g_vec[i].x[0]) } // GABA NetCon for i=0, nampasyn-1 { synpulseampa[i] = new NetCon(ampastim[i], ampasyn[i], 0, 0, ampa_g_vec[i].x[0]) } // Ampa NetCon // 5. Link Objects to Output-Vectors ----------------------------------- timevec.record(&t) // Time vector voltvec.record(&v(.5)) // Volt vector in soma for i=0, ndend-1 { clivec[i].record(&dend_0[i].cli(0.5)) } // 6. Run Simulation -------------------------------------------------------- if (tauAMPA_Step == 0){ printf("Sequence %g of %g; [Cl-]i = %g, gAMPA = %g, tau_AMPA = %g, seed-%g", (tauAMPA_Step*Cl_Steps+Cl_Step+1), (Cl_Steps*tauAMPA_Steps), Cl_List.x[Cl_Step], 0, tauAMPA_List.x[tauAMPA_Step], seed_AMPA) }else{ printf("Sequence %g of %g; [Cl-]i = %g, gAMPA = %g, tau_AMPA = %g, seed-%g", (tauAMPA_Step*Cl_Steps+Cl_Step+1), (Cl_Steps*tauAMPA_Steps), Cl_List.x[Cl_Step], G_AMPA, tauAMPA_List.x[tauAMPA_Step], seed_AMPA) } run() // 8. Put Data in Output Vector ------------------------------------------------------ MakeShort(timevec, shorttimevec, lenghtoutputvec) Outmatrix.resize(shorttimevec.size()+1, tauAMPA_Steps*Cl_Steps*3+1) Outmatrix.setcol(0, shorttimevec) spacevec.resize(shorttimevec.size()+1) //spavevec caries information about the properties during a loop) spacevec.fill(0) spacevec.x[0] = Cl_List.x[Cl_Step] spacevec.x[1] = tauAMPA_List.x[tauAMPA_Step] spacevec.x[2] = 777 Outmatrix.setcol(tauAMPA_Step*Cl_Steps*3+Cl_Step*3+1, spacevec) MakeShort(voltvec, shortvoltvec, lenghtoutputvec) Outmatrix.setcol(tauAMPA_Step*Cl_Steps*3+Cl_Step*3+2, shortvoltvec) // Calculate average [Cli] in dendrites ------- clivec_aver.mul(0) // empty vector for i=0, ndend-1 { clivec_aver.resize(clivec[i].size()) clivec_aver.add(clivec[i]) } clivec_aver.div(ndend) printf(", max [Cl-]i %g, min [Cl-]i %g \n", clivec_aver.max, clivec_aver.min) MakeShort(clivec_aver, shortclivec, lenghtoutputvec) Outmatrix.setcol(tauAMPA_Step*Cl_Steps*3+Cl_Step*3+3, shortclivec) // Goto next Cl- Concentration Cl_Step+=1 } // End inner loop --------------------------------- // Goto next tauAMPA tauAMPA_Step+=1 } // End of outer loop // Save the Data -------------------------------------------------------------------- OutFile = new File() sprint(OutFileName, "Result_GDP_NR_gGABA-0.789-nGABA-534_gAMPA-0305_div-TauAMPA_Div_Cl_Seed-%g.asc", seed_AMPA) OutFile.wopen(OutFileName) Outmatrix.fprint(OutFile, "\t%g") OutFile.close