{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#!/usr/bin/env python3\n", "# -*- coding: utf-8 -*-\n", "\"\"\"\n", "Created on Wed Apr 22 14:56:44 2020\n", "@author: aborst\n", "\"\"\"\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import blindschleiche_py3 as bs\n", "from scipy import ndimage\n", "\n", "from scipy import stats\n", "from scipy.signal import savgol_filter\n", "import octopus as oct" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "mylabelsize = 10\n", "mylegendsize = 10\n", "\n", "maxtime = 1000\n", "deltat = 10.0\n", "myt = np.arange(maxtime) * deltat / maxtime\n", "\n", "tf = np.zeros(1000)\n", "tf[100:400] = 1.0\n", "tf[600:900] = -1.0\n", " \n", "noisefac = 0.0\n", "\n", "T4d = np.zeros((30, 28, maxtime))\n", "T4c = np.zeros((30, 28, maxtime))\n", "T5d = np.zeros((30, 28, maxtime))\n", "T5c = np.zeros((30, 28, maxtime))\n", "\n", "T4T5d = np.zeros((6, 6, maxtime))\n", "T4T5c = np.zeros((6, 6, maxtime))\n", "\n", "LPi43 = np.zeros((6, 6, maxtime))\n", "LPi34 = np.zeros((6, 6, maxtime))\n", "\n", "T4T5d_mean = np.zeros(maxtime)\n", "T4T5c_mean = np.zeros(maxtime)\n", "LPi43_mean = np.zeros(maxtime)\n", "LPi34_mean = np.zeros(maxtime)\n", "\n", "VS = np.zeros(maxtime)\n", "Vx = np.zeros(maxtime)\n", "\n", "VSg_total = np.zeros(maxtime)\n", "VSx_total = np.zeros(maxtime)\n", "\n", "Vm = np.zeros((6, maxtime))\n", "Vinp = np.zeros((6, maxtime))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# L = LPi, T = T4T5, V = Vertical Cell\n", "\n", "defaultLTgain = 0.5 # a\n", "defaultTLgain = 1.0 # b\n", "defaultLLgain = 1.0 # c\n", "defaultTVgain = 1.0 # d\n", "defaultLVgain = 1.0 # e\n", "\n", "LVgain = defaultLVgain\n", "LLgain = defaultLLgain\n", "LTgain = defaultLTgain\n", "TVgain = defaultTVgain\n", "TLgain = defaultTLgain\n", "\n", "connM = np.zeros((6, 6))\n", "\n", "thrld = 0.0\n", "\n", "tauT = 20.0\n", "tauLPi = 20.0\n", "tauVS = 20.0\n", "\n", "tau = np.array([tauT, tauT, tauLPi, tauLPi, tauVS, tauVS])" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# ------ network calculations ------------------------\n", "\n", "def set_connM():\n", " \n", " global connM\n", " \n", " connM[0,:] = [0, 0, 0, -LTgain, 0, 0]\n", " connM[1,:] = [0, 0, -LTgain, 0, 0, 0]\n", " connM[2,:] = [TLgain, 0, 0, -LLgain, 0, 0]\n", " connM[3,:] = [0, TLgain, -LLgain, 0, 0, 0]\n", " connM[4,:] = [TVgain, 0, 0, -LVgain, 0, 0]\n", " connM[5,:] = [0, TVgain, -LVgain, 0, 0, 0]\n", " \n", " #print('Circuit reset')\n", " \n", " #print(connM)\n", " \n", " \n", "def block_feedb():\n", " \n", " global connM\n", " \n", " connM[0, :] = [0, 0, 0, 0, 0, 0]\n", " connM[1, :] = [0, 0, 0, 0, 0, 0]\n", " connM[2, :] = [TLgain, 0, 0, 0, 0, 0]\n", " connM[3, :] = [0, TLgain, 0, 0, 0, 0]\n", " connM[4, :] = [TVgain, 0, 0, -LVgain, 0, 0]\n", " connM[5, :] = [0, TVgain, -LVgain, 0, 0, 0]\n", " \n", " #print('Feedback blocked')\n", " \n", " #print(connM)\n", "\n", "def block_LPi43():\n", " \n", " global connM\n", " \n", " connM[:,2] = 0\n", " \n", " #print('LPi4-3 blocked')\n", " \n", " #print(connM)\n", " \n", "def block_LPi34():\n", " \n", " global connM\n", " \n", " connM[:, 3] = 0\n", " \n", " #print('LPi3-4 blocked')\n", " \n", " #print(connM ) \n", " \n", "def block_T4T5c():\n", " \n", " global connM\n", " \n", " connM[:, 1] = 0\n", " \n", " #print('T4T5c blocked')\n", " \n", " #print(connM)\n", " \n", "def reset_gains():\n", " \n", " global LVgain, LLgain, LTgain, TVgain, TLgain\n", " \n", " LVgain = defaultLVgain\n", " LLgain = defaultLLgain\n", " LTgain = defaultLTgain\n", " TVgain = defaultTVgain\n", " TLgain = defaultTLgain\n", " \n", " set_connM()\n", " \n", "set_connM()\n", "\n", "def small_network():\n", " \n", " for t in range(1,maxtime):\n", "\n", " total_input = connM.dot(bs.rect(Vm[:, t - 1], thrld)) + Vinp[:, t-1]\n", " Vm[:,t] = deltat / tau * (total_input - Vm[:, t-1]) + Vm[:, t-1]\n", " \n", " return Vm\n", "\n", "def test_small_network():\n", " \n", " set_connM()\n", " \n", " Vinp[0] = np.zeros(maxtime)\n", " Vinp[0, 200:800] = 1.0\n", " Vinp[1] = np.zeros(maxtime)\n", " Vinp[1, 200:800] = 1.0\n", " \n", " Vm=small_network()\n", " \n", " plt.plot(Vm[0], label = 'T4T5d')\n", " plt.plot(Vm[3], label = 'LPi34')\n", " plt.legend(loc = 1, frameon = False)\n", " \n", "def calc_HRBL(lp, hp):\n", " \n", " noff = 30\n", " DC = 0.02\n", " \n", " A = bs.rect(lp[:, 0:noff-2, :], 0)\n", " B = bs.rect(hp[:, 1:noff-1, :], 0)\n", " C = bs.rect(lp[:, 2:noff-0, :], 0)\n", " \n", " Txa = bs.rect(A * B / (DC + C), DC)\n", " \n", " A = bs.rect(lp[:, 2:noff-0, :], 0)\n", " B = bs.rect(hp[:, 1:noff-1, :], 0)\n", " C = bs.rect(lp[:, 0:noff-2, :], 0)\n", " \n", " Txb = bs.rect(A * B / (DC + C), DC)\n", " \n", " return Txa, Txb\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# ---------------------------- Large Network ---------------------------------\n", "\n", "def large_network():\n", " \n", " global T4d,T4c,T5d,T5c,T4T5d_mean,T4T5c_mean,LPi43_mean,LPi34_mean,stimulus,VS,Vx,VSg_total,Vxg_total\n", " \n", " syn_gain = 1\n", " \n", " n = stimulus.shape\n", " maxtime = n[2]\n", " noff = 30\n", " \n", " lptau = 50.0 / deltat\n", " hptau = 250.0 / deltat\n", " \n", " R16 = bs.rebin(stimulus, noff, noff, maxtime)\n", " \n", " interim = bs.highpass(R16, hptau)\n", " interim = interim + 0.1 * R16\n", " L1 = bs.rect(interim, 0)\n", " L2 = bs.rect(-(interim - 0.05), 0)\n", " \n", " ONlp = bs.lowpass(R16, lptau)\n", " ONhp = L1\n", " OFFlp = bs.lowpass(1.0 - R16, lptau)\n", " OFFhp = L2\n", "\n", " T4d, T4c = calc_HRBL(ONlp, ONhp)\n", " T5d, T5c = calc_HRBL(OFFlp, OFFhp)\n", " \n", " for i in range(6):\n", " \n", " for j in range(6):\n", " \n", " Vinp[0] = np.mean(bs.rect(T4d[i*5:i*5+5,j*5:j*5+5,:],0), axis=(0,1))\n", " Vinp[0] += np.mean(bs.rect(T5d[i*5:i*5+5,j*5:j*5+5,:],0), axis=(0,1))\n", " \n", " Vinp[1] = np.mean(bs.rect(T4c[i*5:i*5+5,j*5:j*5+5,:],0), axis=(0,1))\n", " Vinp[1] += np.mean(bs.rect(T5c[i*5:i*5+5,j*5:j*5+5,:],0), axis=(0,1))\n", " \n", " Vm = small_network()\n", " \n", " T4T5d[i,j] = Vm[0]\n", " T4T5c[i,j] = Vm[1]\n", " LPi43[i,j] = Vm[2]\n", " LPi34[i,j] = Vm[3]\n", " \n", " T4T5d_mean = np.mean(T4T5d,axis = (0,1))\n", " T4T5c_mean = np.mean(T4T5c,axis = (0,1))\n", " LPi43_mean = np.mean(LPi43,axis = (0,1))\n", " LPi34_mean = np.mean(LPi34,axis = (0,1))\n", " \n", " T4T5d_mean = T4T5d_mean - np.mean(T4T5d_mean[0:250])\n", " T4T5c_mean = T4T5c_mean - np.mean(T4T5c_mean[0:250])\n", " LPi43_mean = LPi43_mean - np.mean(LPi43_mean[0:250])\n", " LPi34_mean = LPi34_mean - np.mean(LPi34_mean[0:250]) \n", " \n", " \n", " # Calculate conductances of VS inputs\n", " \n", " gexcVS = np.mean(bs.rect(T4T5d, thrld), axis = (0,1)) * connM[4,0] * syn_gain\n", " ginhVS = np.mean(bs.rect(LPi34, thrld), axis = (0,1)) * (-connM[4,3]) * syn_gain\n", " \n", " gexcVx = np.mean(bs.rect(T4T5c, thrld), axis = (0,1)) * connM[5,1] * syn_gain\n", " ginhVx = np.mean(bs.rect(LPi43, thrld), axis = (0,1)) * (-connM[5,2]) * syn_gain\n", " \n", " VSg_total = gexcVS + ginhVS + 1.0\n", " Vxg_total = gexcVx + ginhVx + 1.0\n", " \n", " VS = (40.0 * gexcVS - 20.0 * ginhVS) / VSg_total \n", " Vx = (40.0 * gexcVx - 20.0 * ginhVx) / Vxg_total\n", " \n", " VS = VS - np.mean(VS[0:250])\n", " Vx = Vx - np.mean(Vx[0:250])\n", " \n", " #T4T5d_mean[0:250] = 0\n", " #T4T5c_mean[0:250] = 0\n", " #LPi43_mean[0:250] = 0\n", " #LPi34_mean[0:250] = 0\n", " #VS[0:250] = 0\n", " #Vx[0:250] = 0" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "thrld" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# ----------------------------------------------------------------------------- \n", "# -------------- create visual stimuli, calculate responses -------------------\n", "# -----------------------------------------------------------------------------\n", "# -------------------sine grating directional tuning --------------------------\n", "\n", "def calc_singlewave(img_size, new_spat_freq, x, y):\n", " \n", " sinewave = np.sin((np.linspace(0,img_size-1,img_size)-x+y)/img_size*2.0*np.pi*new_spat_freq)\n", " return sinewave\n", " \n", "def calc_sine(tf, img_rot, spat_freq, contrast):\n", " \n", " print()\n", " print('rot angle =', img_rot)\n", " \n", " n = tf.shape\n", " maxtime = n[0]\n", " img_size = 180\n", " movie = np.zeros((img_size,img_size,maxtime))\n", " img_rot_rad = img_rot / 360.0 * 2 * np.pi\n", " new_spat_freq = spat_freq * np.cos(img_rot_rad)\n", " spat_wlength = img_size / spat_freq\n", " velo = tf * spat_wlength / 100.0\n", " \n", " print('Spatial Wavelength =', spat_wlength)\n", " print('Velocity (dt=10 msec) =', np.max(np.abs(velo)) * 100, 'deg/s')\n", " print('Temp Freq (dt=10 msec) =', np.max(np.abs(tf)), 'Hz')\n", " \n", " yshift = np.tan(img_rot_rad)\n", " \n", " new_velo = velo / np.cos(img_rot_rad)\n", " \n", " if img_rot == 0:\n", " image = np.zeros((img_size, img_size))\n", " interim = calc_singlewave(img_size, spat_freq, 0, 0)\n", " for i in range(img_size):\n", " image[i,0::] = interim \n", " for i in range(maxtime):\n", " movie[:,:,i] = np.roll(image, int(sum(velo[0:i])), axis=1) \n", " else: \n", " for i in range(maxtime):\n", " for y in range(img_size):\n", " movie[y,:,i] = calc_singlewave(180,new_spat_freq,int(sum(new_velo[0:i])),int(yshift*y)) \n", " \n", " movie = movie * contrast * 0.5 + 0.5\n", " \n", " return movie\n", " \n", "def store_grating_dir_stimuli_on_disc():\n", " \n", " tf = np.zeros(maxtime)\n", " tf[100:maxtime] = 1.0\n", " \n", " dirname = 'C:/Users/gammer/Desktop/DATA Surface/LPi Opponency/Modelling Axel/'\n", " \n", " for i in range(12):\n", " \n", " angle = i * 30\n", " print(angle,' deg')\n", " \n", " stimulus = calc_sine(tf, angle, 6, 1)\n", " \n", " fname = 'Grating' + np.str(angle) + 'deg.npy'\n", " print(fname)\n", " \n", " np.save(dirname + fname, stimulus)\n", " \n", "def calc_dirtuning():\n", " \n", " global stimulus\n", " \n", " nofconditions = 4\n", " nofcells = 6\n", " nofdirs = 12\n", " \n", " dirtuning = np.zeros((nofcells, nofconditions, nofdirs))\n", " \n", " dirname='C:/Users/gammer/Desktop/DATA Surface/LPi Opponency/Modelling Axel/'\n", " \n", " for direction in range(12):\n", " \n", " angle = direction * 30\n", " #print(angle,' deg')\n", " fname = 'Grating' + np.str(angle) + 'deg.npy'\n", " stimulus = np.load(dirname + fname)\n", " \n", " for condition in range(nofconditions):\n", " \n", " reset_gains()\n", " \n", " # set condition\n", " \n", " if condition == 0: reset_gains() \n", " if condition == 1: block_LPi43()\n", " if condition == 2: block_T4T5c()\n", " if condition == 3: block_feedb()\n", " \n", " large_network()\n", " \n", " # assign cells to output array\n", " \n", " dirtuning[0,condition,direction] = np.mean(T4T5d_mean[500:maxtime])-np.mean(T4T5d_mean[50:100])\n", " dirtuning[1,condition,direction] = np.mean(T4T5c_mean[500:maxtime])-np.mean(T4T5c_mean[50:100])\n", " dirtuning[2,condition,direction] = np.mean(LPi43_mean[500:maxtime])-np.mean(LPi43_mean[50:100])\n", " dirtuning[3,condition,direction] = np.mean(LPi34_mean[500:maxtime])-np.mean(LPi34_mean[50:100])\n", " dirtuning[4,condition,direction] = np.mean(VS[500:maxtime])-np.mean(VS[50:100])\n", " dirtuning[5,condition,direction] = np.mean(Vx[500:maxtime])-np.mean(Vx[50:100])\n", " \n", " return dirtuning" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# -------------- transparent motion ------------------------------------------\n", " \n", "def calc_TM_stimulus(maxtime, velo, index):\n", "\n", " nofdots = 200 # total number of dots in whole movie\n", " \n", " PD = [0.0, 12.5, 25.0, 37.5, 50.0, 50.0, 50.0, 50.0, 50.0, 100.0, 0.0]\n", " ND = [50.0, 50.0, 50.0, 50.0, 50.0, 37.5, 25.0, 12.5, 0.0, 0.0, 100.0]\n", " ST = [50.0, 37.5, 25.0, 12.5, 0.0, 12.5, 25.0, 37.5, 50.0, 0.00, 0.00]\n", " \n", " nofPD_dots = int(PD[index] * 0.01 * nofdots)\n", " nofND_dots = int(ND[index] * 0.01 * nofdots)\n", " nofST_dots = int(ST[index] * 0.01 * nofdots)\n", " \n", " print( 'nof dots: ', nofdots)\n", " print( 'nof PD d: ', nofPD_dots)\n", " print( 'nof ND d: ', nofND_dots)\n", " print( 'nof ST d: ', nofST_dots)\n", " \n", " movie = np.zeros((200,200,maxtime))\n", " \n", " # avoid placing dots on edges by limiting xpos and ypos to bewteen 10 and 190 \n", " \n", " PDxpos = np.random.randint(10,190, size=nofPD_dots)\n", " PDypos = np.random.randint(10,190, size=nofPD_dots)\n", " \n", " NDxpos = np.random.randint(10,190, size=nofND_dots)\n", " NDypos = np.random.randint(10,190, size=nofND_dots)\n", " \n", " STxpos = np.random.randint(10,190, size=nofST_dots)\n", " STypos = np.random.randint(10,190, size=nofST_dots)\n", " \n", " # calc individual patch\n", " \n", " patch = bs.Gauss2D(5,20)\n", " patch = patch / np.max(patch)\n", " \n", " # set up frames\n", " \n", " PDframe = np.zeros((200,200))\n", " NDframe = np.zeros((200,200))\n", " STframe = np.zeros((200,200))\n", " \n", " # put patches on frames\n", " \n", " if nofPD_dots > 0:\n", " \n", " interim = np.zeros((200, 200, nofPD_dots))\n", " for i in range(nofPD_dots):\n", " interim[PDxpos[i]-10:PDxpos[i]+11,PDypos[i]-10:PDypos[i]+11,i] = patch\n", " PDframe = interim.max(2)\n", " \n", " if nofND_dots > 0:\n", " \n", " interim = np.zeros((200,200,nofND_dots))\n", " for i in range(nofND_dots):\n", " interim[NDxpos[i]-10:NDxpos[i]+11,NDypos[i]-10:NDypos[i]+11,i] = patch\n", " if nofND_dots>0:\n", " NDframe = interim.max(2)\n", " \n", " if nofST_dots > 0:\n", "\n", " interim = np.zeros((200,200,nofST_dots))\n", " for i in range(nofST_dots):\n", " interim[STxpos[i]-10:STxpos[i]+11,STypos[i]-10:STypos[i]+11,i] = patch\n", " if nofST_dots>0:\n", " STframe = interim.max(2)\n", " \n", " # calculate movie\n", " \n", " for i in range(maxtime):\n", " \n", " f1 = np.roll(PDframe, int(velo*i))\n", " f2 = np.roll(NDframe, -int(velo*i))\n", " f3 = STframe\n", " z = np.stack((f1,f2,f3))\n", " movie[:,:,i] = z.max(0)\n", " \n", " for i in range(250): \n", " movie[:,:,i] = movie[:,:,250]\n", " \n", " for i in range(250): \n", " movie[:,:,i+750] = movie[:,:,750]\n", " \n", " return movie\n", " \n", "def store_TM_stimuli_on_disk():\n", " \n", " dirname='C:/Users/gammer/Desktop/DATA Surface/LPi Opponency/Modelling Axel/'\n", "\n", " for i in range(9):\n", " \n", " fname = 'TPnoise' + np.str(i) + '.npy'\n", " stim = calc_TM_stimulus(1000, 1, i)\n", " np.save(dirname + fname, stim)\n", "\n", "def calc_TM_response(nofreps = 1, switch = 2):\n", " \n", " # if switch=1: stimulus is read from file on disk\n", " # if switch=2: stimulus is calculated each time\n", " \n", " global LVgain, LLgain, LTgain, TVgain, TLgain, VS, stimulus\n", " \n", " nofcells = 6\n", " nofconditions = 4\n", " nofstim = 3 # PD, ND, TM\n", " \n", " dirname = 'C:/Users/gammer/Desktop/DATA Surface/LPi Opponency/Modelling Axel/'\n", " fname = ['TPnoise0.npy', 'TPnoise8.npy', 'TPnoise4.npy']\n", " stim_seq = [0, 8, 4]\n", "\n", " TM_response = np.zeros((nofcells, nofconditions, nofstim, maxtime))\n", " \n", " for n in range(nofreps):\n", "\n", " for stim in range(3):\n", "\n", " if switch == 1:\n", " stimulus = np.load(dirname + fname[stim])\n", " print('filename=', fname[stim])\n", " if switch == 2:\n", " stimulus = calc_TM_stimulus(maxtime, 1, stim_seq[stim])\n", " print('calculated new TM stimulus')\n", " \n", " stimulus = stimulus[0:180,0:180]\n", " \n", " for condition in range(nofconditions):\n", " \n", " reset_gains()\n", " \n", " # set condition\n", " \n", " if condition == 0: reset_gains() \n", " if condition == 1: block_LPi43()\n", " if condition == 2: block_T4T5c()\n", " if condition == 3: block_feedb()\n", " \n", " large_network()\n", "\n", " TM_response[0,condition,stim] += T4T5d_mean - np.mean(T4T5d_mean[0:100])\n", " TM_response[1,condition,stim] += T4T5c_mean - np.mean(T4T5c_mean[0:100])\n", " TM_response[2,condition,stim] += LPi43_mean - np.mean(LPi43_mean[0:100])\n", " TM_response[3,condition,stim] += LPi34_mean - np.mean(LPi34_mean[0:100])\n", " TM_response[4,condition,stim] += VS - np.mean(VS[0:100])\n", " TM_response[5,condition,stim] += Vx - np.mean(Vx[0:100])\n", " \n", " TM_response = TM_response / (1.0 * nofreps)\n", " \n", " return TM_response" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# -------------- VS conductance change ---------------------------------------\n", "\n", "def calc_split_motion_stimulus():\n", " \n", " PD_motion = calc_TM_stimulus(1000, 1, 9)\n", " ND_motion = calc_TM_stimulus(1000, 1, 10)\n", " split_motion = 1.0 * PD_motion\n", " split_motion[100:200] = ND_motion[100:200]\n", " \n", " return split_motion\n", "\n", "def store_split_motion_to_disk():\n", " \n", " dirname = 'C:/Users/gammer/Desktop/DATA Surface/LPi Opponency/Modelling Axel/'\n", " \n", " stim = calc_split_motion_stimulus()\n", " np.save(dirname + 'split_motion.npy', stim)\n", "\n", "def calc_VS_conductance(condition = 3, switch = 2):\n", " \n", " global stimulus\n", " \n", " # if switch=1: stimulus is read from file on disk\n", " # if switch=2: stimulus is calculated each time\n", " \n", " VS_cntrl = np.zeros((4, maxtime))\n", " VS_block = np.zeros((4, maxtime))\n", " g_cntrl = np.zeros((4, maxtime))\n", " g_block = np.zeros((4, maxtime))\n", " \n", " dirname = 'C:/Users/gammer/Desktop/DATA Surface/LPi Opponency/Modelling Axel'\n", " \n", " fname = ['TPnoise8.npy','TPnoise0.npy','TPnoise4.npy','split_motion.npy']\n", " stim_seq = [8, 0, 4]\n", " \n", " for i in range(4):\n", " \n", " if switch == 1:\n", " stimulus = np.load(dirname + fname[i])\n", " print(fname[i])\n", " if switch == 2:\n", " if i < 3: stimulus = calc_TM_stimulus(maxtime, 1, stim_seq[i])\n", " if i > 2: stimulus = calc_split_motion_stimulus()\n", " print('calculated new TM stimulus') \n", " \n", " stimulus = stimulus[10:190, 10:190]\n", " \n", " reset_gains()\n", " \n", " large_network()\n", " \n", " VS_cntrl[i] = 1.0 * VS\n", " g_cntrl[i] = 1.0 * VSg_total #/np.mean(VSg_total[1:100])\n", " \n", " # set condition\n", " \n", " if condition == 0: reset_gains() \n", " if condition == 1: block_LPi43()\n", " if condition == 2: block_T4T5c()\n", " if condition == 3: block_feedb()\n", " \n", " large_network()\n", " \n", " VS_block[i] = 1.0 * VS\n", " g_block[i] = 1.0 * VSg_total\n", " \n", " return VS_cntrl, VS_block, g_cntrl, g_block\n", " " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# ----------------------------------------------------------------------------\n", " \n", "def calc_all():\n", " \n", " dirtuning = calc_dirtuning()\n", " TM_response = calc_TM_response()\n", " VS_cntrl, VS_block, g_cntrl, g_block = calc_VS_conductance()\n", " \n", " return dirtuning, TM_response, VS_cntrl, VS_block, g_cntrl, g_block" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": false }, "outputs": [], "source": [ "dirtuning = calc_dirtuning()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "scrolled": false }, "outputs": [], "source": [ "#TM_response = calc_TM_response()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "scrolled": false }, "outputs": [], "source": [ "#VS_cntrl, VS_block, g_cntrl, g_block = calc_VS_conductance()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "#------------------------------------------------------------------------------ \n", "# ----------------------- Plotting --------------------------------------------\n", "#------------------------------------------------------------------------------\n", "\n", "plt.rc('xtick', labelsize = 10)\n", "plt.rc('ytick', labelsize = 10)\n", "mylabel = ['T4d', 'T4c', 'LPi4-3', 'LPi3-4', 'VS', 'Vx']\n", "block_condition = np.array(['Control', 'LPi4-3 block', 'T4T5c block', 'No Feedback'])\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# ----------------- Just for me, no figure in paper --------------------------------\n", "\n", "def plot_network(condition):\n", " \n", " myt = np.arange(maxtime) * 0.01\n", " cell_color = ['red','purple','orange','blue','magenta','green']\n", " cell_type = ['T4T5c','T4T5d','LPi34','LPi43','Vx','VS']\n", " frame_pos = [1,2,5,6]\n", " mylw = 2\n", " \n", " for j in range(2):\n", " \n", " for i in range(4):\n", " \n", " if i==0: data = np.mean(T4T5c[j*3:j*3+3],axis=(0,1))\n", " if i==1: data = np.mean(T4T5d[j*3:j*3+3],axis=(0,1))\n", " if i==2: data = np.mean(LPi34[j*3:j*3+3],axis=(0,1))\n", " if i==3: data = np.mean(LPi43[j*3:j*3+3],axis=(0,1))\n", "\n", " if condition==1: \n", " mycolor='black'\n", " mylabel='fb block'\n", " if condition==2: \n", " mycolor=cell_color[i]\n", " mylabel='control'\n", " \n", " ylow = -1.0\n", " yhigh = 1.5\n", " \n", " plt.subplot(3,4,j*2+frame_pos[i])\n", " \n", " plt.plot(myt,data,color=mycolor,linewidth=mylw,label=mylabel)\n", " plt.yticks(np.arange(3)-1,np.arange(3)-1)\n", " plt.xticks(np.arange(3)*5,'')\n", " plt.title(cell_type[i])\n", " plt.ylim(ylow,yhigh)\n", " plt.xlim(0,10)\n", " \n", " for j in range(2):\n", " \n", " if j==0: data=Vx\n", " if j==1: data=VS\n", " \n", " if condition==1: \n", " mycolor='black'\n", " mylabel='fb block'\n", " if condition==2: \n", " mycolor=cell_color[4+j]\n", " mylabel='control'\n", " \n", " ylow = -4\n", " yhigh = 8\n", " \n", " plt.subplot(3,4,10+j)\n", " \n", " plt.plot(myt,data,color=mycolor,linewidth=mylw,label=mylabel)\n", " plt.title(cell_type[4+j])\n", " plt.ylim(ylow,yhigh)\n", " plt.xticks(np.arange(3)*5,np.arange(3)*5)\n", " plt.xlim(0,10)\n", " plt.legend(loc=1,frameon=False)\n", " plt.xlabel('time [s]')\n", " \n", "\n", "def compare_network():\n", " \n", " global stimulus\n", " \n", " stimulus = stimulus[10:190,10:190]\n", " \n", " plt.figure(figsize = (10,6))\n", " \n", " block_feedb()\n", " large_network()\n", " plot_network(1)\n", " \n", " reset_gains()\n", " large_network()\n", " plot_network(2)\n", " " ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# ---------- Figure 7A -------------------------------------------------------------\n", " \n", "def plot_dirtuning(input_tuning, cell_color, location):\n", " \n", " dirtuning = 1.0 * input_tuning\n", " \n", " mydirtuning = np.zeros((4,13))\n", " \n", " mylw = 2\n", " \n", " for i in range(4):\n", " dirtuning[i] = dirtuning[i] / np.max(input_tuning[0])\n", " dirtuning[i] = np.roll(dirtuning[i], -3)\n", " mydirtuning[i, 0:12] = dirtuning[i]\n", " mydirtuning[i, 12] = dirtuning[i, 0]\n", " \n", " # control\n", "\n", " plt.plot(mydirtuning[0], linewidth = mylw, color = '0.4', label = 'Control', zorder=0)\n", " plt.scatter(np.arange(13), mydirtuning[0], color = '0.4', linewidth = 0.5, zorder=0)\n", " \n", " # T4/T5c block\n", "\n", " plt.plot(mydirtuning[2], linewidth = mylw, color = cell_color, label = 'T4/T5c block', zorder=1)\n", " plt.scatter(np.arange(13), mydirtuning[2], color = cell_color, linewidth = 0.5, zorder=1)\n", " \n", " \n", " plt.plot(np.arange(13), np.arange(13) * 0, color = '0.05',linestyle = ':', linewidth = 1)\n", " \n", " plt.xticks(np.arange(5) * 3, np.arange(5) * 90)\n", " plt.xlabel(u'Direction [°]', fontsize = mylabelsize)\n", " \n", " plt.yticks(np.arange(5)/2-1, np.arange(5)/2-1)\n", " \n", " #t.legend(loc = location, frameon = False, fontsize = mylegendsize)\n", " \n", " plt.ylim(-1.1, 1.1)\n", " plt.xlim(0, 12)\n", "\n", " dirtuning_resp = np.zeros((2,13))\n", " dirtuning_resp[0] = mydirtuning[0]\n", " dirtuning_resp[1] = mydirtuning[2]\n", " \n", " return dirtuning_resp\n", "\n", " \n", "def plot_Figure7A(dirtuning):\n", " \n", " fig = plt.figure(figsize = (11, 2.3))\n", " plt.subplots_adjust(wspace = 0.35)\n", " #plt.subplots_adjust(hspace = 0.3)\n", " \n", " sequence = [4,3,2,1]\n", " locseq = [4,3,4,3]\n", " cell_color = ['C2','C1','C0','C3']\n", " \n", " dirtuning_resp = np.zeros((4,2,13))\n", " \n", " for i in range(4):\n", " \n", " ax = fig.add_subplot(1, 4, i+1)\n", " dirtuning_resp[i] = plot_dirtuning(dirtuning[sequence[i]], cell_color[i], locseq[i])\n", " if i == 0:\n", " plt.ylabel('Response [a.u.]', fontsize = mylabelsize)\n", " #plt.title(mylabel[sequence[i]], fontsize = 10)\n", "\n", " #xticks = np.array([0,90,180,270,360])\n", " #ax.set_xticklabels(xticks, size=11)\n", " ax.spines[\"top\"].set_visible(False)\n", " ax.spines[\"right\"].set_visible(False)\n", " ax.spines['left'].set_position(('outward', 7))\n", " ax.spines['bottom'].set_position(('outward', 7))\n", " \n", " return dirtuning_resp" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# ----------------------------- plot 7A,B,C -----------------------------------\n", " \n", "def plot_Figure7(dirtuning, TM_response, VS_cntrl, VS_block, g_cntrl, g_block):\n", " \n", " plot_Figure7A(dirtuning)\n", " plot_Figure7B(TM_response)\n", " plot_Figure7C(VS_cntrl, VS_block, g_cntrl, g_block)\n", " " ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "dirtuning_resp = plot_Figure7A(dirtuning)\n", "\n", "bbox_inches = 'tight'\n", "#plt.savefig('C:\\\\Users\\\\gammer\\\\Desktop\\\\DATA Surface\\\\LPi Opponency\\\\plots_LPi_ms\\\\\\\n", "#Fig7A_Tuning_Curves.pdf', bbox_inches = 'tight', dpi = 600, transparent = True)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "R_magn =5.34270299889142 R_deg = 273.56444333921706\n", "R_indiv_magn = 7.226779124822744\n", "LDir = 0.7392924159727193\n", "R_magn =5.8050559322091875 R_deg = 92.3780432583662\n", "R_indiv_magn = 7.387827274762005\n", "LDir = 0.7857595631722717\n", "R_magn =5.616908677829323 R_deg = 272.4156758598078\n", "R_indiv_magn = 7.152441481276007\n", "LDir = 0.7853134754801597\n", "R_magn =4.034858664500519 R_deg = 91.1851551908574\n", "R_indiv_magn = 5.112986921253916\n", "LDir = 0.7891392500395845\n", "R_magn =2.4352013653821802 R_deg = 269.9948213512603\n", "R_indiv_magn = 4.564198136743679\n", "LDir = 0.5335441828823785\n", "R_magn =2.4075821453252235 R_deg = 90.00019298143208\n", "R_indiv_magn = 3.664670910788769\n", "LDir = 0.6569708996890598\n", "R_magn =2.330425422392065 R_deg = 270.00016686514755\n", "R_indiv_magn = 3.547247036909174\n", "LDir = 0.6569673321716654\n", "R_magn =3.779753839179044 R_deg = 89.98796591477752\n", "R_indiv_magn = 4.6880783135721975\n", "LDir = 0.8062480160018843\n", "D_magn =3.2511565727933256 D_deg = 276.1326100714301\n", "H_magn =2.099871085011256 H_deg = 269.58637705314544\n", "MOI = 0.6416732846852118\n", "D_magn =2.8348306295174557 D_deg = 92.71532542257523\n", "H_magn =2.970321297412781 H_deg = 92.05614632471806\n", "MOI = 0.9543220199368273\n", "D_magn =2.7826320411362673 D_deg = 273.6205314308464\n", "H_magn =2.835495615743216 H_deg = 271.2332862383259\n", "MOI = 0.9805048033437983\n", "D_magn =2.759476466681735 D_deg = 91.87507715682816\n", "H_magn =1.276014939420795 H_deg = 89.6930154219206\n", "MOI = 0.46207666507361556\n", "D_magn =2.4352013653821802 D_deg = 269.9948213512603\n", "H_magn =0.0 H_deg = 0.0\n", "MOI = -0.0\n", "D_magn =0.0 D_deg = 0.0\n", "H_magn =2.4075821453252235 H_deg = 90.00019298143208\n", "MOI = -0.0\n", "D_magn =2.330425422392065 D_deg = 270.00016686514755\n", "H_magn =0.0 H_deg = 0.0\n", "MOI = 0.0\n", "D_magn =2.5863551876320385 D_deg = 89.98847709446277\n", "H_magn =1.1933986518730204 H_deg = 89.98685807689894\n", "MOI = 0.46142102101962335\n" ] } ], "source": [ "# Calculate LDir, MOI, and R_deg for grating tuning curves\n", "\n", "dirtuning_resp_12 = dirtuning_resp[:,:,:12]\n", "rot = (np.arange(12) * 30)\n", "rot_rad = np.radians(rot)\n", "\n", "LDir_ctrl = np.empty(len(dirtuning_resp_12[:,0,0]))\n", "for i in range(len(dirtuning_resp_12[:,0,0])):\n", " LDir_ctrl[i] = oct.LDir(rot_rad, dirtuning_resp_12[i,0,:])\n", "\n", "LDir_block = np.empty(len(dirtuning_resp_12[:,1,0]))\n", "for i in range(len(dirtuning_resp_12[:,1,0])):\n", " LDir_block[i] = oct.LDir(rot_rad, dirtuning_resp_12[i,1,:])\n", " \n", "MOI_ctrl = np.empty(len(dirtuning_resp_12[:,0,0]))\n", "for i in range(len(dirtuning_resp_12[:,0,0])):\n", " MOI_ctrl[i] = oct.MOI(rot_rad, dirtuning_resp_12[i,0,:])\n", "\n", "MOI_block = np.empty(len(dirtuning_resp_12[:,1,0]))\n", "for i in range(len(dirtuning_resp_12[:,1,0])):\n", " MOI_block[i] = oct.MOI(rot_rad, dirtuning_resp_12[i,1,:])\n", " \n", "R_deg_ctrl = np.empty(len(dirtuning_resp_12[:,0,0]))\n", "for i in range(len(dirtuning_resp_12[:,0,0])):\n", " R_deg_ctrl[i] = oct.R_deg(rot_rad, dirtuning_resp_12[i,0,:])\n", "\n", "R_deg_block = np.empty(len(dirtuning_resp_12[:,1,0]))\n", "for i in range(len(dirtuning_resp_12[:,1,0])):\n", " R_deg_block[i] = oct.R_deg(rot_rad, dirtuning_resp_12[i,1,:])" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Make Scatter Plot of LDir\n", "\n", "pos = [0, 1, 3, 4, 6, 7, 9, 10]\n", "\n", "fig = plt.figure(figsize = (0.4*len(pos), 2.25))\n", "\n", "ax = fig.add_subplot(111)\n", "w = 0.6\n", "wb = 0.6\n", "data = [LDir_ctrl[0], LDir_block[0], LDir_ctrl[1], LDir_block[1], LDir_ctrl[2], LDir_block[2], LDir_ctrl[3], LDir_block[3]]\n", "\n", "colors = ['C2', 'C2', 'C1', 'C1', 'C0', 'C0', 'C3', 'C3']\n", "\n", "ax.axhline(y=0,xmin=0.0001,xmax=0.9999, color='0.05', linestyle=':', linewidth = 1)\n", "\n", "for j in range (len(data)):\n", " ax.plot([pos[j]-w/2, pos[j]+w/2],[(data[j]), (data[j])],\n", " color=colors[j], linestyle='-', linewidth = 4)\n", "\n", "ax.spines[\"top\"].set_visible(False)\n", "ax.spines[\"right\"].set_visible(False)\n", "ax.spines['left'].set_position(('outward', 7))\n", "ax.spines['bottom'].set_position(('outward', 7))\n", "ax.set_xticks(pos)\n", "ax.set_xticklabels(('Ctrl','Block', 'Ctrl','Block', 'Ctrl','Block', 'Ctrl','Block'),rotation=45, size=10)\n", "ax.set_ylabel('Direction selectivity index', size=10)\n", "plt.ylim([-0.01,1])\n", "\n", "bbox_inches = 'tight'\n", "#plt.savefig('C:\\\\Users\\\\gammer\\\\Desktop\\\\DATA Surface\\\\LPi Opponency\\\\plots_LPi_ms\\\\\\\n", "#FigS7_Modelling_LDir.pdf',bbox_inches='tight', dpi=600, transparent=True)\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Make Scatter Plot of MOI\n", "\n", "pos = [0, 1, 3, 4, 6, 7, 9, 10]\n", "\n", "fig = plt.figure(figsize = (0.4*len(pos), 2.25))\n", "\n", "ax = fig.add_subplot(111)\n", "w = 0.6\n", "wb = 0.6\n", "data = [MOI_ctrl[0], MOI_block[0], MOI_ctrl[1], MOI_block[1], MOI_ctrl[2], MOI_block[2], MOI_ctrl[3], MOI_block[3]]\n", "\n", "colors = ['C2', 'C2', 'C1', 'C1', 'C0', 'C0', 'C3', 'C3']\n", "\n", "ax.axhline(y=0,xmin=0.0001,xmax=0.9999, color='0.05', linestyle=':', linewidth = 1)\n", "\n", "for j in range (len(data)):\n", " ax.plot([pos[j]-w/2, pos[j]+w/2],[(data[j]), (data[j])],\n", " color=colors[j], linestyle='-', linewidth = 4)\n", "\n", "ax.spines[\"top\"].set_visible(False)\n", "ax.spines[\"right\"].set_visible(False)\n", "ax.spines['left'].set_position(('outward', 7))\n", "ax.spines['bottom'].set_position(('outward', 7))\n", "ax.set_xticks(pos)\n", "ax.set_xticklabels(('Ctrl','Block', 'Ctrl','Block', 'Ctrl','Block', 'Ctrl','Block'),rotation=45, size=10)\n", "ax.set_ylabel('Motion opponency index', size=10)\n", "plt.ylim([-0.01,1])\n", "\n", "bbox_inches = 'tight'\n", "#plt.savefig('C:\\\\Users\\\\gammer\\\\Desktop\\\\DATA Surface\\\\LPi Opponency\\\\plots_LPi_ms\\\\\\\n", "#FigS7_Modelling_MOI.pdf',bbox_inches='tight', dpi=600, transparent=True)\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Make Scatter Plot of R_deg\n", "\n", "pos = [0, 1, 3, 4, 6, 7, 9, 10]\n", "\n", "fig = plt.figure(figsize = (0.4*len(pos), 2.25))\n", "\n", "ax = fig.add_subplot(111)\n", "w = 0.6\n", "wb = 0.6\n", "data = [R_deg_ctrl[0], R_deg_block[0], R_deg_ctrl[1], R_deg_block[1], R_deg_ctrl[2], R_deg_block[2], R_deg_ctrl[3], R_deg_block[3]]\n", "\n", "colors = ['C2', 'C2', 'C1', 'C1', 'C0', 'C0', 'C3', 'C3']\n", "\n", "ax.axhline(y=0,xmin=0.0001,xmax=0.9999, color='0.05', linestyle=':', linewidth = 1)\n", "\n", "for j in range (len(data)):\n", " ax.plot([pos[j]-w/2, pos[j]+w/2],[(data[j]), (data[j])],\n", " color=colors[j], linestyle='-', linewidth = 4)\n", "\n", "ax.spines[\"top\"].set_visible(False)\n", "ax.spines[\"right\"].set_visible(False)\n", "ax.spines['left'].set_position(('outward', 7))\n", "ax.spines['bottom'].set_position(('outward', 7))\n", "ax.set_xticks(pos)\n", "ax.set_xticklabels(('Ctrl','Block', 'Ctrl','Block', 'Ctrl','Block', 'Ctrl','Block'),rotation=45, size=10)\n", "rotations = [0,45,90,135,180,225,270,315,360]\n", "ax.set_yticks((rotations[::2]))\n", "ax.set_yticklabels(rotations[::2])\n", "ax.set_ylabel(u'Preferred direction [°]', size=10)\n", "plt.ylim([-0.01,360])\n", "\n", "bbox_inches = 'tight'\n", "#plt.savefig('C:\\\\Users\\\\gammer\\\\Desktop\\\\DATA Surface\\\\LPi Opponency\\\\plots_LPi_ms\\\\\\\n", "#FigS7_Modelling_R_deg.pdf',bbox_inches='tight', dpi=600, transparent=True)\n", "\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.15" } }, "nbformat": 4, "nbformat_minor": 5 }