Mechanisms of very fast oscillations in axon networks coupled by gap junctions (Munro, Borgers 2010)

 Download zip file 
Help downloading and running models
Axons connected by gap junctions can produce very fast oscillations (VFOs, > 80 Hz) when stimulated randomly at a low rate. The models here explore the mechanisms of VFOs that can be seen in an axonal plexus, (Munro & Borgers, 2009): a large network model of an axonal plexus, small network models of axons connected by gap junctions, and an implementation of the model underlying figure 12 in Traub et al. (1999) . The large network model consists of 3,072 5-compartment axons connected in a random network. The 5-compartment axons are the 5 axonal compartments from the CA3 pyramidal cell model in Traub et al. (1994) with a fixed somatic voltage. The random network has the same parameters as the random network in Traub et al. (1999), and axons are stimulated randomly via a Poisson process with a rate of 2/s/axon. The small network models simulate waves propagating through small networks of axons connected by gap junctions to study how local connectivity affects the refractory period.
1 . Munro E, Börgers C (2010) Mechanisms of very fast oscillations in networks of axons coupled by gap junctions. J Comput Neurosci 28:539-55 [PubMed]
Citations  Citation Browser
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network; Neuron or other electrically excitable cell; Axon;
Brain Region(s)/Organism: Hippocampus;
Cell Type(s): Hippocampus CA3 pyramidal GLU cell;
Channel(s): I Na,t; I K;
Gap Junctions: Gap junctions;
Simulation Environment: C or C++ program;
Model Concept(s): Oscillations; Detailed Neuronal Models; Axonal Action Potentials; Epilepsy; Conduction failure;
Implementer(s): Munro, Erin [ecmun at];
Search NeuronDB for information about:  Hippocampus CA3 pyramidal GLU cell; I Na,t; I K;
/* Establishes connections for n_row by n_col grid with
   max Euclidean distance r_c, and c connections
   per cell placed randomly. conn is an (n_row*n_col,4)
   array. Row i gives the numbers of the cells cell i
   is connected to
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include "connections.h"

static int within_bounds(int*,int*,int,int,double);
static int already_connected(int conn[][4],int,int);

void connections(int conn[][4],int n_row,int n_col,double r_c,double c){
  int x,y,i,a[2],b[2],a_index,b_index,rel_coord;
  unsigned long m, max_conn;
  int M=n_row*n_col;
  int n_conn[M];
  int d = floor(r_c);
  int rc_list[(int)pow(2*d+1,2)][2];

  // initialize the conn and n_conn matrices
    n_conn[x] = 0;
      conn[x][i] = -1;
  // number of connections to make
    max_conn = factorial(M-1);
    max_conn = 0;
  if(ceil(M*c/2) < max_conn){
    m = ceil(M*c/2);
    m = max_conn;
  // relative indexes of cells r_c from (0,0)
  i = 0;
      rc_list[i][0] = x;
      rc_list[i][1] = y;
      i = i+1;

  i = 0;
    // choose random cell a
    a_index = floor((double)rand()*M/RAND_MAX);
    // choose random cell b, at most r_c away from a,
    // include phantom cells
    rel_coord = floor(rand()*pow(2*d+1,2)/RAND_MAX);
    b[0] = rc_list[rel_coord][0] + a[0];
    b[1] = rc_list[rel_coord][1] + a[1];
    b_index = coord_to_index(b[0],b[1],n_row,n_col);
    if(within_bounds(a,b,n_row,n_col,r_c) & 
       n_conn[a_index] < 4 & n_conn[b_index] < 4 & 
      // cell is not phantom, connection not already made
      // set connection
      conn[a_index][n_conn[a_index]] = b_index;
      n_conn[a_index] = n_conn[a_index] + 1;
      conn[b_index][n_conn[b_index]] = a_index;
      n_conn[b_index] = n_conn[b_index] + 1;;
      m = m-1;
    i = i+1;

int coord_to_index(int x,int y,int n_row,int n_col){
  // translates row x, col y to cell #,
  // ordered by row then column
  // first row/col is #0, first cell is #0
  int index = x*n_col + y;
  return index;

int* index_to_coord(int index,int n_row,int n_col,int* coord){
  // give the coordinates in row and column # when
  // given the cells #
  // first row/col is #0, first cell is #0
  // row coordinate
  coord[0] = index/n_col;

  // column coordinate
  coord[1] = fmod(index,n_col);
  return coord;

int within_bounds(int* a,int* b,int n_row,int n_col,double r_c){
  /* Check if b is on the grid and in range of a */
  int yes;
  yes = 0<=b[0] & b[0]<n_row;
  yes = yes & 0<=b[1] & b[1]<n_col;
  yes = yes & sqrt(pow(a[0]-b[0],2)+pow(a[1]-b[1],2))<=r_c;
  return yes;

int already_connected(int conn[][4], int a_index,int b_index){
  int yes = 0;
  int k;
  if(a_index == b_index){
    return 1;
    if(conn[a_index][k] == b_index){
      yes = 1;
  return yes;