Dentate gyrus network model (Tejada et al 2014)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:155568
" ... Here we adapted an existing computational model of the dentate gyrus (J Neurophysiol 93: 437-453, 2005) by replacing the reduced granule cell models with morphologically detailed models coming from (3D) reconstructions of mature cells. ... Different fractions of the mature granule cell models were replaced by morphologically reconstructed models of newborn dentate granule cells from animals with PILO-induced Status Epilepticus, which have apical dendritic alterations and spine loss, and control animals, which do not have these alterations. This complex arrangement of cells and processes allowed us to study the combined effect of mossy fiber sprouting, altered apical dendritic tree and dendritic spine loss in newborn granule cells on the excitability of the dentate gyrus model. Our simulations suggest that alterations in the apical dendritic tree and dendritic spine loss in newborn granule cells have opposing effects on the excitability of the dentate gyrus after Status Epilepticus. Apical dendritic alterations potentiate the increase of excitability provoked by mossy fiber sprouting while spine loss curtails this increase. "
References:
1 . Tejada J, Garcia-Cairasco N, Roque AC (2014) Combined role of seizure-induced dendritic morphology alterations and spine loss in newborn granule cells with mossy fiber sprouting on the hyperexcitability of a computer model of the dentate gyrus. PLoS Comput Biol 10:e1003601 [PubMed]
2 . Tejada J, Arisi GM, García-Cairasco N, Roque AC (2012) Morphological alterations in newly born dentate gyrus granule cells that emerge after status epilepticus contribute to make them less excitable. PLoS One 7:e40726 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism: Dentate gyrus;
Cell Type(s): Dentate gyrus granule GLU cell; Dentate gyrus mossy cell; Dentate gyrus basket cell; Dentate gyrus hilar cell;
Channel(s): I L high threshold; I T low threshold; I K; I h; I K,Ca; I Calcium; I Potassium;
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: NEURON;
Model Concept(s): Activity Patterns; Spatio-temporal Activity Patterns; Epilepsy; Neurogenesis;
Implementer(s): Tejada, Julian [julian.tejada at gmail.com];
Search NeuronDB for information about:  Dentate gyrus granule GLU cell; I L high threshold; I T low threshold; I K; I h; I K,Ca; I Calcium; I Potassium;
/
TejadaEtAl2014
readme.html
bgka.mod *
CaBK.mod *
ccanl.mod *
Gfluct2.mod *
gskch.mod *
hyperde3.mod *
ichan2.mod *
LcaMig.mod *
nca.mod *
tca.mod *
BasketCell.hoc
DG.hoc
HIPPCell.hoc
init.hoc
mosinit.hoc
MossyCell.hoc
n01.hoc
n02.hoc
n03.hoc
n04.hoc
n05.hoc
n06.hoc
n07.hoc
n08.hoc
n09.hoc
n10.hoc
n100.hoc
n101.hoc
n102.hoc
n103.hoc
n104.hoc
n105.hoc
n106.hoc
n107.hoc
n108.hoc
n109.hoc
n11.hoc
n110.hoc
n111.hoc
n112.hoc
n113.hoc
n114.hoc
n115.hoc
n116.hoc
n117.hoc
n118.hoc
n12.hoc
n13.hoc
n14.hoc
n15.hoc
n16.hoc
n17.hoc
n18.hoc
n19.hoc
n20.hoc
n21.hoc
n22.hoc
n23.hoc
n24.hoc
n25.hoc
n26.hoc
n27.hoc
n28.hoc
n29.hoc
n30.hoc
n31.hoc
n32.hoc
n33.hoc
n34.hoc
n35.hoc
n36.hoc
n37.hoc
n38.hoc
n39.hoc
n40.hoc
n41.hoc
n42.hoc
n43.hoc
n44.hoc
n45.hoc
n46.hoc
n47.hoc
n48.hoc
n49.hoc
n50.hoc
n51.hoc
n52.hoc
n53.hoc
n54.hoc
n55.hoc
n56.hoc
n57.hoc
n58.hoc
n59.hoc
n60.hoc
n61.hoc
n62.hoc
n63.hoc
n64.hoc
n65.hoc
n66.hoc
n67.hoc
n68.hoc
n69.hoc
n70.hoc
n71.hoc
n72.hoc
n73.hoc
n74.hoc
n75.hoc
n76.hoc
n77.hoc
n78.hoc
n79.hoc
n80.hoc
n81.hoc
n82.hoc
n83.hoc
n84.hoc
n85.hoc
n86.hoc
n87.hoc
n88.hoc
n89.hoc
n90.hoc
n91.hoc
n92.hoc
n93.hoc
n94.hoc
n95.hoc
n96.hoc
n97.hoc
n98.hoc
n99.hoc
NumberOfDendrites.dat
Sample_100A0Y.dat
Sample_50A50P.dat
Sample_50A50Y.dat
screenshot.png
SimCtrl.ses
                            
/* Dentage Gyrus network model associated with the papers: 

J. Tejada, G.M. Arisi, N. Garcia-Cairasco, A.C. Roque, Morphological alterations in newly born dentate gyrus granule cells that emerge after status epilepticus contribute to make them less excitable, PLoS ONE. 7 (2012) e40726. doi:10.1371/journal.pone.0040726.

J. Tejada, N. Garcia-Cairasco, A.C. Roque, Combined role of seizure-induced dendritic morphology alterations and spine loss in newborn granule cells with mossy fiber sprouting on the hyperexcitability of a computer model of the dentate gyrus, PLoS Comput. Biol. 10 (2014) e1003601. doi:10.1371/journal.pcbi.1003601.

julian.tejada@gmail.com - 2014  
*/

secondorder=2 
tstep=0
period=2
steps_per_ms = 10 
dt=0.1
tstop=300	//1500

// define network size
ngcell = 500
nbcell = 6
nmcell = 15
nhcell = 6
npp = 1



//***********************************************************************************************
// Load templates of granule cells with realistic morphology
objref Gcell[ngcell]

// newborn control cells
load_file("n01.hoc")
load_file("n02.hoc")
load_file("n03.hoc")
load_file("n04.hoc")
load_file("n05.hoc")
load_file("n06.hoc")
load_file("n07.hoc")
load_file("n08.hoc")
load_file("n09.hoc")
load_file("n10.hoc")
load_file("n11.hoc")
load_file("n12.hoc")
load_file("n13.hoc")
load_file("n14.hoc")
load_file("n15.hoc")
load_file("n16.hoc")
load_file("n17.hoc")
load_file("n18.hoc")
load_file("n19.hoc")
load_file("n20.hoc")

// newborn PILO cells

load_file("n21.hoc")
load_file("n22.hoc")
load_file("n23.hoc")
load_file("n24.hoc")
load_file("n25.hoc")
load_file("n26.hoc")
load_file("n27.hoc")
load_file("n28.hoc")
load_file("n29.hoc")
load_file("n30.hoc")
load_file("n31.hoc")
load_file("n32.hoc")
load_file("n33.hoc")
load_file("n34.hoc")
load_file("n35.hoc")
load_file("n36.hoc")
load_file("n37.hoc")
load_file("n38.hoc")
load_file("n39.hoc")
load_file("n40.hoc")

// Mature cells

load_file("n41.hoc")
load_file("n42.hoc")
load_file("n43.hoc")
load_file("n44.hoc")
load_file("n45.hoc")
load_file("n46.hoc")
load_file("n47.hoc")
load_file("n48.hoc")
load_file("n49.hoc")
load_file("n50.hoc")
load_file("n51.hoc")
load_file("n52.hoc")
load_file("n53.hoc")
load_file("n54.hoc")
load_file("n55.hoc")
load_file("n56.hoc")
load_file("n57.hoc")
load_file("n58.hoc")
load_file("n59.hoc")
load_file("n60.hoc")
load_file("n61.hoc")
load_file("n62.hoc")
load_file("n63.hoc")
load_file("n64.hoc")
load_file("n65.hoc")
load_file("n66.hoc")
load_file("n67.hoc")
load_file("n68.hoc")
load_file("n69.hoc")
load_file("n70.hoc")
load_file("n71.hoc")
load_file("n72.hoc")
load_file("n73.hoc")
load_file("n74.hoc")
load_file("n75.hoc")
load_file("n76.hoc")
load_file("n77.hoc")
load_file("n78.hoc")
load_file("n79.hoc")
load_file("n80.hoc")
load_file("n81.hoc")
load_file("n82.hoc")
load_file("n83.hoc")
load_file("n84.hoc")
load_file("n85.hoc")
load_file("n86.hoc")
load_file("n87.hoc")
load_file("n88.hoc")
load_file("n89.hoc")
load_file("n90.hoc")
load_file("n91.hoc")
load_file("n92.hoc")
load_file("n93.hoc")
load_file("n94.hoc")
load_file("n95.hoc")
load_file("n96.hoc")
load_file("n97.hoc")
load_file("n98.hoc")
load_file("n99.hoc")
load_file("n100.hoc")
load_file("n101.hoc")
load_file("n102.hoc")
load_file("n103.hoc")
load_file("n104.hoc")
load_file("n105.hoc")
load_file("n106.hoc")
load_file("n107.hoc")
load_file("n108.hoc")
load_file("n109.hoc")
load_file("n110.hoc")
load_file("n111.hoc")
load_file("n112.hoc")
load_file("n113.hoc")
load_file("n114.hoc")


// ************************************************************************************************************
// Load templates of the other cells
objref Bcell[nbcell]
load_file("BasketCell.hoc")

//***********************************************************************************************************
objref Mcell[nmcell]
load_file("MossyCell.hoc")

//***********************************************************************************************************
objref Hcell[nhcell]
load_file("HIPPCell.hoc")
//***********************************************************************************************************

// Create the stimulation pattern

objref PPSt[npp]

	begintemplate PPstim

	public pp, connect_pre, is_art, acell
	create acell
	objref pp

	proc init() {
		actemp() 		
	}
		proc actemp() {
				acell pp = new NetStim(.5)
				pp.interval = 100
				pp.number = 1
				pp.start = 5
				}

	func is_art() {return 1}
	proc connect_pre() {acell $o2 = new NetCon(pp, $o1)}

	endtemplate PPstim
//###############################################################################################################

// Read the number of proximal and distal dendrites of each cells from a txt file
objref arq1
arq1 = new File()
arq1.ropen("NumberOfDendrites.dat")
objref NumOfPD, NumOfDD
NumOfPD= new Vector(116,0)
NumOfDD= new Vector(116,0)
for i=1,114 {
 NumOfPD.x[i] =  arq1.scanvar()
 NumOfDD.x[i] =  arq1.scanvar()
}
arq1.close()

// Load the order in which each cells will be positioned in the network
arq1 = new File()
arq1.ropen(FileName)
objref NetTopology, Counter, Randomizer
NetTopology= new Vector(500,0)
Counter= new Vector(116,0)
Randomizer = new Vector(36,0)
for i=0,499 {
 NetTopology.x[i] =  arq1.scanvar()
}
arq1.close()

CellPilo = 0
i_control = 0
i_pilo = 0



// Create the copy of each cells from the templates 
for i=0,499 {
    
//     print i, "Primeiro"
    if (NetTopology.x[i] == 1) {Gcell[i] = new GranuleCell1(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1 
     } 
    if (NetTopology.x[i] == 2) {Gcell[i] = new GranuleCell2(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 3) {Gcell[i] = new GranuleCell3(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }
    if (NetTopology.x[i] == 4) {Gcell[i] = new GranuleCell4(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 5) {Gcell[i] = new GranuleCell5(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 6) { Gcell[i] = new GranuleCell6(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 7) { Gcell[i] = new GranuleCell7(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 8) {Gcell[i] = new GranuleCell8(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 9) {Gcell[i] = new GranuleCell9(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 10) {Gcell[i] = new GranuleCell10(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 11) {Gcell[i] = new GranuleCell11(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 12) {Gcell[i] = new GranuleCell12(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 13) {Gcell[i] = new GranuleCell13(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 14) {Gcell[i] = new GranuleCell14(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 15) {Gcell[i] = new GranuleCell15(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
      } 
    if (NetTopology.x[i] == 16) {Gcell[i] = new GranuleCell16(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 17) {Gcell[i] = new GranuleCell17(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 18) {Gcell[i] = new GranuleCell18(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 19) {Gcell[i] = new GranuleCell19(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 20) { Gcell[i] = new GranuleCell20(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }  
    if (NetTopology.x[i] == 21) { Gcell[i] = new GranuleCell21(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   

    if (NetTopology.x[i] == 22) { Gcell[i] = new GranuleCell22(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   
    if (NetTopology.x[i] == 23) {Gcell[i] = new GranuleCell23(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   
    if (NetTopology.x[i] == 24) { Gcell[i] = new GranuleCell24(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   

    if (NetTopology.x[i] == 25) {Gcell[i] = new GranuleCell25(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   
    if (NetTopology.x[i] == 26) { Gcell[i] = new GranuleCell26(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   

    if (NetTopology.x[i] == 27) { Gcell[i] = new GranuleCell27(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   
    if (NetTopology.x[i] == 28) { Gcell[i] = new GranuleCell28(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }  
    if (NetTopology.x[i] == 29) { Gcell[i] = new GranuleCell29(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   
    if (NetTopology.x[i] == 30) { Gcell[i] = new GranuleCell30(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }     
    if (NetTopology.x[i] == 31) { Gcell[i] = new GranuleCell31(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }     
    if (NetTopology.x[i] == 32) { Gcell[i] = new GranuleCell32(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }     
    if (NetTopology.x[i] == 33) { Gcell[i] = new GranuleCell33(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 34) { Gcell[i] = new GranuleCell34(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }     
    if (NetTopology.x[i] == 35) { Gcell[i] = new GranuleCell35(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }   
    if (NetTopology.x[i] == 36) { Gcell[i] = new GranuleCell36(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }  
    if (NetTopology.x[i] == 37) { Gcell[i] = new GranuleCell37(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }  
    if (NetTopology.x[i] == 38) {  Gcell[i] = new GranuleCell38(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }  
    if (NetTopology.x[i] == 39) { Gcell[i] = new GranuleCell39(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }  
    if (NetTopology.x[i] == 40) { Gcell[i] = new GranuleCell40(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
    if (NetTopology.x[i] == 41) { Gcell[i] = new GranuleCell41(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 42) {  Gcell[i] = new GranuleCell42(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 43) {  Gcell[i] = new GranuleCell43(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 44) { Gcell[i] = new GranuleCell44(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 45) { Gcell[i] = new GranuleCell45(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 46) { Gcell[i] = new GranuleCell46(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 47) { Gcell[i] = new GranuleCell47(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 48) { Gcell[i] = new GranuleCell48(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 49) {  Gcell[i] = new GranuleCell49(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 50) { Gcell[i] = new GranuleCell50(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 51) { Gcell[i] = new GranuleCell51(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 52) {  Gcell[i] = new GranuleCell52(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     }
     
     for i=0,499 {
     if (NetTopology.x[i] == 53) {  Gcell[i] = new GranuleCell53(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
      if (NetTopology.x[i] == 54) {  Gcell[i] = new GranuleCell54(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 55) {  Gcell[i] = new GranuleCell55(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 56) { Gcell[i] = new GranuleCell56(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 57) { Gcell[i] = new GranuleCell57(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 58) { Gcell[i] = new GranuleCell58(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 59) { Gcell[i] = new GranuleCell59(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 60) {  Gcell[i] = new GranuleCell60(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 61) {  Gcell[i] = new GranuleCell61(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 62) { Gcell[i] = new GranuleCell62(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 63) { Gcell[i] = new GranuleCell63(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 64) {  Gcell[i] = new GranuleCell64(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 65) { Gcell[i] = new GranuleCell65(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 66) { Gcell[i] = new GranuleCell66(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 67) {Gcell[i] = new GranuleCell67(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 68) { Gcell[i] = new GranuleCell68(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 69) { Gcell[i] = new GranuleCell69(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 70) {Gcell[i] = new GranuleCell70(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 71) { Gcell[i] = new GranuleCell71(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 72) { Gcell[i] = new GranuleCell72(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 73) { Gcell[i] = new GranuleCell73(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 74) { Gcell[i] = new GranuleCell74(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 75) {  Gcell[i] = new GranuleCell75(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 76) {  Gcell[i] = new GranuleCell76(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 77) { Gcell[i] = new GranuleCell77(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 78) {  Gcell[i] = new GranuleCell78(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 79) { Gcell[i] = new GranuleCell79(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 80) {  Gcell[i] = new GranuleCell80(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     }
     
     for i=0,499 {
      if (NetTopology.x[i] == 81) {Gcell[i] = new GranuleCell81(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 82) { Gcell[i] = new GranuleCell82(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 83) { Gcell[i] = new GranuleCell83(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 84) {Gcell[i] = new GranuleCell84(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 85) { Gcell[i] = new GranuleCell85(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 86) {Gcell[i] = new GranuleCell86(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 87) {Gcell[i] = new GranuleCell87(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 88) { Gcell[i] = new GranuleCell88(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 89) { Gcell[i] = new GranuleCell89(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 90) { Gcell[i] = new GranuleCell90(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 91) { Gcell[i] = new GranuleCell91(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 92) { Gcell[i] = new GranuleCell92(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 93) {  Gcell[i] = new GranuleCell93(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 94) { Gcell[i] = new GranuleCell94(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 95) { Gcell[i] = new GranuleCell95(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 96) {  Gcell[i] = new GranuleCell96(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 97) {  Gcell[i] = new GranuleCell97(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 98) {  Gcell[i] = new GranuleCell98(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 99) { Gcell[i] = new GranuleCell99(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 100) { Gcell[i] = new GranuleCell100(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 101) { Gcell[i] = new GranuleCell101(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 102) {  Gcell[i] = new GranuleCell102(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 103) {  Gcell[i] = new GranuleCell103(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 104) {  Gcell[i] = new GranuleCell104(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 105) { Gcell[i] = new GranuleCell105(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 106) { Gcell[i] = new GranuleCell106(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 107) { Gcell[i] = new GranuleCell107(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 108) { Gcell[i] = new GranuleCell108(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 109) { Gcell[i] = new GranuleCell109(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 110) { Gcell[i] = new GranuleCell110(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 111) {Gcell[i] = new GranuleCell111(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 112) { Gcell[i] = new GranuleCell112(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     }
     if (NetTopology.x[i] == 113) { Gcell[i] = new GranuleCell113(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
     if (NetTopology.x[i] == 114) { Gcell[i] = new GranuleCell114(Counter.x(NetTopology.x[i]))
     Counter.x(NetTopology.x[i]) +=1
     } 
}

	for i=0, nbcell-1 {Bcell[i] = new BasketCell(i)}
	for i=0, nmcell-1 {Mcell[i] = new MossyCell(i)}
	for i=0, nhcell-1 {Hcell[i] = new HIPPCell(i)}
	for i =0, npp-1 {PPSt[i] = new PPstim(i)}

objref nclist, netcon, cells, net_c, net_d, net_gr,  net_bc,  net_mc,  net_hc,  vbc2gc, vmc2gc, vhc2gc
{  cells = new List()
nclist = new List()
}
 func cell_append() {cells.append($o1) 
	return cells.count -1}

func nc_append() {

	if ($3 >= 0 )	{
		cells.object($1).connect_pre(cells.object($2).pre_list.object($3),netcon)
		netcon.weight = $4	netcon.delay = $5	netcon.threshold = $6
	} 
	nclist.append(netcon)
	return nclist.count-1
		}

func is_connected() {local i, c
	c=0
	for i=0, nclist.count-1 {
	net_c= nclist.object(i)
	if (($o1 == net_c.postcell())  && ($o2 == net_c.precell())) {c=1}
}
return c
}


objref vbc2gc, vmc2gc, vhc2gc, vgc2bc, vbc2bc, vmc2bc, vhc2bc, vgc2mc, vbc2mc, vmc2mc, vhc2mc, vgc2hc, vmc2hc,vgc2gc

	{
	vgc2bc = new Vector(nbcell, 0)
	vbc2bc = new Vector(nbcell, 0)
	vmc2bc = new Vector(nbcell, 0)
	vhc2bc = new Vector(nbcell, 0)

	vgc2mc = new Vector(nmcell, 0)
	vbc2mc = new Vector(nmcell, 0)
	vmc2mc = new Vector(nmcell, 0)
	vhc2mc = new Vector(nmcell, 0)


	vgc2hc = new Vector(nhcell, 0)
	vmc2hc = new Vector(nhcell, 0)

	vbc2gc = new Vector(ngcell, 0)
	vmc2gc = new Vector(ngcell, 0)
	vhc2gc = new Vector(ngcell, 0)
	vgc2gc = new Vector(ngcell, 0)
	}


//initiating randm number generator

objref rdsynb, rdsyna, rdgc2hc, rdgc2bc, rdgc2mc, rdbc2gc, rdbc2bc, rdbc2mc
objref rdmc2gc1, rdmc2gc2, rdmc2bc, rdmc2mc, rdmc2mc1, rdmc2hc, rdhc2gc, rdhc2bc, rdhc2mc, rdgc2gc
objref RandUniform, rdm_1 
ropen("/proc/uptime")		// get a seed  that is changing based on the processing time
	 {			
 	rseed = fscan()		// so simulation will not start with the same seed
	ropen()		
	}
//************************************GC***********************************************
rdgc2bc = new Random(rseed)			// use for syn.connections 
proc new_rdgc2bc() {rdgc2bc.discunif(-1,1)}
new_rdgc2bc()
rdgc2mc = new Random(rseed)			// use for syn.connections 
proc new_rdgc2mc() {rdgc2mc.discunif(0,2)}
new_rdgc2mc()
rdgc2hc = new Random(rseed)			// use for syn.connections 
proc new_rdgc2hc() {rdgc2hc.discunif(-2 , 2)}
new_rdgc2hc()
rdgc2gc = new Random(rseed)			// use for syn.connections 
proc new_rdgc2gc() {rdgc2gc.discunif(-50, 50)}
new_rdgc2gc()

//************************************BC***********************************************
rdbc2gc = new Random(rseed)			// use for syn.connections 
proc new_rdbc2gc() {rdbc2gc.discunif(0, ngcell-1)}
new_rdbc2gc()
rdbc2bc = new Random(rseed)			// use for syn.connections 
proc new_rdbc2bc() {rdbc2bc.discunif(ngcell, ngcell+nbcell-1)}
new_rdbc2bc()
rdbc2mc = new Random(rseed)			// use for syn.connections 
proc new_rdbc2mc() {rdbc2mc.discunif(ngcell+nbcell, ngcell+nbcell+nmcell-1)}
new_rdbc2mc()

//*************************************MC********************************************
rdmc2gc1 = new Random(rseed)			// use for syn.connections 
proc new_rdmc2gc1() {rdmc2gc1.discunif(25, 175)}
new_rdmc2gc1()
rdmc2gc2 = new Random(rseed)			// use for syn.connections 
proc new_rdmc2gc2() {rdmc2gc2.discunif(-175, -25)}
new_rdmc2gc2()
rdmc2bc = new Random(rseed)			// use for syn.connections 
proc new_rdmc2bc() {rdmc2bc.discunif(-3,3)}
new_rdmc2bc()
rdmc2mc = new Random(rseed)			// use for syn.connections 
proc new_rdmc2mc() {rdmc2mc.discunif(ngcell+nbcell, ngcell+nbcell+nmcell-1)}
new_rdmc2mc()
rdmc2mc1 = new Random(rseed)			// use for syn.connections 
proc new_rdmc2mc1() {rdmc2mc1.discunif(-3, 3)}
new_rdmc2mc1()
rdmc2hc = new Random(rseed)			// use for syn.connections 
proc new_rdmc2hc() {rdmc2hc.discunif(-2, 2)}
new_rdmc2hc()
//*************************************HC********************************************

rdhc2gc = new Random(rseed)			// use for syn.connections 
proc new_rdhc2gc() {rdhc2gc.discunif(0, ngcell-1)}
new_rdhc2gc()
rdhc2bc = new Random(rseed)			// use for syn.connections 
proc new_rdhc2bc() {rdhc2bc.discunif(ngcell, ngcell+nbcell-1)}
new_rdhc2bc()
rdhc2mc = new Random(rseed)			// use for syn.connections 
proc new_rdhc2mc() {rdhc2mc.discunif(ngcell+nbcell, ngcell+nbcell+nmcell-1)}
new_rdhc2mc()

//*********************************************************************************

rdsyna = new Random(rseed)		// initialize random distr.
proc new_rdsyna() {rdsyna.discunif(0, 1)}
new_rdsyna()

rdsynb = new Random(rseed)		// initialize random distr.
proc new_rdsynb() {rdsynb.discunif(0, 3)}
new_rdsynb()

//**************************Sinapse realistic networks*******************************

RandUniform = new Random(rseed) 


//	NETWORK INITIATION
	for i = 0, ngcell-1 {cell_append(Gcell[i])} // cells 0-4 GCs
	for i = 0, nbcell-1 {cell_append(Bcell[i])} // cells 5-6 BC
	for i = 0, nmcell-1 {cell_append(Mcell[i])} // cell 7 MC
	for i = 0, nhcell-1 {cell_append(Hcell[i])} // cell 8 HC
	for i = 0, npp-1 {cell_append(PPSt[i])}	// cell 9 PP


//**************Preforant Path  synaptic connections ******************************
proc initNet() { local i,j,k,l/*, contador8, contador2b*/

// contador8 = 0
for i=0, npp-1 {
	for j=0, 99 {	//ngcell-1{
	// Cada dendrito de cada neurônio recebe sinais do PP
	for k=0, NumOfDD.x[NetTopology.x[j]] {
// 	
		  
// 	print 	 "Random number ", Randomizer.x[NumOfDD.x[NetTopology.x[j]]], "j ", j
	nc_append(i+ngcell+nbcell+nmcell+nhcell, j, k, 2e-2, 3, 10)  
	}
	}
	}

	for j=0, 0 { 	// 15% of MCs have OML dendrites
	 npost = rdmc2mc.repick()
	dbr = rdsynb.repick()
	if ((is_connected(MossyCell[npost-ngcell-nbcell], PPstim[0]) == 0) && (npost < ngcell+nbcell+3)) {
	nc_append(ngcell+nbcell+nmcell+nhcell, npost, dbr, 0.5e-2, 3, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr
	} else {	j -= 1	print "pp2mc"}
	}

// }
//******************************************************************************************

//**************Granule Cell post synaptic connections ******************************


for  i=0, ngcell-1 {

	for j=0, 1 {

	if (i < 84) { a=0}
	if ((i > 83) && (i < 166)) { a=1}
	if ((i > 165) && (i < 252)) { a=2}
	if ((i > 251) && (i < 336)) { a=3}
	if ((i > 335) && (i < 420)) { a=4}
	if ((i > 419) && (i < 500)) { a=5}

	 Gauz3 = rdgc2bc.repick()
	if (a+Gauz3 > 5) {npost = a+Gauz3-6 }
	if (a+Gauz3 < 0) {npost = a+Gauz3+6} 
	if ((a+Gauz3 > -1) && (a+Gauz3 < 6)) {npost = a+Gauz3}
	dbr = rdsynb.repick()
// 	print npost, a
	// Basket to Granule
	if ((is_connected(BasketCell[npost], Gcell[i]) == 0) && (vgc2bc.x[npost] < 180))  {
	nc_append(i, ngcell+npost, dbr+2, 4.7e-3, .8, 10)  // Gcell[3] to Bcell[1]
	
// 	print i, npost, dbr+2
	vgc2bc.x[npost]  +=1
	} else {j -= 1	/*print "sdtf"*/}
	}

	for j=0, 0 {
	if (i < 100) { a=0}
	if ((i > 99) && (i < 200)) { a=1}
	if ((i > 199) && (i < 300)) { a=2}
	if ((i > 299) && (i < 400)) { a=3}
	if ((i > 399) && (i < 500)) { a=4}
	b=a*3
	 npost = rdgc2mc.repick()
	dbr = rdsynb.repick()
//	print npost, b
	// MC to granule
	if ((is_connected(MossyCell[npost+b], Gcell[i]) == 0) && (vgc2mc.x[npost+b] < 38)){
	nc_append(i, ngcell+nbcell+npost+b, dbr+4, 0.2e-3, 1.5, 10)  // Gcell[3] to Bcell[1]
// 	print npost+b, dbr+4
	vgc2mc.x[npost+b] +=1
	} else {	j -= 1	/*print "mdtf"*/}
	}

	for j=0, 2 {
	if (i < 84) { a=0}
	if ((i > 83) && (i < 166)) { a=1}
	if ((i > 165) && (i < 252)) { a=2}
	if ((i > 251) && (i < 336)) { a=3}
	if ((i > 335) && (i < 420)) { a=4}
	if ((i > 419) && (i < 500)) { a=5}
	 Gauz3 = rdgc2hc.repick()
	if (a+Gauz3 > 5) {npost = a+Gauz3-6 }
	if (a+Gauz3 < 0) {npost = a+Gauz3+6} 
	if ((a+Gauz3 > -1) && (a+Gauz3 < 6)) {npost = a+Gauz3}
	dbr = rdsynb.repick()
	// HIPP to Granule
	if ((is_connected(HIPPCell[npost], Gcell[i]) == 0) && (vgc2hc.x[npost] < 270)) {
	nc_append(i, ngcell+nbcell+nmcell+npost, dbr, 0.5e-3, 1.5, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr
	vgc2hc.x[npost] +=1
	} else {j -= 1	/*print "hhhh"*/}
	}
	// 10% sprouting = 10 cells connections
	for j=0, 10  {
	 Gauz3 = rdgc2gc.repick()
//print Gauz3
	if (i+Gauz3 > 499) {npost = i+Gauz3-500 }
	if (i+Gauz3 < 0) {npost = i+Gauz3+500} 
	if ((i+Gauz3 > -1) && (i+Gauz3 < 500)) {npost = i+Gauz3}

	// granule to sprout
// 	for j=0, NumOfPD.x[NetTopology.x[j]]/3  {
	// Spine loss represented as a lost connection
	
// 	print "npost", npost
	SpineLossOdds = rdsynb.repick()
	if ((NetTopology.x[npost] < 41) && (SpineLossOdds == 0) && (SpineLossEnable == 1)) {
	  j -= 1  
	  contador2b += 1
	  print "contador2b ", contador2b, "SPINE LOSS Gcell"
	  if (contador2b > 5000) {
	    print "Please try again, the network connections were not completed."
	    stop
	  }
	  
        } else {  
	dbr = rdsyna.repick()
	
	      if ((is_connected(Gcell[npost], Gcell[i]) == 0) && (vgc2gc.x[npost] < 15)) {
      // 	  for k=0, NumOfPD.x[NetTopology.x[npost]]/2 {
		Randomizer.x[1] = 0
		for l=2, 35 {
		  Alea = RandUniform.repick() 
		  Numero = abs(Alea) - int(abs(Alea))
		  Randomizer.x[l] = 1 + (int(Numero * ((l - 1) + 1)))
		  Randomizer.x[l] -= 1
		
		}
      // 		nc_append(i, npost, Randomizer.x[NumOfPD.x[NetTopology.x[npost]]] + (NumOfDD.x[NetTopology.x[npost]]*2) + NumOfPD.x[NetTopology.x[npost]] + 1, 2e-3, .8, 10) // original value 
		      
		      nc_append(i, npost, Randomizer.x[NumOfPD.x[NetTopology.x[npost]]] + (NumOfDD.x[NetTopology.x[npost]]*2) + NumOfPD.x[NetTopology.x[npost]] + 1, 2e-3, .8, 10)  // Gcell[3] to Bcell[1]
      //       	  print i, npost, dbr+8
		      
      // 	  }
		vgc2gc.x[npost] +=1
	      
	      } else {j -= 1	
      // 	  print "gc2gc" 
      // 	  print "origen", i, "destino", npost
		Counter8 += 1
		if  (Counter8 > NumOfPD.x[NetTopology.x[j]]) {
		  Gauz3 = rdgc2gc.repick()
		  if (i+Gauz3 > 499) {npost = i+Gauz3-500 }
		  if (i+Gauz3 < 0) {npost = i+Gauz3+500} 
		  if ((i+Gauz3 > -1) && (i+Gauz3 < 500)) {npost = i+Gauz3}
		  Counter8 = 0
		}
	      }
	
	  
	}
	}
}
//******************************************************************************************

//**************Basket Cell post synaptic connections ******************************



for  i=0, nbcell-1 {
	
		for j=0, 99 {
	 npost = rdbc2gc.repick()
	 Sinapsis = (NumOfDD.x[NetTopology.x[npost]] * 2) +  NumOfPD.x[NetTopology.x[npost]] 
	// Granule to BC
	if ((is_connected(Gcell[npost], BasketCell[i]) == 0) && (vbc2gc.x[npost] < 2)) {
	nc_append(i+ngcell, npost, Sinapsis, 1.6e-3, .85, 10)  // Gcell[3] to Bcell[1]
	vbc2gc.x[npost] +=1
// 	print i, npost, 6, "aqui"
	} else {j -= 1	print "BC2GC"}
	}

	for j=0, 1 {
	 npost = rdbc2bc.repick()
	dbr = rdsyna.repick()
	if ((is_connected(BasketCell[npost-ngcell], BasketCell[i]) == 0) && (vbc2bc.x[npost-ngcell] < 3)) {
	nc_append(i+ngcell, npost, dbr+8, 7.6e-3, .8, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr+8
	vbc2bc.x[npost-ngcell] +=1
	} else {j -= 1	print "bc2bc"}
	}

	for j=0, 4 {
	 npost = rdbc2mc.repick()
	if ((is_connected(MossyCell[npost-ngcell-nbcell], BasketCell[i]) == 0) && (vbc2mc.x[npost-ngcell-nbcell] < 3)) {
	nc_append(i+ngcell, npost, 12, 1.5e-3, 1.5, 10)  // Gcell[3] to Bcell[1]
// 	print npost, 12
	vbc2mc.x[npost-ngcell-nbcell] +=1
	} else {	j -= 1	print "bc2mc"}
	}


}
//******************************************************************************************

//**************Mossy Cell post synaptic connections ******************************

}

proc initNet2() { local i,j,k, contador1, contador2, contador2b, contador3, contador4, contador5, contador6, contador7

contador1 = 0
contador2 = 0
contador2b = 0
contador3 = 0
contador4 = 0
contador5 = 0
contador6 = 0
contador7 = 0

for  i=0, nmcell-1 {
	if (i < 3) { y=0}
	if ((i > 2) && (i < 6)) { y=1}
	if ((i > 5) && (i < 9)) { y=2}
	if ((i > 8) && (i < 12)) { y=3}
	if ((i > 11) && (i < 15)) { y=4}
	
	for j=0, 99 {
	 Gauz1 = rdmc2gc1.repick()
// print Gauz1
	if (i*33+17+Gauz1 > 499) {
	 npost1 = i*33+17+Gauz1-500
	} else {npost1 =i*33+17+Gauz1}
	
// 	print "npost1", npost1
	
	SpineLossOdds = rdsynb.repick()
	if ((NetTopology.x[npost1] < 41) && (SpineLossOdds == 0) && (SpineLossEnable == 1)) {
	
	  j -= 1 
	  contador2b += 1
	  print "contador2b ", contador2b, "SPINE LOSS Mossy"
	  if (contador2b > 5000) {
	    print "Please try again, the network connections were not completed."
	    stop
	  }    
	  } else { 

// 	// -----------------  MC  to GC
	if ((is_connected(Gcell[npost1], MossyCell[i]) == 0) && (vmc2gc.x[npost1] < 7))  {
// 	  for k=0, NumOfPD.x[NetTopology.x[npost1]]/4 {
	    Randomizer.x[1] = 0
	    
	   for l=2, 35 {
	    Alea = RandUniform.repick() 
	    Numero = abs(Alea) - int(abs(Alea))
	    Randomizer.x[l] = 1 + (int(Numero * ((l - 1) + 1)))
	    	   
	    }	  
	    
	nc_append(i+ngcell+nbcell, npost1, Randomizer.x[NumOfPD.x[NetTopology.x[npost1]]] + NumOfDD.x[NetTopology.x[npost1]], 0.3e-3, 3, 10)  // Gcell[3] to Bcell[1]
	
	  print "MC2GC"
// 	  }
	vmc2gc.x[npost1] +=1
	print i, npost1, dbr+2
	} else {j -= 1	
	  print "MC2GC1"
	  contador1 += 1 
	  print "contador1 ", contador1
	  if (contador1 > 5000) {
	    stop
	  }
	}
	
	  
	}
// 	}
	}
	for j=0, 99 {
	 Gauz2 = rdmc2gc2.repick()

//print Gauz2
	if (i*33+17+Gauz2 < 0) {
	 npost2 =i*33+17+Gauz2+500
	} else {npost2 =i*33+17+Gauz2}
	
	
	SpineLossOdds = rdsynb.repick()
	if ((NetTopology.x[npost2] < 41) && (SpineLossOdds == 0) && (SpineLossEnable == 1)) {
	  j -= 1 
	  contador2b += 1
	  print "contador2b ", contador2b, "SPINE LOSS Mossy 2"
	  if (contador2b > 5000) {
	    print "Please try again, the network connections were not completed."
	    stop
	  }	  
	} else {  

	dbr = rdsyna.repick()
	// granule to MC
	
	if ((is_connected(Gcell[npost2], MossyCell[i]) == 0) && (vmc2gc.x[npost2] < 7))  {
// 	  for k=0, NumOfPD.x[NetTopology.x[npost2]]/4 {
	        Randomizer.x[1] = 0

	 for l=2, 35 {
	    Alea = RandUniform.repick() 
	    Numero = abs(Alea) - int(abs(Alea))
	    Randomizer.x[l] = 1 + (int(Numero * ((l - 1) + 1)))
	    
	}
	nc_append(i+ngcell+nbcell, npost2, Randomizer.x[NumOfPD.x[NetTopology.x[npost2]]] + NumOfDD.x[NetTopology.x[npost2]], 0.3e-3, 3, 10)  // Gcell[3] to Bcell[1]
// 	  }
	 
	vmc2gc.x[npost2] +=1
	print "GC2MC", i, npost2, dbr+2
	} else {j -= 1	
	  print "MC2GC2"
	  contador2 += 1
	  print "contador2 ", contador2
	  if (contador2 > 5000) {
	    stop
	  }
	}
	
	  
	  
	}
	}

	for j=0, 0 {
	 Gauz3 = rdmc2bc.repick()
	if (y+Gauz3 > 5) {npost = y+Gauz3-6}
	if (y+Gauz3 < 0) {npost = y+Gauz3+6} 
	if ((y+Gauz3 > -1) && (y+Gauz3 < 6)) {npost = y+Gauz3}
	dbr = rdsyna.repick()
	if ((is_connected(BasketCell[npost], MossyCell[i]) == 0) && (vmc2bc.x[npost] < 4) && (Gauz3 !=0)) {
	nc_append(i+ngcell+nbcell, ngcell+npost, dbr+6, 0.3e-3, 3, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr+6
	vmc2bc.x[npost] += 1
	} else {j -= 1	print "mc2bc"}
	}

	for j=0, 2 {
	 Gauz3 = rdmc2mc1.repick()
//print Gauz3
	if (i+Gauz3 > 14) {npost = i+Gauz3-15 }
	if (i+Gauz3 < 0) {npost = i+Gauz3+15} 
	if ((i+Gauz3 >-1) && (i+Gauz3 < 15)) {npost = i+Gauz3}
//print npost
	dbr = rdsynb.repick()
	if ((is_connected(MossyCell[npost], MossyCell[i]) == 0) && (vmc2mc.x[npost] < 4) && (Gauz3 != 0))  {
	nc_append(i+ngcell+nbcell, npost+ngcell+nbcell, dbr+8, 0.5e-3, 2, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr+8
	vmc2mc.x[npost] +=1
	} else {	j -= 1	
	  print "mc2mc"
	  contador4 += 1 
	  print "contador4 ", contador4
	  if (contador4 > 5000) {
	    stop
	  }
	  
	}
	}

	for j=0, 1 {
	 Gauz3 = rdmc2hc.repick()
	if (y+Gauz3 > 5) {npost = y+Gauz3-6}
	if (y+Gauz3 < 0) {npost = y+Gauz3+6} 
	if ((y+Gauz3 > -1) && (y+Gauz3 < 6)) {npost = y+Gauz3}
	dbr = rdsynb.repick()
	if ((is_connected(HIPPCell[npost], MossyCell[i]) == 0) && (vmc2hc.x[npost] < 6) && (Gauz3 != 0))  {
	nc_append(i+ngcell+nbcell, ngcell+nbcell+nmcell+npost, dbr+4, 0.2e-3, 3, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr+4
	vmc2hc.x[npost] +=1
	} else {	j -= 1	
	  print y, Gauz3, "mc2hc"
	  contador3 += 1
	  print "contador3 ", contador3
	  if (contador3 > 5000) {
	    stop
	  }
	}
	}


}
//******************************************************************************************
//**************HIPP Cell post synaptic connections ******************************
}
proc initNet3() { local i,j,l, contador1, contador2, contador2b, contador3, contador4, contador5, contador6, contador7

for  i=0, nhcell-1 {
	
		for j=0, 159 {
	 npost = rdhc2gc.repick()
	// For newborn cells, the odds of receive a connection is a half
	SpineLossOdds = rdsynb.repick()
	if ((NetTopology.x[npost] < 41) && (SpineLossOdds == 0) && (SpineLossEnable == 1)) {
	 j -= 1 
	  contador2b += 1
	  print "contador2b ", contador2b, "SPINE LOSS Hipp"
	  if (contador2b > 5000) {
	    print "Please try again, the network connections were not completed."
	    stop
	  }  
	  } else {
	
	dbr = rdsyna.repick()
	// Granule to HIPP
	if ((is_connected(Gcell[npost], HIPPCell[i]) == 0) && (vhc2gc.x[npost] < 7))  {
// 	  for k=0, NumOfDD.x[NetTopology.x[npost]]/4 {
	        Randomizer.x[1] = 0

	     for l=2, 35 {
	    Alea = RandUniform.repick() 
	    Numero = abs(Alea) - int(abs(Alea))
	    Randomizer.x[l] = 1 + (int(Numero * ((l - 1) + 1)))
	    
	     }
	     
	    
	nc_append(i+ngcell+nbcell+nmcell, npost, Randomizer.x[NumOfDD.x[NetTopology.x[npost]]] + NumOfDD.x[NetTopology.x[npost]] + NumOfPD.x[NetTopology.x[npost]] , 0.5e-3, 1.6, 10)  // Gcell[3] to Bcell[1]
// 	  }
// 	print "HIP2GC", i, npost, dbr+4
	  
	vhc2gc.x[npost] +=1  
	} else {j -= 1	
	  print "HC2GC"
	  contador5 += 1 
	  print "contador5 ", contador5
	  if (contador5 > 5000) {
	    stop
	  }
	}
	
	}
	}

	for j=0, 3 {
	 npost = rdhc2bc.repick()
	dbr = rdsyna.repick()
	if ((is_connected(BasketCell[npost-ngcell], HIPPCell[i]) == 0) && (vhc2bc.x[npost-ngcell] < 5))  {
	nc_append(i+ngcell+nbcell+nmcell, npost, dbr+10, 0.5e-3, 1.6, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr+10
	vhc2bc.x[npost-ngcell] += 1
	} else {j -= 1	
	  print "hc2bc"
	  contador6 += 1 
	  print "contador6 ", contador6
	  if (contador6 > 5000) {
	    stop
	  }
	}
	}

	for j=0, 3 {
	 npost = rdhc2mc.repick()
	dbr = rdsynb.repick()
	if ((is_connected(MossyCell[npost-ngcell-nbcell], HIPPCell[i]) == 0) && (vhc2mc.x[npost-ngcell-nbcell] < 2))  {
	nc_append(i+ngcell+nbcell+nmcell, npost, dbr+13, 1.5e-3, 1, 10)  // Gcell[3] to Bcell[1]
// 	print npost, dbr+13
	vhc2mc.x[npost-ngcell-nbcell] += 1
	} else {	j -= 1	
	  print "hc2mc"
	  contador7 += 1 
	  print "contador7 ", contador7
	  if (contador7 > 5000) {
	    stop
	  }
	  
	}
	}

}
}
//*********************************Print out Net cons*********************************************************
strdef strvar
objref dfile
dfile = new File()

proc saveNet(){ local i
	dfile.wopen("N2I10sp")
	dfile.printf("Precell \tpstcell \t Synapse \n")
	for i=0, nclist.count-1 {
	dfile.printf("%s\t%s\t%s\n", nclist.object[i].precell, nclist.object[i].postcell, nclist.object[i].syn)}

dfile.printf("TO BC\n GC \tBC \tMC \tHC \n")
for i= 0, nbcell-1 {dfile.printf("%d\t%d\t%d\t%d \n",  vgc2bc.x[i], vbc2bc.x[i], vmc2bc.x[i], vhc2bc.x[i])}
dfile.printf("TO MC\n GC \tBC \tMC \tHC \n")
for i= 0, nmcell-1 {dfile.printf("%d\t%d\t%d\t%d\n",  vgc2mc.x[i], vbc2mc.x[i], vmc2mc.x[i], vhc2mc.x[i])}
dfile.printf("TO HC \n GC\t MC\n")
for i= 0, nhcell-1 {dfile.printf("%d\t%d\n", vgc2hc.x[i], vmc2hc.x[i])}
dfile.printf("TO GC\n BC\t MC\t HC\t GC\n")
for i= 0, ngcell-1 {dfile.printf("%d\t%d\t%d\t%d\n", vbc2gc.x[i], vmc2gc.x[i], vhc2gc.x[i], vgc2gc.x[i])}
dfile.close()

}


//******************************************************************************************
strdef strmat
objref efile
efile = new File()

	efile.wopen("M2I10sp.txt")
	efile.printf("t\t")
	for i = 0, 49 {
	b = i*10
	efile.printf("%s\t", cells.object[b])}
	for i = 498, cells.count-2{
	efile.printf("%s\t", cells.object[i])}
	efile.printf("\n")
	efile.close("M2I10sp.txt")

proc sMatrix(){ local  j

	efile.aopen("M2I10sp.txt")
	efile.printf("%f\t", t)
	for i = 0, 49 {
	b = i*10
	efile.printf("%f\t", cells.object[b].soma.v(0.5))}
	for j =498, cells.count-2 {
	efile.printf("%f\t", cells.object[j].soma.v(0.5))}
	efile.printf("\n")
	efile.close("M2I10sp.txt")
}

objref  VmT
objref VmMat[cells.count-1]
VmT = new Vector()
for i=0, cells.count-2 {
	VmMat[i] = new Vector()
	}

proc VecMx() { local i
	VmT.append(t)
	for i=0, cells.count-2 {
		VmMat[i].append( cells.object[i].soma.v(0.5))
		}
	}
	
objref Spike[cells.count-1]
for i=0, cells.count-2 {
	Spike[i] = new Vector()
	}
strdef Spkstr
objref dfile
dfile = new File()


proc SpkMx() { local i, j
	for i=0, cells.count-2 {
		Spike[i].spikebin(VmMat[i], 0)
		}

	dfile.wopen("S2I10sp.txt")

	while(k <  VmT.size) {
	for j = 0, cells.count-2 {
	if(Spike[j].x[k] != 0) {
	dfile.printf("%f\t%d\n", VmT.x[k], j)}
	}
	k +=1 }
	dfile.close("S2I10sp.txt")
	}


objref r_plt
proc initrPlt() {
	r_plt = new Graph(0)
	r_plt.size(0, tstop,0, cells.count)
	r_plt.label(0.95, 0.02, "ms")
	r_plt.label(0.01, 0.82, "neu")
	r_plt.view(0,0, tstop, cells.count,320,20,300,230)
}
 initrPlt()

proc plotAP() { local i, a
	a=1
 	r_plt.erase()
	while(j < cells.count-2) {
	for i = 0, VmT.size-1 {
	if ((j > ngcell-1)&&(j < ngcell+nbcell-1)) { a=2}
	if ((j > ngcell+nbcell-1)&&(j < ngcell+nbcell+nmcell-1)) { a=3}
	if (j > ngcell+nbcell+nmcell-1) { a=4}
	if (Spike[j].x[i] == 1) {
	r_plt.mark(VmT.x[i], j, "T", 5, a, 1)}}
// 	print "Coordenadas"
// 	print i, j 
	j+=1}
	r_plt.flush()
	}


//################################################################################################
proc init() { local dtsav, temp, secsav
finitialize(v_init)
t = -1000
dtsav = dt
secondorder =0
dt= 10
	// if cvode is on, turn it off to do large fixed step
temp= cvode.active()
if (temp!=0) {cvode.active(0)}
while(t<-100) { fadvance() print t}
	//restore cvode if reqd
if (temp!=0) {cvode.active(1)}
dt = dtsav
secondorder =2
t = 0
if (cvode.active()){
cvode.re_init()
}else{
fcurrent()
}
//frecord_init()
}
proc continuerun() {local rt
	eventcount =0
	eventslow =1
	stoprun =0
	if (using_cvode_) {
	cvode.event($1)
	}
	while(t < $1 && stoprun == 0) {
	step()
	sMatrix()
	VecMx()
	rt = stopsw()
	if (rt > realtime) {
		realtime = rt
		if (!stdrun_quiet) fastflushPlot()
		doNotify()
		if (realtime == 2 && eventcount > 50) {
			eventslow = int(eventcount/50)+1
		}
		eventcount = 0
	}else{
		eventcount = eventcount +1
		if ((eventcount%eventslow) == 0) {
			doEvents()
		}
	}
	}
	flushPlot()
}

objectvar save_window_, rvp_
objectvar scene_vector_[4]
objectvar ocbox_, ocbox_list_, scene_, scene_list_
{ocbox_list_ = new List()  scene_list_ = new List()}

{
xpanel("RunControl", 0)
v_init = -60
xvalue("Init","v_init", 1,"stdinit()", 1, 1 )
xbutton("Init & Run","run()")
xbutton("Stop","stoprun=1")
runStopAt = 5
xvalue("Continue til","runStopAt", 1,"{continuerun(runStopAt) stoprun=1}", 1, 1 )
runStopIn = 1
xvalue("Continue for","runStopIn", 1,"{continuerun(t + runStopIn) stoprun=1}", 1, 1 )
xbutton("Single Step","steprun()")
t = 0
xvalue("t","t", 2 )
tstop = 300	//1500
xvalue("Tstop","tstop", 1,"tstop_changed()", 0, 1 )
dt = 0.1
xvalue("dt","dt", 1,"setdt()", 0, 1 )
steps_per_ms = 10	//40
xvalue("Points plotted/ms","steps_per_ms", 1,"setdt()", 0, 1 )
xpanel(344,321)
}


proc rrun(){
initNet()
initNet2()
initNet3()
saveNet()
run()
SpkMx()
}

rrun()
plotAP()

objectvar scene_vector_[1]
{doNotify()}
//quit()
// the below allows modelview to run
access Gcell[0].soma

// quit()

Loading data, please wait...