2D model of olfactory bulb gamma oscillations (Li and Cleland 2017)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:232097
This is a biophysical model of the olfactory bulb (OB) that contains three types of neurons: mitral cells, granule cells and periglomerular cells. The model is used to study the cellular and synaptic mechanisms of OB gamma oscillations. We concluded that OB gamma oscillations can be best modeled by the coupled oscillator architecture termed pyramidal resonance inhibition network gamma (PRING).
Reference:
1 . Li G, Cleland TA (2017) A coupled-oscillator model of olfactory bulb gamma oscillations. PLoS Comput Biol 13:e1005760 [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): Olfactory bulb main mitral GLU cell; Olfactory bulb main interneuron granule MC GABA cell; Olfactory bulb main interneuron periglomerular GABA cell;
Channel(s):
Gap Junctions:
Receptor(s): AMPA; NMDA; GabaA;
Gene(s):
Transmitter(s):
Simulation Environment: NEURON;
Model Concept(s): Olfaction;
Implementer(s): Li, Guoshi [guoshi_li at med.unc.edu];
Search NeuronDB for information about:  Olfactory bulb main mitral GLU cell; Olfactory bulb main interneuron periglomerular GABA cell; Olfactory bulb main interneuron granule MC GABA cell; GabaA; AMPA; NMDA;
/
OBGAMMA
celldata
connection
data0
input
README
cadecay.mod *
cadecay2.mod *
Caint.mod *
Can.mod *
CaPN.mod *
CaT.mod *
GradeAMPA.mod *
GradeGABA.mod *
GradNMDA.mod *
hpg.mod *
kAmt.mod *
KCa.mod *
KDRmt.mod *
kfasttab.mod *
kM.mod *
KS.mod
kslowtab.mod *
LCa.mod *
nafast.mod *
NaP.mod *
Naxn.mod *
Nicotin.mod *
nmdanet.mod *
OdorInput.mod *
SineInput.mod
Background.hoc
Cal_Synch.hoc
Connect.hoc
Figure.hoc
GC_def.hoc
GC_save.hoc *
GC_Stim.hoc
Input.hoc
mathslib.hoc
MC_def.hoc
MC_save.hoc
MC_Stim.hoc
mosinit.hoc
OBNet.hoc
Parameter.hoc
PG_def.hoc
PG_save.hoc *
PG_Stim.hoc
SaveData.hoc
tabchannels.dat *
tabchannels.hoc
                            
// Calculate firing rate
objref mitrate, granrate, spk, hist
spk      = new Vector()
mitrate  = new Vector()
granrate = new Vector()

T = (tstop-ttrans)/1000

proc firing_rate() { local i, n

 for i = 0, nMit-1 {
    n = 0
	if (mit[i].spiketimes.size() > 0) {
      spk = mit[i].spiketimes
	  ind = spk.indwhere(">", ttrans)
	  if (ind != -1) {
	   //print ind
	   n = spk.size()-ind
	 }
    }
	mitrate.append(n/T)
  }
  
 for i = 0, nGran-1 {
    n = 0
	if (gran[i].spiketimes.size() > 0) {
      spk = gran[i].spiketimes
	  ind = spk.indwhere(">", ttrans)
	  if (ind != -1) {
	   //print ind
	   n = spk.size()-ind
	 }
    }
	granrate.append(n/T)
  }  
      
   print "\n Individual MC somatic firing rate:"
   mitrate.printf()
   print "\n The average MC somatic rate is:"
   print mitrate.mean()
   
   print "\n Individual GC dendritic firing rate:"
   granrate.printf()
   print "\n The average GC dendritic rate is:"
   print granrate.mean()  
   
// Create histogram
 minrate = mitrate.min()
 maxrate = mitrate.max()
 
 //hist = mitrate.histogram(minrate, maxrate, 10) 
   
   
// Save results to file   
  outfile.wopen("data/Fmit")
  mitrate.printf(outfile)
  outfile.close()

  outfile.wopen("data/Fgran")
  granrate.printf(outfile)
  outfile.close()  
  
  outfile.aopen(filename)

  outfile.printf("\nMitral average rate: %10.3f\n", mitrate.mean())  
  outfile.printf("Std: %10.3f\n", mitrate.stdev())
  outfile.printf("Granule average rate: %10.3f\n", granrate.mean())  
  outfile.printf("Std: %10.3f\n", granrate.stdev())  
  
  outfile.printf("\nIndividual mitral firing rate:\n")
  mitrate.printf(outfile)
  outfile.printf("Individual granule firing rate:\n")
  granrate.printf(outfile)

  outfile.close()   
}
   
  
// Calculate synchronization index    
  objref outfile, lags, work
  outfile = new File()
  lags 	  = new Vector()
  work 	  = new Vector()
  
  proc print_si() { // 1 arg - fileroot
  print "MC Soma synchronization index"
  print phaselock_index_Mit()
  print "MC Dend synchronization index"
  print phaselock_index_Mit_dend()  
  print "GC Dend synchronization index"  
  print phaselock_index_Gran()  
  
  sprint(filename,"%s",$s1)
  outfile.wopen(filename)
  outfile.printf("MC Soma Phase-locking index:   %10.3f\n",phaselock_index_Mit())
  outfile.printf("MC Dend Phase-locking index:   %10.3f\n",phaselock_index_Mit_dend())  
  outfile.printf("GC Dend Phase-locking index:   %10.3f\n",phaselock_index_Gran())  
  outfile.close()

  }

func phaselock_index_Mit() { local n,i1,j1,i2,j2
  synchindex = 0
  n = 0
  for i1 = 0, nMit-1 {
     if (mit[i1].spiketimes.size() > 0) {
        for i2 = 0, nMit-1 {
            if (i1 != i2) {
              calc_phase_lags_Mit(i1,i2,ttrans)
              if (lags.size() > 1) {
                synchindex += lags.var()
                n += 1
              }
            }
          }        
      }
  }
  if (n > 0) {
    synchindex = sqrt(synchindex/n)
    return synchindex
  } else {
    return 1e6
  }
}


func phaselock_index_Mit_dend() { local n,i1,j1,i2,j2
  synchindex = 0
  n = 0
  for i1 = 0, nMit-1 {
     if (mit[i1].dendspike.size() > 0) {
        for i2 = 0, nMit-1 {
            if (i1 != i2) {
              calc_phase_lags_Mit_dend(i1,i2,ttrans)
              if (lags.size() > 1) {
                synchindex += lags.var()
                n += 1
              }
            }
          }        
      }
  }
  if (n > 0) {
    synchindex = sqrt(synchindex/n)
    return synchindex
  } else {
    return 1e6
  }
}


func phaselock_index_Gran() { local n,i1,j1,i2,j2
  synchindex = 0
  n = 0
  for i1 = 0, nGran-1 {
     if (gran[i1].spiketimes.size() > 0) {
        for i2 = 0, nGran-1 {
            if (i1 != i2) {
              calc_phase_lags_Gran(i1,i2,ttrans)
              if (lags.size() > 1) {
                synchindex += lags.var()
                n += 1
              }
            }
          }        
      }
  }
  if (n > 0) {
    synchindex = sqrt(synchindex/n)
    return synchindex
  } else {
    return 1e6
  }
}


//=====================================================================================================

proc calc_phase_lags_Mit() { local i1,j1,i2,j2,k,minidx,min // 5 args - indices of mitral cells, transient time
    if ($1 > nMit || $2 > nMit) {
    print "Sorry - index out of range. Please try again."
    return
  }
  i1 = int($1)
  i2 = int($2)
  lags.resize(0)
  // for each spiketime in cell 1, find closest spike in cell 2
  // Note: first and last spikes ignored since can't calculate previous ISI
  if (mit[i2].spiketimes.size > 0) {
    for k = 1,mit[i1].spiketimes.size()-2 {
      if (mit[i1].spiketimes.x[k] > $3) {
        work = mit[i2].spiketimes.c.add(-mit[i1].spiketimes.x[k])
        minidx = work.c.abs.min_ind()
        min = work.x[minidx]
        isiprev = mit[i1].spiketimes.x[k-1]-mit[i1].spiketimes.x[k]
        isinext = mit[i1].spiketimes.x[k+1]-mit[i1].spiketimes.x[k]
        if (min > isiprev/2 && min < isinext/2) {
          if (min < 0) {
            lags.append(min/isiprev)
          } else {
            lags.append(min/isinext)
          }
        }
      }
    }
  }
}

proc calc_phase_lags_Mit_dend() { local i1,j1,i2,j2,k,minidx,min // 5 args - indices of mitral cells, transient time
    if ($1 > nMit || $2 > nMit) {
    print "Sorry - index out of range. Please try again."
    return
  }
  i1 = int($1)
  i2 = int($2)
  lags.resize(0)
  // for each spiketime in cell 1, find closest spike in cell 2
  // Note: first and last spikes ignored since can't calculate previous ISI
  if (mit[i2].dendspike.size > 0) {
    for k = 1,mit[i1].dendspike.size()-2 {
      if (mit[i1].dendspike.x[k] > $3) {
        work = mit[i2].dendspike.c.add(-mit[i1].dendspike.x[k])
        minidx = work.c.abs.min_ind()
        min = work.x[minidx]
        isiprev = mit[i1].dendspike.x[k-1]-mit[i1].dendspike.x[k]
        isinext = mit[i1].dendspike.x[k+1]-mit[i1].dendspike.x[k]
        if (min > isiprev/2 && min < isinext/2) {
          if (min < 0) {
            lags.append(min/isiprev)
          } else {
            lags.append(min/isinext)
          }
        }
      }
    }
  }
}

proc calc_phase_lags_Gran() { local i1,j1,i2,j2,k,minidx,min // 5 args - indices of mitral cells, transient time
    if ($1 > nGran || $2 > nGran) {
    print "Sorry - index out of range. Please try again."
    return
  }
  i1 = int($1)
  i2 = int($2)
  lags.resize(0)
  // for each spiketime in cell 1, find closest spike in cell 2
  // Note: first and last spikes ignored since can't calculate previous ISI
  if (gran[i2].spiketimes.size > 0) {
    for k = 1,gran[i1].spiketimes.size()-2 {
      if (gran[i1].spiketimes.x[k] > $3) {
        work = gran[i2].spiketimes.c.add(-gran[i1].spiketimes.x[k])
        minidx = work.c.abs.min_ind()
        min = work.x[minidx]
        isiprev = gran[i1].spiketimes.x[k-1]-gran[i1].spiketimes.x[k]
        isinext = gran[i1].spiketimes.x[k+1]-gran[i1].spiketimes.x[k]
        if (min > isiprev/2 && min < isinext/2) {
          if (min < 0) {
            lags.append(min/isiprev)
          } else {
            lags.append(min/isinext)
          }
        }
      }
    }
  }
}

Loading data, please wait...