Effects of spinal cord stimulation on WDR dorsal horn network (Zhang et al 2014)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:168414
" ... To study the mechanisms underlying SCS (Spinal cord stimulation), we constructed a biophysically-based network model of the dorsal horn circuit consisting of interconnected dorsal horn interneurons and a wide dynamic range (WDR) projection neuron and representations of both local and surround receptive field inhibition. We validated the network model by reproducing cellular and network responses relevant to pain processing including wind-up, A-fiber mediated inhibition, and surround receptive field inhibition. ..." See paper for more.
Reference:
1 . Zhang TC, Janik JJ, Grill WM (2014) Modeling effects of spinal cord stimulation on wide-dynamic range dorsal horn neurons: influence of stimulation frequency and GABAergic inhibition. J Neurophysiol 112:552-67 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism:
Cell Type(s): Wide dynamic range neuron;
Channel(s):
Gap Junctions:
Receptor(s): GabaA; AMPA; NMDA; Glutamate; Glycine;
Gene(s):
Transmitter(s):
Simulation Environment: NEURON;
Model Concept(s):
Implementer(s): Zhang, Tianhe [tz5@duke.edu];
Search NeuronDB for information about:  GabaA; AMPA; NMDA; Glutamate; Glycine;
/
ZhangEtAl2014
Foreman SCS
CellTemplates.hoc *
CellTempList.dat *
CellTypeVector.txt *
CellVector.txt *
Connectivities_Surround_ERev_70.xls
Coordinates_Trial.xlsx *
DelayVector.txt *
ERevVector.txt
EX_Cell_filenames.dat *
EX_Cell_filenamesH.dat *
EX_Cell_filenamesM.dat *
EX_Cell_SynapseID.dat *
EX_Cell_Synapses_OneEX_Zone2_SCS.txt *
FromVector.txt *
MakeNetwork.hoc *
MATLAB_Afferent_Spikes_Foreman.mat
MATLAB_Afferent_Spikes_Foreman_Grouped.mat
nrnmech.dll *
RunSim_Foreman.hoc
S_NetStim_SynapseID.dat *
SG_Cell_filenames.dat *
SG_Cell_filenamesH.dat *
SG_Cell_filenamesM.dat *
SG_Cell_Pair_1_Vm.png *
SG_Cell_SynapseID.dat *
SG_Cell_Synapses_OneEX_Multiconn_Glycine.dat *
SG_Cell_Synapses_OneEX_Zone2_SCS.txt *
SGSCS_Cell_filenames.dat *
SGSCS_Cell_filenamesH.dat *
SGSCS_Cell_filenamesM.dat *
SGSCS_Cell_SynapseID.dat *
SGSCS_Cell_Synapses_OneEX_Zone2_SCS.txt *
SGZ2_Cell_Synapses_OneEX_Zone2_SCS.txt *
Shell.hoc
SpikeStatsVector.txt
SpikeTimesVector.txt
SynapseVector.txt *
T_Cell_filenames.dat *
T_Cell_filenamesH.dat *
T_Cell_filenamesM.dat *
T_Cell_SpikeCount.png *
T_Cell_SynapseID.dat *
T_Cell_Synapses_OneEX_Zone2_SCS.txt *
ThresholdVector.txt *
ToVector.txt *
WeightVector.txt
XVector.txt *
YVector.txt *
ZVector.txt *
                            
//Modified by Tianhe Zhang from NEURON Book Chapter 11 (Carnevale and Hines) to import necessary values from connectivity files.
//NOTE: For the "import spike times" simulation, spike times will be imported IN THE SIMULATION RUNNER ROUTINE.

//This script is generally a black box i.e. nothing needs to be changed here when only altering the network/cell properties.  However, if a new parameter needs to be incorporated
//(e.g. adding an "ERevVector.txt" import to run KCC2 simulations; see "importcritvalues()"), this should be altered to reflect changes.

////////// import critical values ///////////////// Alteration from NEURON code earlier.  This will allow for parameters to be imported from MATLAB.

objref InCells, InX, InY, InZ, InTypes, InFrom, InTo, InSynapse, InWeights, InDelays, InThresh
objref CellsVec, XVec, YVec, ZVec, CellTypeVec, FromVec, ToVec,  SynapseVec, WeightsVec, DelaysVec, ThreshVec


proc importcritvalues() { //These values (which define the cells and connectivities) of the neural network MUST be imported.

	//Cells//
	InCells = new File()
	CellsVec = new Vector()
	InCells.ropen("CellVector.txt")
	CellsVec.scanf(InCells)
	InCells.close()

	//Cell Coordinates//
	InX = new File()
	XVec = new Vector()
	InX.ropen("XVector.txt")
	XVec.scanf(InX)
	InX.close()

	InY = new File()
	YVec = new Vector()
	InY.ropen("YVector.txt")
	YVec.scanf(InY)
	InY.close()

	InZ = new File()
	ZVec = new Vector()
	InZ.ropen("ZVector.txt")
	ZVec.scanf(InZ)
	InZ.close()

	//Cell Types//  CellTypeVec contains a list of indices corresponding to the indices of CellsVec where cell types switch.

	InTypes = new File()
	CellTypeVec = new Vector()
	InTypes.ropen("CellTypeVector.txt")
	CellTypeVec.scanf(InTypes)
	InTypes.close()


	//Connections//
	InFrom = new File()
	FromVec = new Vector()
	InFrom.ropen("FromVector.txt")
	FromVec.scanf(InFrom)
	InFrom.close()

	InTo = new File()
	ToVec = new Vector()
	InTo.ropen("ToVector.txt")
	ToVec.scanf(InTo)
	InTo.close()

	InSynapse = new File()
	SynapseVec = new Vector()
	InSynapse.ropen("SynapseVector.txt")
	SynapseVec.scanf(InSynapse)
	InSynapse.close()

	//
}

importcritvalues()

//Import data regarding cell parameters (e.g. tau, intervals).  Not importing a value means default in NEURON is used, so optional (if value doesn't matter).

//Import data regarding connection parameters (weights, delays, synaptic thresholds).  Not importing a value means default in NEURON is used.

proc importWeights(){
	InWeights = new File()
	WeightsVec = new Vector()
	InWeights.ropen("WeightVector.txt")
	WeightsVec.scanf(InWeights)
	InWeights.close()
}

proc importDelays(){
	InDelays = new File()
	DelaysVec = new Vector()
	InDelays.ropen("DelayVector.txt")
	DelaysVec.scanf(InDelays)
	InDelays.close()
}

proc importThresh(){
	InThresh = new File()
	ThreshVec = new Vector()
	InThresh.ropen("ThresholdVector.txt")
	ThreshVec.scanf(InThresh)
	InThresh.close()
}

//proc importERev(){  

//Reversal potentials for synapses.  Commented out for Wind-Up simulations, but essential to reproduce KCC2 results.  Make sure synapses that use same ion
//have same reversal potential (KCC2: rest potentials unaffected).

//	InERev = new File()
//	ERevVec = new Vector()
//	InERev.ropen("ERevVector.txt")
//	ERevVec.scanf(InERev)
//	InERev.close()
//}

importWeights()
importDelays()
importThresh()

//Greater than equal to.

func ge() {
  if ($1<$2) {
    $1=$2
  }
  return $1
}

////////// create a network [NEURON generated] //////////
// argument is desired number of cells

objref CellTempFile
strdef cmd

proc createnet() { local p, q //Input 1: # of Cells.  Input 2: # of connections (not categorized yet.  NOTE THAT USER MUST MANUALLY CHANGE "cell_append" ACCORDING TO HOW MANY TYPES OF CELLS THERE ARE)
  $1 = ge($1,2) // force net to have at least two cells
  ncell = $1
  // so we can make a new net without having to exit and restart
  nclist.remove_all()
  cells.remove_all()
  CellTempFile = new File()
  CellTempFile.ropen("CellTempList.dat")

  for p = 1, CellTypeVec.size()-1{
	  CellTempFile.gets(cmd) //Scan in relevant cell template command
	  for q = CellTypeVec.x[p-1], CellTypeVec.x[p]-1{
		j = q
		execute1(cmd) //Run object generation command once for each relevant cell.  See "CellTempList.dat" for exact commands (list of "VARIABLE = new CELLCLASS").
	  }
  }
  CellTempFile.close()

  for p=0, $2-1 {  //Connect cells that were created above based on the layout described in the Connections Excel file.
    nc_append(FromVec.x[p], ToVec.x[p], SynapseVec.x[p], WeightsVec.x[p], DelaysVec.x[p]) //CELL COUNT STARTS AT ZERO.
	print p
  }
  objref netcon  // leave no loose ends (see nc_append())
  strdef cmd     // same as above, but for strings.
}

////////// specify parameters for each individual connection in network//////////
// call this settau() to avoid conflict with scalar tau

proc settau() { local i
	temp = $2
    	if (temp>0) {
    	cells.object($1).pp.tau = $2
   	 }
}

// reworked for individual cells/connections.
proc interval() { local i
	temp = $2
    	if (temp>0) {
   	 cells.object($1).pp.invl = $2
    	}
}

proc weight() { local i
    nclist.object($1).weight = $2
}

proc delay() { local i
  $2 = ge($2,0)  // min del is 0 ms
  del = $2
    nclist.object($1).delay = $2
}

proc thresh() { local i
    nclist.object($1).threshold = $2
}


////////// actually execute the above.  Easier if encapsulated into a single process //////////
createnet(CellsVec.size(), FromVec.size())

proc ConnParamSetter(){ local k
	for k=0, FromVec.size()-1{
		weight(k, WeightsVec.x[k])
		delay(k, DelaysVec.x[k])
		thresh(k, ThreshVec.x[k])
	}
}
ConnParamSetter()

Loading data, please wait...