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

 Download zip file   Auto-launch 
Help downloading and running models
Accession:183014
We developed a 3-layer sensorimotor cortical network of consisting of 704 spiking model-neurons, including excitatory, fast-spiking and low-threshold spiking interneurons. Neurons were interconnected with AMPA/NMDA, and GABAA synapses. We trained our model using spike-timing-dependent reinforcement learning to control a virtual musculoskeletal human arm, with realistic anatomical and biomechanical properties, to reach a target. Virtual arm position was used to simultaneously control a robot arm via a network interface.
References:
1 . 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 [PubMed]
2 . 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
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism:
Cell Type(s): Neocortex M1 pyramidal pyramidal tract L5B cell; Neocortex M1 pyramidal intratelencephalic L2-5 cell; Neocortex M1 interneuron basket PV cell; Neocortex fast spiking (FS) interneuron; Neostriatum fast spiking interneuron; Neocortex spiking regular (RS) neuron; Neocortex spiking low threshold (LTS) neuron;
Channel(s):
Gap Junctions:
Receptor(s): GabaA; AMPA; NMDA;
Gene(s):
Transmitter(s): Gaba; Glutamate;
Simulation Environment: NEURON; Python (web link to model);
Model Concept(s): Synaptic Plasticity; Learning; Reinforcement Learning; STDP; Reward-modulated STDP; Sensory processing; Motor control;
Implementer(s): Neymotin, Sam [samn at neurosim.downstate.edu]; Dura, Salvador [ salvadordura at gmail.com];
Search NeuronDB for information about:  Neocortex M1 pyramidal intratelencephalic L2-5 cell; Neocortex M1 pyramidal pyramidal tract L5B cell; Neocortex M1 interneuron basket PV cell; GabaA; AMPA; NMDA; Gaba; Glutamate;
/
arm2dms_modeldb
mod
msarm
stimdata
README.html
analyse_funcs.py
analysis.py
armGraphs.py
arminterface_pipe.py
basestdp.hoc
bicolormap.py
boxes.hoc *
bpf.h *
col.hoc
colors.hoc *
declist.hoc *
decmat.hoc *
decnqs.hoc *
decvec.hoc *
default.hoc *
drline.hoc *
filtutils.hoc *
grvec.hoc
hinton.hoc *
hocinterface.py
infot.hoc *
init.hoc
intfsw.hoc *
labels.hoc
load.hoc
load.py
local.hoc *
main.hoc
main_demo.hoc
main_neurostim.hoc
misc.h *
misc.py *
msarm.hoc
network.hoc
neuroplot.py *
neurostim.hoc
nload.hoc
nqs.hoc *
nqsnet.hoc *
nrnoc.hoc
params.hoc
perturb.hoc
python.hoc
pywrap.hoc *
run.hoc
runbatch_neurostim.py
runsim_neurostim
samutils.hoc *
saveoutput.hoc
saveoutput2.hoc
setup.hoc *
sim.hoc
sim.py
sim_demo.py
simctrl.hoc *
stats.hoc *
stim.hoc
syncode.hoc *
units.hoc *
vector.py
xgetargs.hoc *
                            
// $Id: intfsw.hoc,v 1.76 2011/10/21 00:37:00 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]")}
sprint(tstr,"o[%d]",CTYPi+1)
{declare("nxadjg",nil,"vhistg",tstr,"vhistgd",tstr,"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
}

Loading data, please wait...