Prosthetic electrostimulation for information flow repair in a neocortical simulation (Kerr 2012)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:141505
This model is an extension of a model (<a href="http://senselab.med.yale.edu/ModelDB/ShowModel.asp?model=138379">138379</a>) recently published in Frontiers in Computational Neuroscience. This model consists of 4700 event-driven, rule-based neurons, wired according to anatomical data, and driven by both white-noise synaptic inputs and a sensory signal recorded from a rat thalamus. Its purpose is to explore the effects of cortical damage, along with the repair of this damage via a neuroprosthesis.
Reference:
1 . Kerr CC, Neymotin SA, Chadderdon GL, Fietkiewicz CT, Francis JT, Lytton WW (2012) Electrostimulation as a prosthesis for repair of information flow in a computer model of neocortex IEEE Transactions on Neural Systems & Rehabilitation Engineering 20(2):153-60 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism: Neocortex;
Cell Type(s): Neocortex V1 pyramidal corticothalamic L6 cell; Neocortex V1 pyramidal intratelencephalic L2-5 cell; Neocortex V1 interneuron basket PV cell; Neocortex fast spiking (FS) interneuron; Neocortex spiny stellate cell;
Channel(s): I Chloride; I Sodium; I Potassium;
Gap Junctions:
Receptor(s): GabaA; AMPA; NMDA; Gaba;
Gene(s):
Transmitter(s): Gaba; Glutamate;
Simulation Environment: NEURON;
Model Concept(s): Activity Patterns; Deep brain stimulation; Information transfer; Brain Rhythms;
Implementer(s): Lytton, William [billl at neurosim.downstate.edu]; Neymotin, Sam [samn at neurosim.downstate.edu]; Kerr, Cliff [cliffk at neurosim.downstate.edu];
Search NeuronDB for information about:  Neocortex V1 pyramidal corticothalamic L6 cell; Neocortex V1 pyramidal intratelencephalic L2-5 cell; Neocortex V1 interneuron basket PV cell; GabaA; AMPA; NMDA; Gaba; I Chloride; I Sodium; I Potassium; Gaba; Glutamate;
/
neuroprosthesis
README
infot.mod *
intf6_.mod *
intfsw.mod *
misc.mod *
nstim.mod *
staley.mod *
stats.mod *
vecst.mod *
batch.hoc
boxes.hoc
bsmart.py
col.hoc
comparecausality.py
comparerasters.py
declist.hoc
decmat.hoc *
decnqs.hoc *
decvec.hoc
default.hoc *
drline.hoc *
filtutils.hoc
flexinput.hoc
grvec.hoc
infot.hoc *
init.hoc
intfsw.hoc
labels.hoc
local.hoc *
misc.h *
mosinit.hoc
network.hoc
nload.hoc
nqs.hoc
nqsnet.hoc
nrnoc.hoc
params.hoc
pyhoc.py
ratlfp.dat *
run.hoc
runsim
setup.hoc *
simctrl.hoc *
spkts.hoc *
staley.hoc *
stats.hoc *
stdgui.hoc *
syncode.hoc *
updown.hoc *
xgetargs.hoc *
                            
// $Id: intfsw.hoc,v 1.75 2010/09/12 02:02:50 samn Exp $ 
// load_file("intfsw.hoc")

print "Loading intfsw.hoc..."

{load_file("nqs.hoc")}
{load_file("drline.hoc")}
{load_file("boxes.hoc")}

//////////////////////////////////////////////////////////////////////////////////////
//                               some usage 
//
//  adj=AdjList() //creates adjacency list used by other functions, it is global obj
//                //that other functions use internally
//
//  this is a variable, users can define their own, but it's not needed for hoc code:
//  subs = 640/numc[SU] //# btwn 0 and 1 specifying % of cells to use in computation
//  of path length and/or clustering coefficient, it can be passed into the functions
//  
//  this type of sequence gets excitatory path length for net:
//  vd=GetNetEXL(-1,subs) // -1 means get full path lengths of ALL distances
//  vd.gzmean // this will give you path length value for net
//
//  this type of sequence gets excitatory cell clustering coefficient for net:
//  vc=GetNetEXCC(ix[DP],ixe[SU],subs) //excitatory (DP,SU) cell clustering coefficient
//  vc.gzmean // this will give you clustering coefficient value for net
//
//
//////////////////////////////////////////////////////////////////////////////////////

{declare("adj",nil,"vd",nil,"vc",nil,"allcells",0,"div","d[1][1]")}
{declare("nxadjg",nil,"vhistg","o[CTYPi+1]","vhistgd","o[CTYPi+1]","intfswb","nil")}
{declare("divnq",nil,"convnq",nil,"intfswbfl",1,"getactive",1,"loadednetworkx",0)}
{install_intfsw()}

obfunc AdjTab () { local idx,jdx localobj adj,vid
  if (verbose) printf("generating adjacency matrix")
  adj=new List()
  for idx=0,allcells-1 adj.append(new Vector(allcells))
  for idx=0,allcells-1{
    if(verbose && idx%100==0)printf(".")
    vid=GetDiv(idx)
    for jdx=0,vid.size-1 adj.o(idx).x(vid.x(jdx))=1
  }
  if (verbose) printf("\n")
  return adj
}

//* AdjList - get list of adjacency lists
//[optional] $1 = startid
//[optional] $2 = endid
//[optional] $3 = skip inhib cells from list
//[optional] $o4 = CE list - default uses global ce
obfunc AdjList () { local idx,jdx,startid,endid,ct,dv,skipinhib localobj adj,vid,vtmp,CE
  if (verbose) printf("generating adjacency list")
  if (numarg()>0) startid=$1 else startid=0
  if (numarg()>1) endid=$2 else endid=allcells-1
  if (numarg()>2) skipinhib=$3 else skipinhib=0
  if (numarg()>3) CE=$o4 else CE=ce
  adj=new List()
  for idx=0,CE.count-1 adj.append(new Vector(CE.o(idx).getdvi))
  CE.o(0).adjlist(adj,startid,endid,skipinhib)
  return adj
}

//** adjstrg() -- get a string representation of adjacency list for use with dot
obfunc adjstrg () { local i,j localobj str,lc
  lc=new List()
  lc.append(new String("blue"))
  lc.append(new String("red"))
  str=new String2()
  str.s="digraph G {"
  for i=0,adj.count-1{ 
    for j=0,adj.o(i).size-1{
      sprint(str.t,"%d -> %d [color=%s];\n",i,adj.o(i).x(j),lc.o(ice(ce.o(i).type)).s)
      strcat(str.s,str.t)
    }
    sprint(str.t,"%d [color=%s];\n",i,lc.o(ice(ce.o(i).type)).s)
    strcat(str.s,str.t)
  }
  strcat(str.s,"}\n")
  return str
}

//** net2txtf(path) -- save net to text file representation
func net2txtf () { local jdx,idx,syns localobj F,vid
  F = new File()
  F.wopen($s1)
  if(!F.isopen){
    printf("couldn't open for saving\n")
    return 0
  }
  syns = 0
  for idx=0,ce.count-1 syns += ce.o(idx).getdvi
  F.printf("%d\n",ce.count)//# of cells  
  F.printf("%d\n",syns)//# of synapses
  F.printf("%d\n",ecells)
  F.printf("%d\n",icells)
  for idx=0,ce.count-1{
    if(ice(ce.o(idx).type)) F.printf("I ") else F.printf("E ")
    F.printf("%g %g %g\n",ce.o(idx).xloc,ce.o(idx).yloc,ce.o(idx).zloc)
  }
  vid=new Vector(allcells)
  vid.resize(0)
  for idx=0,ce.count-1{
    ce.o(idx).getdvi(vid)
    for jdx=0,vid.size-1{
      if(ice(ce.o(idx).type)) F.printf("I ") else F.printf("E ")
      F.printf("%d %d\n",idx,vid.x(jdx))
    }
  }
  F.close
  return 1
}

//write net to pajek .net file , can also be used in GUESS graph visualization program
//$s1=output file path, $o2=vector of cell types to add to output file
func writepajek () { local idx,jdx,ty,ndx localobj fp,vid,vdel,lc,vty,nqc
  fp=new File() vid=new Vector(allcells) vdel=new Vector(allcells)
  lc=new List() lc.append(new String("Red")) lc.append(new String("Blue")) vty=$o2
  fp.wopen($s1)
  if(!fp.isopen())return 0
  fp.printf("*Vertices %d\r\n",allcells)
  for idx=0,allcells-1{
    ty=ce.o(idx).type if(!vty.contains(ty))continue
    fp.printf("%d \"%s%d\" ic %s\r\n",idx+1,CTYP.o(ty).s,idx,lc.o(ice(ty)).s)
  }
  fp.printf("*Arcslist\r\n")  
  for idx=0,allcells-1 {
    ce.o(idx).getdvi(vid,vdel) ty=ce.o(idx).type
    if(!vty.contains(ty))continue

    fp.printf("%d ",idx+1)
    for ndx=0,vid.size/2 {
      jdx=vid.x(ndx)
      if(!vty.contains(ce.o(jdx).type))continue
      fp.printf("%d ",jdx+1)
    }
    fp.printf("1 c %s",lc.o(ice(ty)).s)
    fp.printf("\r\n")

    fp.printf("%d ",idx+1)
    for ndx=1+vid.size/2,vid.size-1 {
      jdx=vid.x(ndx)
      if(!vty.contains(ce.o(jdx).type))continue
      fp.printf("%d ",jdx+1)
    }
//    for vtr(&jdx,vid) {
//      if(!vty.contains(ce.o(jdx).type))continue
//      fp.printf("%d ",jdx+1)
//      fp.printf("%d %d 1 c %s\r\n",idx+1,jdx+1,lc.o(ice(ty)).s)
//    }
    fp.printf("1 c %s",lc.o(ice(ty)).s)
    fp.printf("\r\n")
  }
  fp.close()
  return 1
}



/////////////////////////////////////////////////////////////////////////
//get path existence/distance vector ==
// vector with:
//   d==0==no path between cell $1 and cell index
//               and
//   d>0==a path exists between cell $1 and cell index of distance d
//
// $1 = cell id to start search from
// $2 = minimum id of destination
// $3 = maximum id of destination
// $4 = max distance to search
obfunc GetPathEV () { local idx,myid,idist,startid,endid,maxdist localobj vd,vcheck,vtmp
  if(adj==nil)adj=AdjList()  
  myid=$1  
  if(numarg()>1)startid=$2 else startid=0
  if(numarg()>2)endid=$3 else endid=allcells-1
  if(numarg()>3)maxdist=$4 else maxdist=-1
  vd=new Vector(allcells)
  GetPathEV_intfsw(adj,vd,myid,startid,endid,maxdist)
  return vd
}

//check if network is fully connected == any cell has a path
//to any other cell
//can use speedup/efficiency improvements
func FullyConnected () { local idx localobj vd
  for idx=0,allcells-1{
    if(idx%100==0)printf("checking path from cell %d to others\n",idx)
    vd=GetPathEV(idx)
    if(vd.count(0)>1){
      printf("cell %d not fully connected to other cells, only has path to %d cells\n",idx,allcells-vd.count(0))
      return 0
    }
  }
  return 1
}

//approximate path length formula
//N=# of vertices
//$1=# of 1st degree neighbors
//$2=# of 2nd degree neighbors
func ApproxL () { local z1,z2,N
  N=$1  z1=$2 z2=$3
  return log(N/z1)/log(z2/z1)+1
}

//get approximate path length by first getting # of
//1st & 2nd degree neighbors
func GetApproxL () { local z1,z2,i,subsamp localobj lvnn,vtmp
  if(numarg()>0)subsamp=$1 else subsamp=1
  if(adj==nil) if(numc[DP]) adj=AdjList(ix[DP],ixe[SU]) else adj=AdjList()
  lvnn=new List()
  for i=0,1{
    vtmp=GetNumNeighbors(i+1,ix[DP],ixe[SU],1,adj,subsamp)
    lvnn.append(vtmp)
  }
  {z1=lvnn.o(0).gzmean(ix[DP],ixe[SU]) printf("z1=%g\n",z1)}
  {z2=lvnn.o(1).gzmean(ix[DP],ixe[SU]) printf("z2=%g\n",z2)}
  return ApproxL((1-killDP)*numc[DP]+(1-killSU)*numc[SU],z1,z2)
}

//returns vector of size allcells containing avg dist from that cell
//to all other cells it is connected to
obfunc GetNetL () { local from,gzm,sid,eid localobj vdist,vtmp
  if(numarg()>0)sid=$1 else sid=0
  if(numarg()>1)eid=$2 else eid=allcells-1
  vdist=new Vector(allcells) vtmp=new Vector(allcells)
  adj=AdjList(sid,eid) //make sure initialized properly in face of prup,killp,etc.
  printf("searching from id: ")
  for from=sid,eid{
    if(verbose && from%100==0)printf("%d...",from)
    if(ce.o(from).flag("dead"))continue
    vtmp=GetPathEV(from,sid,eid)
    if((gzm=vtmp.gzmean)>0){
      vdist.x(from)=gzm
    }
  }
  printf("\n")
  return vdist
}

// ** GetNetEXLSubPops -- get path length between excitatory subpopulations
// returns Vector of size allcells, to see path length do Vector.gzmean
// $1 == from population
// $2 == to population
// $3 == subsamp [default == 1, optional]
// $4 == take into account self-loop-length [default == 0, optional]
obfunc GetNetEXLSubPops () { local subsampi,from,selfl localobj vd,vstart,vend
  from=$1 to=$2
  if(numarg()>2) subsamp=$3 else subsamp=1
  if(numarg()>3) selfl=$4 else selfl=0
  if(adj==nil) adj=AdjList(0,allcells-1,1)//get adjacency list
  {vstart=new Vector(allcells) vend=new Vector(allcells) vd=new Vector(allcells)}
  for i=ix[from],ixe[from] vstart.x(i)=1
  for i=ix[to],ixe[to] vend.x(i)=1
  GetPathSubPop_intfsw(adj,vd,vstart,vend,subsamp,selfl)
  printf("exl path from sub pop %s to %s = %g\n",CTYP.o(from).s,CTYP.o(to).s,vd.gzmean)
  return vd
}

//returns vector of size allcells containing avg dist from that cell
//to all other excitatory(E) cells it is connected to
//only travels paths through E cells
//$1 == max dist , default == -1, to search all distances
//$2 == subsamp -- only use subsamp% of cells
//$3 == first turn off sub-pop to sub-pop [optional] default == -1
obfunc GetNetEXL () { local from,gzm,maxdist,subsamp localobj vdist,rdm,vuse
  if(numarg()>0)maxdist=$1 else maxdist=-1
  if(numarg()>1)subsamp=$2 else subsamp=1
  if(adj==nil)adj=AdjList(0,allcells-1,1) //make sure initialized properly in face of prup,killp,etc.
  vdist=new Vector(adj.count)
  GetPathR_intfsw(adj,vdist,0,adj.count-1,-1,subsamp)
  return vdist
}

//import networkx python library
func initnetworkx () {
  if(loadednetworkx) return 1
  if(!nrnpython("import networkx")) {
    printf("initnetworkx ERRA: couldn't import networkx python library!\n")
    return 0
  }
  loadednetworkx=1
  return 1
}

//get a PythonObject containing adjacency list adj, with variable name = $s1, $2==skip I cells
obfunc NXAdjG () { local idx,jdx,skipI localobj str,py  
  if(!initnetworkx()) return nil
  str=new String()
  sprint(str.s,"%s=networkx.XDiGraph()",$s1)
  py=new PythonObject()
  if(!nrnpython(str.s)){
    printf("NXAdjG ERRA: Couldn't evaluate %s in python!\n",str.s)
    return nil
  }
  if(numarg()>1)skipI=$2 else skipI=1
  for idx=0,allcells-1 if(!skipI || !ice(ce.o(idx).type)) {
    sprint(str.s,"%s.add_node(%d)",$s1,idx)
    if(!nrnpython(str.s)){
      printf("NXAdjG ERRB: Couldn't add node %d to %s\n",idx,$s1)
      return nil
    }
  }
//  if(!adj)adj=AdjList(0,allcells-1,skipI)
//  for idx=0,adj.count-1 for jdx=0,adj.o(idx).count-1 {
//    sprint(str.s,
//  }
  return py
}

func tyfunc () { return ce.o($1).type }

//get between-ness centrality of all E cells, in output NQS
obfunc GetNetECent () { localobj vcent,centnq
  if(adj==nil)adj=AdjList(0,allcells-1,1)
  vcent=new Vector(adj.count) vcent.fill(0)
  GetCentrality_intfsw(adj,vcent)
  centnq=new NQS("id","type","C")
  centnq.v[0].indgen(0,adj.count-1,1)
  centnq.v[1].copy(centnq.v[0])
  centnq.v[1].apply("tyfunc")
  centnq.v[2].copy(vcent)
  return centnq
}

//gets vector with loop/return path-lengths to each excitatory cell
// out.x(idx)=0 means no such path found to cell idx
obfunc GetNetELoop () { local idx localobj vdist,vloop,vf,vto
  vdist=new Vector(1) vloop=new Vector(allcells) vf=new Vector(1) vto=new Vector(1)
  if(adj==nil)adj=AdjList(0,allcells-1,1)//make sure initialized properly in face of prup,killp,etc.
  for idx=0,allcells-1 {
    if(ice(ce.o(idx).type)) {
      vloop.x(idx)=0
      continue
    }
    vf.x(0)=vto.x(0)=idx
    GetPairDist_intfsw(adj,vdist,vf,vto)
    vloop.x(idx)=vdist.x(0)
  }
  return vloop
}

// ** wirenq -- get wiring nqs, preid, postid, delay, wt1, wt2
// iff numarg()>0 $1 == only store info on excitatory connections
obfunc wirenq () { local ii,jj,exonly localobj vid,vdel,vprob,vw1,vw2,nq,vpl
  if(numarg()>0) exonly=$1 else exonly=0
  {vid=new Vector() vdel=new Vector() vprob=new Vector() vw1=new Vector() vw2=new Vector()}
  nq=new NQS("preid","poid","del","wt1","wt2")
  if(exonly){
    for ii=0,allcells-1{
     if(ice(ce.o(ii))) continue
     ce.o(ii).getdvi(1,vid,vdel,vprob,vw1,vw2)
     for jj=0,vid.size-1{
       if(ice(ce.o[vid.x(jj)])) continue
       nq.append(ii,vid.x(jj),vdel.x(jj),vw1.x(jj),vw2.x(jj))
     }
    }
  } else {
    for ii=0,allcells-1{
      ce.o(ii).getdvi(1,vid,vdel,vprob,vw1,vw2)
      for jj=0,vid.size-1{
        if(ice(ce.o[vid.x(jj)])){
          vw1.mul(-1)
          vw2.mul(-1)
        } 
        nq.append(ii,vid.x(jj),vdel.x(jj),vw1.x(jj),vw2.x(jj))
      }
    }
  }
  return nq
}

// ** GetNetWEXL() -- get weighted network excitatory path length
// uses directed weighted graph where distance between nodes is == delay/weight
// done for AMPA,NMDA or BOTH -- $1 == ampa flag, $2 == nmda flag
// $o3 == wirenq , [optional]
// $4 == flip order of preid, poid (convergence instead of divergence lengths) [optional]
obfunc GetNetWEXL () { local ampa,nmda,edgef,flip\
                      localobj vid,vdel,vprob,vw1,vw2,nq,vpl,vs,vpre,vpo
  if(numarg()>0) ampa=$1 else ampa=1
  if(numarg()>1) nmda=$2 else nmda=1
  if(numarg()>2) nq=$o3 else nq = wirenq(1)
  if(numarg()>3) flip=$4 else flip=0
  vpl=new Vector(allcells)
  vdel=new Vector()
  if(flip){ // flip pre and po
    vpre=nq.getcol("poid")
    vpo=nq.getcol("preid")
  } else {
    vpre=nq.getcol("preid")
    vpo=nq.getcol("poid")
  }
  nq.getcol("del",vdel)
  if(ampa && nmda){
    vs=new Vector()
    vs.copy(nq.getcol("wt1"))
    vs.add(nq.getcol("wt2"))
    GetWPath_intfsw(vpre,vpo,vs,vdel,vpl)
  } else if(ampa){
    GetWPath_intfsw(vpre,vpo,nq.getcol("wt1"),vdel,vpl)
  } else if(nmda){
    GetWPath_intfsw(vpre,vpo,nq.getcol("wt2"),vdel,vpl)
  } else { 
    if(numarg()<=2)nqsdel(nq)
    return nil
  }
  if(numarg()<=2)nqsdel(nq)
  return vpl
}

// ** GetNetWL() -- get weighted network path length, takes inhibitory contributions as
// weight/delay , and excitatory contributions as delay/weight
// only uses AMPA/GABAA or NMDA/GABAB
obfunc GetNetWL () { local ampagabaa localobj vid,vdel,vprob,vw1,vw2,nq,vpl
  if(numarg()>0) ampagabaa=$1 else ampagabaa=1
  nq = wirenq(0)
  vpl=new Vector(nq.size)
  if(ampagabaa){
    GetWPath_intfsw(nq.getcol("preid"),nq.getcol("poid"),nq.getcol("wt1"),nq.getcol("del"),vpl)
  } else {
    GetWPath_intfsw(nq.getcol("preid"),nq.getcol("poid"),nq.getcol("wt2"),nq.getcol("del"),vpl)
  }
  return vpl
}


// ** GetNetEXCCSubPops -- get clustering coefficient between excitatory subpopulations
// returns Vector of size allcells, to see path length do Vector.gzmean
// $1 == from population
// $2 == to population
// $3 == subsamp [default == 1, optional]
obfunc GetNetEXCCSubPops () { local subsampi,from localobj vd,vstart,vend
  from=$1 to=$2
  if(numarg()>2) subsamp=$3 else subsamp=1
  if(adj==nil) adj=AdjList(0,allcells-1,1)//get adjacency list
  {vstart=new Vector(allcells) vend=new Vector(allcells) vd=new Vector(allcells)}
  for i=ix[from],ixe[from] vstart.x(i)=1
  for i=ix[to],ixe[to] vend.x(i)=1
  GetCCSubPop_intfsw(adj,vd,vstart,vend,subsamp)
  printf("excc from sub pop %s to %s = %g\n",CTYP.o(from).s,CTYP.o(to).s,vd.nnmean)
  return vd
}

//get clustering coefficient vector for excitatory cells
//usage: vcc = GetNetEXCC()
//vcc.x(i) is clustering coefficient of cell i (must be >= 0.0 && <= 1.0)
//otherwise there was a problem...
//vcc.mean(ix[DP],ixe[SU]) is clustering coefficient of excitatory cells for entire network
obfunc GetNetEXCC () { local idx,sid,eid,subsamp localobj vcc,vuse
  if(adj==nil)adj=AdjList(0,allcells-1,1)
  if(numarg()>0)sid=$1 else sid=0
  if(numarg()>1)eid=$2 else eid=adj.count-1
  if(numarg()>2)subsamp=$3 else subsamp=1
  vcc=new Vector(adj.count)
  GetCCR_intfsw(adj,vcc,sid,eid,subsamp)
  return vcc
}

//returns vector of size allcells containing num of neighbors <= $1 distance away
//for each cell
obfunc GetNumNeighbors () { local maxdist,startid,endid,exact,subsamp,sead localobj vdist,vtmp,vuse,rdm
  maxdist=$1
  if(numarg()>1)startid=$2 else startid=ix[DP]
  if(numarg()>2)endid=$3 else endid=ixe[SU]
  if(numarg()>3)exact=$4 else exact=0
  if(numarg()>4)adj=$o5 else if(adj==nil) adj=AdjList()//make sure initialized properly in face of prup,killp,etc.
  if(numarg()>5)subsamp=$6 else subsamp=1
  vdist=new Vector(allcells) vtmp=new Vector(allcells)
  printf("searching from id: ")
  CountNeighborsR_intfsw(adj,vdist,startid,endid,maxdist,subsamp)
  return vdist
}

//returns vector of size allcells containing # of recurrent connections terminating on cell
//i in out.x(i)
//$1 == from type, -1 means from all E cells, -2 means all I cells, as a vec from all types in vec
//$2 == thru type, -1 means thru all E cells, -2 means all I cells, as a vec thru all types in vec
obfunc GetRecurVec () { local from,thru,ct localobj vRC,vfrom,vthru,vtmp
  vRC=new Vector(allcells) vfrom=new Vector(allcells) vthru=new Vector(allcells)
  vRC.fill(0) 
  if(adj==nil)adj=AdjList()
  if(numarg()>0) {
    if(argtype(1)==0) {
      if($1>=0) {
        vfrom.fill(1,ix[$1],ixe[$1]) //from only a specific type
      } else if($1==-1) { // E cells
        for ctt(&ct) if(!ice(ct)) vfrom.fill(1,ix[ct],ixe[ct])
      } else for ctt(&ct) if(ice(ct)) vfrom.fill(1,ix[ct],ixe[ct]) // I cells
    } else {
      for vtr(&from,$o1) vfrom.fill(1,ix[from],ixe[from]) //from a bunch of types
    }
  } else vfrom.fill(1)
  if(numarg()>1) {
    if(argtype(1)==0) {
      if($1>=0) {
        vthru.fill(1,ix[$2],ixe[$2])
      } else if($1==-1) { // E cells
        for ctt(&ct) if(!ice(ct)) vthru.fill(1,ix[ct],ixe[ct])
      } else for ctt(&ct) if(ice(ct)) vthru.fill(1,ix[ct],ixe[ct]) // I cells
    } else {
      for vtr(&thru,$o1) vthru.fill(1,ix[thru],ixe[thru]) //thru a bunch of types
    }
  } else vthru.fill(1)
  GetRecurCount_intfsw(adj,vRC,vfrom,vthru)
  return vRC
}

//* DivNQS([cell list]) - gets NQS with # of outputs of a given type from each cell
obfunc DivNQS () { local a,idx,x,flag localobj nq,vc,vd,vo,vty,st,CE,vcnt,xo
  if(numarg()>0)CE=$o1 else CE=ce
  st=new String2()
  nq=new NQS("id","type")
  a=allocvecs(vc,vd,vty,vo,vcnt,CTYPi+1)
  vrsz(0,vc,vd,vo,vty) vcnt.resize(CTYPi)
  for ltr(xo,CE) vcnt.x(xo.type)+=1
  for x=0,CTYPi-1 if(vcnt.x(x)) {
    {sprint(st.s,"to%s",CTYP.o(x).s) nq.resize(st.s) vty.append(x)} // vty -- type vec
  }
  nq.clear(CE.count) // make big enough
  flag=getactive+0.2
  for idx=0,CE.count-1 {
    CE.o(idx).getdvi(flag,vc) // picks up for all existing (CTYP) cell types
    vo.index(vc,vty) // only take the ones for the relevant types
    revec(vd,idx,CE.o(idx).type) vd.append(vo) // put in the id and type values for the postcell
    nq.append(vd)
  }
  dealloc(a)
  return nq
}

//* ConvNQS([cell list]) - gets NQS with # of inputs of a given type onto each cell
obfunc ConvNQS () { local a,idx,x,flag localobj nq,vc,vd,vo,vty,st,CE,vcnt,xo
  if(numarg()>0)CE=$o1 else CE=ce
  st=new String2()
  nq=new NQS("id","type")
  a=allocvecs(vc,vd,vty,vo,vcnt,CTYPi+1)
  vrsz(0,vc,vd,vty) vcnt.resize(CTYPi)
  for ltr(xo,CE) vcnt.x(xo.type)+=1
  for x=0,CTYPi-1 if(vcnt.x(x)) {
    {sprint(st.s,"f%s",CTYP.o(x).s) nq.resize(st.s) vty.append(x)} // vty -- type vec
  }
  nq.clear(CE.count) // make big enough
  flag=getactive+0.2
  for idx=0,CE.count-1 {
    CE.o(idx).getconv(flag,vc) // picks up for all possible cell types
    vo.index(vc,vty) // only take the ones for the relevant types
    revec(vd,idx,CE.o(idx).type) vd.append(vo) // put in the id and type values for the postcell
    nq.append(vd)
  }
  dealloc(a)
  return nq
}

//display conv hists in graphs
proc ShowConvHists () { local from,to,jj,ii,num localobj vt,vt2,mystr,o,xo,yo
  mystr=new String()       hflg=2      ers=0
  if(numarg()<1 && convnq!=nil)nqsdel(convnq)
  if(convnq==nil) convnq=ConvNQS()
  convnq.verbose=0
  num=0
  for ctt(&to) num+=1 // count the active cells
  if (intfswbfl) {
    for ltr(yo,boxerl) if (strm(yo.name,"CONV")) o=yo
    if (o!=nil) { // reuse this box
      if (o.size!=num) {printf("ERR: wrong # of graphs in tray: %d %d\n",o.size,num) return}
      for ltr(xo,o.gl) xo.erase_all
    } else o=mktray("CONV",num)
    for ctt(&to,&ii) vhistg[to]=o.gl.o(ii)
  } else for ctt(&to) {
    if(vhistg[to]==nil || numarg()<1) vhistg[to]=new Graph() else vhistg[to].erase_all
  }  
  for ctt(&to) {
    sprint(mystr.s,"conv hist onto %s",CTYP.o(to).s)
    vhistg[to].color(to)
    vhistg[to].label(0.35,0.95,mystr.s)
    for ctt(&from,&ii){
      if(!div[from][to]) continue
      clr=from
      if(convnq.select("type",to)){
        sprint(mystr.s,"f%s",CTYP.o(from).s)
        vt=convnq.getcol(mystr.s)
        sprint(mystr.s,"from %s avg=%g",CTYP.o(from).s,vt.mean)
        if (vt.min==vt.max) {
          vhistg[to].mark(vt.min,0,"S",10,clr,4)
        } else {
          hist(vhistg[to],vt)
        }
        vhistg[to].color(clr)
        vhistg[to].label(0.5,0.88-0.05*ii,mystr.s)
      }
    }
    vhistg[to].exec_menu("View = plot")
  }  
  convnq.verbose=1
}

//display div hists in graphs -- skips inhibitory cells for now...
proc ShowDivHists () { local from,to,ii,jj,num,rows,cols localobj vt,mystr,o,xo,yo
  mystr=new String()      hflg=2      ers=0
  if(numarg()<1 && divnq!=nil)nqsdel(divnq)
  if(divnq==nil) divnq=DivNQS()
  divnq.verbose=0
  num=0
  for ctt(&from) num+=1 // count the active cells
  if (intfswbfl) {
    for ltr(yo,boxerl) if (strm(yo.name,"DIV")) o=yo
    if (o!=nil) { // reuse this box
      if (o.size!=num) {printf("ERR: wrong # of graphs in tray: %d %d\n",o.size,num) return}
       for ltr(xo,o.gl) xo.erase_all
   } else o=mktray("DIV",num)
    for ctt(&from,&ii) vhistgd[from]=o.gl.o(ii)
  } else for ctt(&from) {
    if(vhistgd[from]==nil || numarg()<1) vhistgd[from]=new Graph() else vhistgd[from].erase_all
  }  
  for ctt(&from,&jj) {
    sprint(mystr.s,"div hist from %s",CTYP.o(from).s)
    vhistgd[from].color(from)
    vhistgd[from].label(0.35,0.95,mystr.s)
    for ctt(&to,&ii){
      if(!div[from][to]) continue
      clr=to
      if(divnq.select("type",from)){
        sprint(mystr.s,"to%s",CTYP.o(to).s)
        vt=divnq.getcol(mystr.s)
        sprint(mystr.s,"to %s avg=%g",CTYP.o(to).s,vt.mean)
        if(vt.min==vt.max){
          vhistgd[from].mark(vt.min,0,"S",10,clr,4)
        } else {
          hist(vhistgd[from],vt)
        }
        vhistgd[from].color(clr)
        vhistgd[from].label(0.5,0.88-0.05*ii,mystr.s)
      }
    }
    vhistgd[from].exec_menu("View = plot")
  }  
  divnq.verbose=1
}

//get index of GetCellNQ arg which column is needed, $s1=colname
func getcellnqcolid () { localobj str
  str=new String()
  str.s=$s1
  if(!strcmp($s1,"wexl")){
    return 1
  } else if(!strcmp($s1,"snq")) {
    return 2
  } else if(!strcmp($s1,"fnq")) {
    return 3
  } else if(!strcmp($s1,"C")) {
    return 4
  } else if(!strcmp($s1,"exl")) {
    return 5
  } else if(!strcmp($s1,"excc")) {
    return 6
  } else if(!strcmp($s1,"conv") || strm($s1,"f")) {
    return 7
  } else if(!strcmp($s1,"div") || strm($s1,"to")) {
    return 8
  } else if(!strcmp($s1,"blk")) {
    return 9
  }
  return 0
}

func ifunc () { return ice(ce.o($1).type) }
//get nqs with cell properties including: centrality, exl, excc, div to all types, conv to all types
//$1=do wexl,$2=do snq,$3=do fnq,$4=do C,$5=do exl,$6=do excc,$7=do convnq,$8=do div,$9=do block
obfunc GetCellNQ () { local i,id,n,doexl,doexcc,doconv,doC,dodiv,doblk\
                     localobj nq,nqt,vv,snq,fnq
  nq=new NQS("id","type") adj=nil
  nq.v[0].indgen(0,allcells-1,1)  nq.v[1].copy(nq.v[0]) nq.v[1].apply("tyfunc")
  if(numarg()>3)doC=$4 else doC=1
  if(numarg()>4)doexl=$5 else doexl=1
  if(numarg()>5)doexcc=$6 else doexcc=1
  if(numarg()>6)doconv=$7 else doconv=1
  if(numarg()>7)dodiv=$8 else dodiv=1
  if(numarg()>8)doblk=$9 else doblk=1
  if(doC){
    if (verbose) printf("getting centrality nq\n") nqt=GetNetECent() 
    nq.resize("C") nq.v[nq.m-1].copy(nqt.v[nqt.m-1]) nqsdel(nqt)
  }
  if(numarg()>0) if($1) {
    {if (verbose) printf("getting wexl\n")
      vv=GetNetWEXL()  nq.resize("wexl") nq.v[nq.m-1].copy(vv)}
  }
  if(doexl){
    {if (verbose) printf("getting exl\n")
      vv=GetNetEXL()  nq.resize("exl") nq.v[nq.m-1].copy(vv)}
  }
  if(doexcc){
    {if (verbose) printf("getting excc\n")
      vv=GetNetEXCC() nq.resize("excc") nq.v[nq.m-1].copy(vv)}
  }
  if(doconv){
    if (verbose) printf("getting convnq\n") nqt=ConvNQS()
    for i=2,nqt.m-1 {
      nq.resize(nqt.s[i].s) nq.v[nq.m-1].copy(nqt.v[i])
    }
    nqsdel(nqt)
  }
  if(dodiv){
    if (verbose) printf("getting divnq\n") nqt=DivNQS()
    for i=2,nqt.m-1 {
      nq.resize(nqt.s[i].s) nq.v[nq.m-1].copy(nqt.v[i])
    }
    nqsdel(nqt)
  }
  {nq.resize("inhib") nq.pad() nq.v[nq.m-1].copy(nq.v[0]) nq.v[nq.m-1].apply("ifunc")}
  if(numarg()>1) if($2) {
    if (verbose) printf("getting spike counts\n")
    vv=printlist.o(0).vec    nq.resize("spikes") nq.pad() nq.v[nq.m-1].fill(0)
    for vtr(&i,vv) nq.v[nq.m-1].x(i)+=1
  }
  if(doblk){
    nq.resize("block") nq.pad() for i=1,allcells-1 nq.v[nq.m-1].x(i)=ce.o(i).spkcnt(i,i,2)
  }
  if(numarg()>2) if($3 && name_declared("FreqNQS")) {
    if (verbose) printf("getting FreqNQS\n")
    snq=SpikeNQS(printlist.o(0))
    fnq=FreqNQS(snq,20,0,0)
    for i=0,allcells-1 if((n=fnq.select("ID",i))) {
      if(n>0){
        nq.v[nq.m-1].x(i)=fnq.getcol("Freq").mean
      } else {
        nq.v[nq.m-1].x(i)=fnq.getcol("Freq").x(0)
      }
    }
  }
  if(snq!=nil)nqsdel(snq)
  if(fnq!=nil)nqsdel(fnq)
  return nq
}

//get nqs with rand value for each cell, $1==seed
obfunc GetRandCellNQ () { local i localobj nq,rd
  nq=new NQS("id","type","rand")
  rd=new Random()
  rd.ACG($1)
  for i=0,allcells-1 nq.append(i,ce.o(i).type,rd.normal(0,1))
  return nq
}

// from ShowDivHists()
proc prdiv () { local from,to,jj,ii,num,rows,cols localobj vt,mystr,o,xo,yo
  if (numarg()==1) o=$o1 else o=divnq
  if (o==nil) o=divnq=DivNQS()
  o.verbose=0
  for ctt(&from,&jj) { printf("\ndiv from %s: ",CTYP.o(from).s)
    if (o.select("type",from)) for ctt(&to,&ii) {
      vt=o.getcol(CTYP.o(to).s)
      printf("  to %s avg=%02.3f +- %02.3f",CTYP.o(to).s,vt.mean,vt.stdev) 
  }}
  print ""
  o.verbose=1
}
proc prconv () { local from,to,jj,ii,num,rows,cols localobj vt,mystr,o,xo,yo
  if (numarg()==1) o=$o1 else o=convnq
  if (o==nil) o=convnq=ConvNQS()
  o.verbose=0
  for ctt(&to,&jj) { printf("\nconv to %s: ",CTYP.o(to).s)
    if (o.select("type",to)) for ctt(&from,&ii) {
      vt=o.getcol(CTYP.o(from).s)
      printf("  from %s avg=%02.3f +- %02.3f",CTYP.o(from).s,vt.mean,vt.stdev) 
  }}
  print ""
  o.verbose=1
}

Kerr CC, Neymotin SA, Chadderdon GL, Fietkiewicz CT, Francis JT, Lytton WW (2012) Electrostimulation as a prosthesis for repair of information flow in a computer model of neocortex IEEE Transactions on Neural Systems & Rehabilitation Engineering 20(2):153-60[PubMed]

References and models cited by this paper

References and models that cite this paper

Adesnik H, Scanziani M (2010) Lateral competition for cortical space by layer-specific horizontal circuits. Nature 464:1155-60 [PubMed]

Binzegger T, Douglas RJ, Martin KA (2004) A quantitative map of the circuit of cat primary visual cortex. J Neurosci 24:8441-53 [PubMed]

Carnevale NT, Hines ML (2006) The NEURON Book

Cui J, Xu L, Bressler SL, Ding M, Liang H (2008) BSMART: a Matlab-C toolbox for analysis of multichannel neural time series. Neural Netw 21:1094-104 [PubMed]

Francis JT, Xu S, Chapin JK (2008) Proprioceptive and cutaneous representations in the rat ventral posterolateral thalamus. J Neurophysiol 99:2291-304 [PubMed]

Gisiger T, Boukadoum M (2011) Mechanisms Gating the Flow of Information in the Cortex: What They Might Look Like and What Their Uses may be. Front Comput Neurosci 5:1-304 [PubMed]

Hines ML, Carnevale NT (2001) NEURON: a tool for neuroscientists. Neuroscientist 7:123-35 [Journal] [PubMed]

   Spatial gridding and temporal accuracy in NEURON (Hines and Carnevale 2001) [Model]

Kamiński M, Ding M, Truccolo WA, Bressler SL (2001) Evaluating causal relations in neural systems: granger causality, directed transfer function and statistical assessment of significance. Biol Cybern 85:145-57 [PubMed]

Lefort S, Tomm C, Floyd Sarria JC, Petersen CC (2009) The excitatory neuronal network of the C2 barrel column in mouse primary somatosensory cortex. Neuron 61:301-16 [PubMed]

Lizier JT, Heinzle J, Horstmann A, Haynes JD, Prokopenko M (2011) Multivariate information-theoretic measures reveal directed information structure and task relevant changes in fMRI connectivity. J Comput Neurosci 30:85-107

Lloyd KG, Davidson L, Hornykiewicz O (1975) The neurochemistry of Parkinson's disease: effect of L-dopa therapy. J Pharmacol Exp Ther 195:453-64 [PubMed]

Lytton WW, Neymotin SA, Hines ML (2008) The virtual slice setup. J Neurosci Methods 171:309-15 [Journal] [PubMed]

   The virtual slice setup (Lytton et al. 2008) [Model]

Lytton WW, Omurtag A (2007) Tonic-clonic transitions in computer simulation. J Clin Neurophysiol 24:175-81 [PubMed]

   Tonic-clonic transitions in a seizure simulation (Lytton and Omurtag 2007) [Model]

Lytton WW, Omurtag A, Neymotin SA, Hines ML (2008) Just in time connectivity for large spiking networks Neural Comput 20(11):2745-56 [Journal] [PubMed]

   JitCon: Just in time connectivity for large spiking networks (Lytton et al. 2008) [Model]

Lytton WW, Stewart M (2005) A rule-based firing model for neural networks Int J Bioelectromagn 7:47-50

Lytton WW, Stewart M (2006) Rule-based firing for network simulations. Neurocomputing 69:1160-1164

Meyer JS, Obara K, Muramatsu K (1993) Diaschisis. Neurol Res 15:362-6 [PubMed]

Neymotin SA, Jacobs KM, Fenton AA, Lytton WW (2011) Synaptic information transfer in computer models of neocortical columns. J Comput Neurosci. 30(1):69-84 [Journal] [PubMed]

   Synaptic information transfer in computer models of neocortical columns (Neymotin et al. 2010) [Model]

Quilodran R, Gariel MA, Markov NT, Falchier A, Vezoli J, Sallet J, Anderson JC, Dehay C, Doug (2008) Strong loops in the neocortex Society for Neuroscience Abstracts 853.4

Rasche D, Rinaldi PC, Young RF, Tronnier VM (2006) Deep brain stimulation for the treatment of various chronic pain syndromes. Neurosurg Focus 21:E8

Richman JS, Moorman JR (2000) Physiological time-series analysis using approximate entropy and sample entropy. Am J Physiol Heart Circ Physiol 278:H2039-49 [PubMed]

Schiff ND, Giacino JT, Kalmar K, Victor JD, Baker K, Gerber M, Fritz B, Eisenberg B, Biondi T (2007) Behavioural improvements with thalamic stimulation after severe traumatic brain injury. Nature 448:600-3 [PubMed]

Schroeder CE, Mehta AD, Foxe JJ (2001) Determinants and mechanisms of attentional modulation of neural processing. Front Biosci 6:D672-84

Shipp S (2005) The importance of being agranular: a comparative account of visual and motor cortex. Philos Trans R Soc Lond B Biol Sci 360:797-814 [PubMed]

Stefani A, Lozano AM, Peppe A, Stanzione P, Galati S, Tropepi D, Pierantozzi M, Brusa L, Scar (2007) Bilateral deep brain stimulation of the pedunculopontine and subthalamic nuclei in severe Parkinson's disease. Brain 130:1596-607 [PubMed]

Stoerig P, Cowey A (1997) Blindsight in man and monkey. Brain 120 ( Pt 3):535-59 [PubMed]

Traub RD, Contreras D, Cunningham MO, Murray H, Lebeau FE, Roopun A, Bibbig A, et al (2005) A single-column thalamocortical network model exhibiting gamma oscillations, sleep spindles and epileptogenic bursts J Neurophysiol 93(4):2194-232 [Journal] [PubMed]

   A single column thalamocortical network model (Traub et al 2005) [Model]
   Collection of simulated data from a thalamocortical network model (Glabska, Chintaluri, Wojcik 2017) [Model]

Van Essen DC, Anderson CH, Felleman DJ (1992) Information processing in the primate visual system: an integrated systems perspective. Science 255:419-23 [PubMed]

Von_monakow C (1914) Die Lokalisation im Grosshirn und der Abbau der Funktion durch kortikale Herde

Chadderdon GL, Mohan A, Suter BA, Neymotin SA, Kerr CC, Francis JT, Shepherd GM, Lytton WW (2014) Motor cortex microcircuit simulation based on brain activity mapping. Neural Comput 26:1239-62 [Journal] [PubMed]

   Motor cortex microcircuit simulation based on brain activity mapping (Chadderdon et al. 2014) [Model]

Dura-Bernal S, Li K, Neymotin SA, Francis JT, Principe JC, Lytton WW (2016) Restoring behavior via inverse neurocontroller in a lesioned cortical spiking model driving a virtual arm. Front. Neurosci. Neuroprosthetics 10:28 [Journal]

   Cortical model with reinforcement learning drives realistic virtual arm (Dura-Bernal et al 2015) [Model]

Dura-Bernal S, Neymotin SA, Kerr CC, Sivagnanam S, Majumdar A, Francis JT, Lytton WW (2017) Evolutionary algorithm optimization of biological learning parameters in a biomimetic neuroprosthesis. IBM Journal of Research and Development (Computational Neuroscience special issue) 61(2/3):6:1-6:14 [Journal]

   Motor system model with reinforcement learning drives virtual arm (Dura-Bernal et al 2017) [Model]

Dura-Bernal S, Zhou X, Neymotin SA, Przekwas A, Francis JT, Lytton WW (2015) Cortical Spiking Network Interfaced with Virtual Musculoskeletal Arm and Robotic Arm. Front Neurorobot 9:13 [Journal] [PubMed]

   Cortical model with reinforcement learning drives realistic virtual arm (Dura-Bernal et al 2015) [Model]

Kerr CC, Van Albada SJ, Neymotin SA, Chadderdon GL, Robinson PA, Lytton WW (2013) Cortical information flow in Parkinson's disease: a composite network-field model. Front Comput Neurosci 7:39:1-14 [Journal] [PubMed]

   Composite spiking network/neural field model of Parkinsons (Kerr et al 2013) [Model]

Neymotin SA, Chadderdon GL, Kerr CC, Francis JT, Lytton WW (2013) Reinforcement learning of 2-joint virtual arm reaching in a computer model of sensorimotor cortex Neural Computation 25(12):3263-93 [Journal] [PubMed]

   Sensorimotor cortex reinforcement learning of 2-joint virtual arm reaching (Neymotin et al. 2013) [Model]

Neymotin SA, Dura-Bernal S, Lakatos P, Sanger TD, Lytton WW (2016) Multitarget Multiscale Simulation for Pharmacological Treatment of Dystonia in Motor Cortex. Front Pharmacol 7:157 [Journal] [PubMed]

   Multitarget pharmacology for Dystonia in M1 (Neymotin et al 2016) [Model]

Neymotin SA, Lee H, Park E, Fenton AA, Lytton WW (2011) Emergence of physiological oscillation frequencies in a computer model of neocortex. Front Comput Neurosci 5:19-75 [Journal] [PubMed]

   Emergence of physiological oscillation frequencies in neocortex simulations (Neymotin et al. 2011) [Model]

Rowan MS, Neymotin SA, Lytton WW (2014) Electrostimulation to reduce synaptic scaling driven progression of Alzheimer's disease. Front Comput Neurosci 8:39 [Journal] [PubMed]

   Electrostimulation to reduce synaptic scaling driven progression of Alzheimers (Rowan et al. 2014) [Model]

(38 refs)