Cancelling redundant input in ELL pyramidal cells (Bol et al. 2011)

 Download zip file 
Help downloading and running models
The paper investigates the property of the electrosensory lateral line lobe (ELL) of the brain of weakly electric fish to cancel predictable stimuli. Electroreceptors on the skin encode all signals in their firing activity, but superficial pyramidal (SP) cells in the ELL that receive this feedforward input do not respond to constant sinusoidal signals. This cancellation putatively occurs using a network of feedback delay lines and burst-induced synaptic plasticity between the delay lines and the SP cell that learns to cancel the redundant input. Biologically, the delay lines are parallel fibres from cerebellar-like granule cells in the eminentia granularis posterior. A model of this network (e.g. electroreceptors, SP cells, delay lines and burst-induced plasticity) was constructed to test whether the current knowledge of how the network operates is sufficient to cancel redundant stimuli.
1 . Bol K, Marsat G, Harvey-Girard E, Longtin A, Maler L (2011) Frequency-tuned cerebellar channels and burst-induced LTD lead to the cancellation of redundant sensory inputs. J Neurosci 31:11028-38 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network; Neuron or other electrically excitable cell;
Brain Region(s)/Organism: Cerebellum;
Cell Type(s): ELL pyramidal cell;
Gap Junctions:
Simulation Environment: C or C++ program; MATLAB;
Model Concept(s): Dendritic Action Potentials; Bursting; Active Dendrites; Synaptic Plasticity; Long-term Synaptic Plasticity; Learning; Unsupervised Learning; STDP; Biofeedback; Noise Sensitivity;
Implementer(s): Bol, Kieran [kieran_bol at];
#define IA 16807
#define IM 2147483647
#define AM (1.0/IM)
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)

/*Function prototype */
float ran1(long *idum);
float gasdev(long *idum);
void lowpassnoise(int length, long seed, double out[]);

float gasdev(long *idum)
/*Returns a normally distributed deviate with zero mean and unit variance, using ran1(idum)
as the source of uniform deviates.*/
/* This function and the random number generator is taken directly from Numerical Recipes in C, 2nd Ed.,
    Cambridge University press, by William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery
    ISBN 0-521-43108-5 */
    float ran1(long *idum);
    static int iset=0;
    static float gset;
    float fac,rsq,v1,v2;
    if (*idum < 0) iset=0; /*Reinitialize. */
        if (iset == 0) { /*We don't have an extra deviate handy, so do */
        do {
            v1=2.0*ran1(idum)-1.0; /* pick two uniform numbers in the square ex*/
            v2=2.0*ran1(idum)-1.0; /* tending from -1 to +1 in each direction, */
            rsq=v1*v1+v2*v2; /* see if they are in the unit circle, */
        } while (rsq >= 1.0 || rsq == 0.0); /*and if they are not, try again.*/
        /*Now make the Box-Muller transformation to get two normal deviates. Return one and
        save the other for next time.*/
        iset=1; /*Set flag.*/
        return v2*fac;
        } else { /*We have an extra deviate handy,*/
        iset=0; /*so unset the flag, */
        return gset; /*and return it.*/

float ran1(long *idum)
/* "Minimal" random number generator of Park and Miller with Bays-Durham shuffle and added
safeguards. Returns a uniform random deviate between 0.0 and 1.0 (exclusive of the endpoint
values). Call with idum a negative integer to initialize; thereafter, do not alter idum between
successive deviates in a sequence. RNMX should approximate the largest floating value that is
less than 1. */

/* This algorithm is good for random arrays less than 100 million */
int j;
long k;
static long iy=0;
static long iv[NTAB];
float temp;
if (*idum <= 0 || !iy) { /*Initialize.*/
if (-(*idum) < 1) *idum=1; /*Be sure to prevent idum = 0. */
else *idum = -(*idum);
for (j=NTAB+7;j>=0;j--) { /* Load the shue table (after 8 warm-ups). */
if (*idum < 0) *idum += IM;
if (j < NTAB) iv[j] = *idum;
k=(*idum)/IQ; /* Start here when not initializing. */
*idum=IA*(*idum-k*IQ)-IR*k; /* Compute idum=(IA*idum) % IM without overflows */
if(*idum < 0) *idum += IM; /* by Schrage's method. */
j=iy/NDIV; /* Will be in the range 0..NTAB-1. */
iy=iv[j]; /* Output previously stored value and refll the */
iv[j] = *idum; /* shue table. */
if ((temp=AM*iy) > RNMX) return RNMX; /* Because users don't expect endpoint values.*/ 
else return temp;

void lowpassnoise(int length, long seed, double out[])
    /*This function generates normally distributed random variables and then low-pass filters it
    with a 4th order Butterworth filter */
    int n;
    double *x,
    b[]={0.00011138, 0.00044552, 0.00066829, 0.00044552, 0.00011138}, a[]={1, -3.4259, 4.4368, -2.5712, 0.5621};
    /*Parameters for 4th order butterworth filter with 500Hz cutoff and sampling frequency = Fs/2, where Fs=1/delt/tau_m=1/0.01/0.007*/
    /* that leads to a ratio of cutoff to nyquist of 0.07 */

    /*Initializing vector to place normally distributed numbers in*/
    x=(double *) calloc(length,sizeof(double)); 
        x[n]=gasdev(&seed); /*Gets Gaussian random numbers*/
        if(n<4) out[n]=x[n];    
        else out[n]=b[0]*x[n] + b[1]*x[n-1]+b[2]*x[n-2]+b[3]*x[n-3]+b[4]*x[n-4] - a[1]*out[n-1] - a[2]*out[n-2] - a[3]*out[n-3] -a[4]*out[n-4];
    }           /*  -------------Feedforward filter parameters----------------    --------------Feedback filter parameters------------------ */               

Loading data, please wait...