Cortical feedback alters visual response properties of dLGN relay cells (Martínez-Cañada et al 2018)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:239878
Network model that includes biophysically detailed, single-compartment and multicompartment neuron models of relay-cells and interneurons in the dLGN and a population of orientation-selective layer 6 simple cells, consisting of pyramidal cells (PY). We have considered two different arrangements of synaptic feedback from the ON and OFF zones in the visual cortex to the dLGN: phase-reversed (‘push-pull’) and phase-matched (‘push-push’), as well as different spatial extents of the corticothalamic projection pattern. This project is the result of a research work and its associated publication is: (Martínez-Cañada et al 2018). Installation instructions as well as the latest version can be found in the Github repository: https://github.com/CINPLA/biophysical_thalamocortical_system
Reference:
1 . Martínez-Cañada P, Mobarhan MH, Halnes G, Fyhn M, Morillas C, Pelayo F, Einevoll GT (2018) Biophysical network modeling of the dLGN circuit: Effects of cortical feedback on spatial response properties of relay cells. PLoS Comput Biol 14:e1005930 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism: Thalamus;
Cell Type(s):
Channel(s):
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: LFPy; NEURON; NEST; Python;
Model Concept(s): Vision;
Implementer(s): Martínez-Cañada, Pablo [pablomc at ugr.es];
#!/usr/bin/env python
# -*- coding: utf-8 -*-

## Interface for creating connection masks between neuronal layers.

from os.path import join
import numpy as np
import pylab as plt
from time import time
import neuron
import LFPy

nrn = neuron.h

# periodic boundary conditions
periodic = True

class Topology(object):

    def __init__(self):
        print("init")

    # Fit a number of cells 'nCell' into a square
    def fitSquare(self,N,nCell,position):
        conns = []
        nCell = float(nCell)
        for x in np.arange(0,np.ceil(nCell/int(np.sqrt(nCell)))):
            for y in np.arange(0,int(np.sqrt(nCell))):
                # continue last row until complete nCell
                if(len(conns) < nCell):
                    # periodic boundary conditions
                    if (np.remainder(position,N) + y) < N and (int(position/N) + x) < N:
                        conns.append(position + x*N + y)
                    elif (np.remainder(position,N) + y) >= N and (int(position/N) + x) < N:
                        conns.append(position + x*N + (N -1 - np.remainder(position,N)))
                    elif (np.remainder(position,N) + y) < N and (int(position/N) + x) >= N:
                        conns.append(np.remainder(position,N) + y + (N-1)*N)
                    else:
                        conns.append(N*N-1)

        return conns

    # Rectangular mask
    def rectMask(self,N,mask,position):
        conns = []
        mask[0] = float(mask[0])
        mask[1] = float(mask[1])

        start1 = 0
        start2 = 0

        # even
        if(np.remainder(mask[0],2)==0):
            start1 = -int(mask[0]/2) + int(position/N) + 1
        # odd
        else:
            start1 = -int(mask[0]/2) + int(position/N)

        # even
        if(np.remainder(mask[1],2)==0):
            start2 = -int(mask[1]/2) + np.remainder(position,N) + 1
        else:
            start2 = -int(mask[1]/2) + np.remainder(position,N)

        # Find connections
        for x in np.arange(start1,int(mask[0]/2)+1 + int(position/N)):
            for y in np.arange(start2,int(mask[1]/2)+1+np.remainder(position,N)):

                if(x>= 0 and y>=0 and x<N and y<N):
                    conns.append(x*N + y)
                else:
                    # periodic boundary conditions
                    if(periodic):
                        conn = 0.0
                        # Upper left
                        if(x<0 and y<0  and x<N and y<N):
                            conns.append((x+N)*N + (y+N))
                        # Top
                        elif(x< 0 and y>=0  and x<N and y<N):
                            conns.append((x+N)*N + y)
                        # Left
                        elif(x>= 0 and y<0  and x<N and y<N):
                            conns.append(x*N + (y+N))
                        # Upper right
                        elif(x< 0 and y>=0 and x<N and y>=N):
                            conns.append((x+N)*N + y-N)
                        # Right
                        elif(x>= 0 and y>=0 and x<N and y>=N):
                            conns.append(x*N + y-N)
                        # Bottom left
                        elif(x>= 0 and y<0 and x>=N and y<N):
                            conns.append((x-N)*N + y+N)
                        # Bottom
                        elif(x>= 0 and y>=0 and x>=N and y<N):
                            conns.append((x-N)*N + y)
                        # Bottom right
                        elif(x>= 0 and y>=0 and x>=N and y>=N):
                            conns.append((x-N)*N + (y-N))

        return conns

    # Display connectivity pattern
    def showConn(self,N,conns):
        matrix = np.zeros((N,N))

        for n in conns:
            matrix[int(n/N),np.remainder(n,N)]=1.0

        plt.matshow(matrix)
        plt.show()



Loading data, please wait...