RunMe_Both.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "from A_Functions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2Hz_plasticity\n",
      "no\n",
      "Noise input is of type double sine\n"
     ]
    }
   ],
   "source": [
    "# Create Noise Type\n",
    "# Give a name for your noise - be precise to make it easy to detect what type it is\n",
    "\n",
    "freq = 2\n",
    "simulation = 1\n",
    "\n",
    "simtype = ['initial', 'plasticity','adapted']\n",
    "namenoise = str(freq)+'Hz_'+simtype[simulation]\n",
    "print(namenoise)\n",
    "## input of NoiseGenerator for double sine is :\n",
    "# (amount of noise sources, 'DS', [offset sine1,offset sine2,amplitude sine1 (nA), frequency sine1(Hz),,\n",
    "#amplitude sine2, frequency sine2], duration in ms, name of the file)\n",
    "\n",
    "## input of NoiseGenerator for OU is :\n",
    "# (amount of noise sources, 'OU', [initial I, initial I0, sigma], duration in ms, name of the file)\n",
    "\n",
    "## input of NoiseGenerator Constant value :\n",
    "# (amount, 'const',[constant value in nA], duration in ms, name of the file)\n",
    "\n",
    "Noise_t,Noise_I,N_Noise=NoiseGenerator(2,'DS',[0.2,0.2    # offset in nA\n",
    "                                               ,0.2,0.2 # amplitude in nA\n",
    "                                               ,freq,freq   # frequency in Hz\n",
    "                                              ],5000,15000,20000,\n",
    "                                       namenoise,'no',simtype[simulation],freq)\n",
    "#Noise_t,Noise_I,N_Noise=NoiseGenerator(5,'DS',[1 ,0.5, 0, -0.5, -1,     #offsets in nA\n",
    "#                                              1, 0.5, 0, 0.5, 1, #amplitude in nA\n",
    "#                                              20, 2, 2, 20, 2]         # frequency in Hz\n",
    "#                                              ,2500,namenoise,simparameter)\n",
    "\n",
    "#Noise_const15 = NoiseGenerator(2,'const',[1.5],10,'Noise_const15')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'saving': 'yes', 'plotting': 'yes', 'dt': 25. * usecond, 'exp_runtime': array(20.), 'IO_response': 'both', 'N_Cells_PC': 10, 'N_Cells_DCN': 20, 'N_Cells_IO': 20}\n"
     ]
    }
   ],
   "source": [
    "SimParams = {}\n",
    "######################## Save\n",
    "SimParams['saving'] = 'yes' #'yes','no'\n",
    "######################## plot\n",
    "SimParams['plotting'] = 'yes' #'yes','no'\n",
    "######################## Experiment length\n",
    "SimParams['dt'] = 0.025*ms\n",
    "SimParams['exp_runtime'] = asarray(size(Noise_t)*SimParams['dt'])\n",
    "#print(type(SimParams['exp_runtime']*second))\n",
    "######################## Neuronal responses to run. \n",
    "SimParams['IO_response']='both' #'oscillatory', 'non', 'spiking', 'both' \n",
    "SimParams['N_Cells_PC'] = 10\n",
    "SimParams['N_Cells_DCN'] = 20\n",
    "SimParams['N_Cells_IO'] = 20\n",
    "name = namenoise+'SimParam.pickle'\n",
    "print(SimParams)\n",
    "######################## Saving SimParams\n",
    "with open(name, 'wb') as sims:\n",
    "    pickle.dump(SimParams,sims, pickle.HIGHEST_PROTOCOL)\n",
    "#sio.savemat('SimParams.mat', mdict={'SimParams': SimParams})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adaptation - Plasticity\n",
      "Take set parameters for cells\n",
      "Parameter of the cells are loaded\n",
      "<brian2.input.timedarray.TimedArray object at 0x00000182A9724BE0>\n",
      "nr of noise is 2\n",
      "initial weights <dummy_Coupled.weight: array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,\n",
      "       0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5])>\n"
     ]
    }
   ],
   "source": [
    "if namenoise.find('initial') != -1:\n",
    "    print('intial run - no Plasticity')\n",
    "    from E_Synapses_NoPlasticity import *\n",
    "elif namenoise.find('adapt') != -1:\n",
    "    print('adapted network - no Plasticity')\n",
    "    from E_Synapses_NoPlasticity import *\n",
    "elif namenoise.find('plasticity') != -1:\n",
    "    print('adaptation - Plasticity')\n",
    "    from E_New_Plasticity import *\n",
    "    \n",
    "else:\n",
    "    print('relook at name of namenoise')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting simulation at t=0. s for a duration of 20. s\n",
      "0.391375 s (1%) simulated in 10s, estimated 8m 21s remaining.\n",
      "0.77875 s (3%) simulated in 20s, estimated 8m 14s remaining.\n",
      "1.069025 s (5%) simulated in 30s, estimated 8m 52s remaining.\n",
      "1.234225 s (6%) simulated in 40s, estimated 10m 9s remaining.\n",
      "1.3986 s (6%) simulated in 50s, estimated 11m 5s remaining.\n",
      "1.562025 s (7%) simulated in 1m 0s, estimated 11m 49s remaining.\n",
      "1.728025 s (8%) simulated in 1m 10s, estimated 12m 21s remaining.\n",
      "1.892025 s (9%) simulated in 1m 20s, estimated 12m 47s remaining.\n",
      "2.056025 s (10%) simulated in 1m 30s, estimated 13m 7s remaining.\n",
      "2.2191 s (11%) simulated in 1m 40s, estimated 13m 22s remaining.\n",
      "2.382025 s (11%) simulated in 1m 50s, estimated 13m 35s remaining.\n",
      "2.546025 s (12%) simulated in 2m 0s, estimated 13m 44s remaining.\n",
      "2.7104 s (13%) simulated in 2m 10s, estimated 13m 50s remaining.\n",
      "2.873025 s (14%) simulated in 2m 20s, estimated 13m 56s remaining.\n",
      "3.036675 s (15%) simulated in 2m 30s, estimated 13m 59s remaining.\n",
      "3.1965 s (15%) simulated in 2m 40s, estimated 14m 2s remaining.\n",
      "3.357025 s (16%) simulated in 2m 50s, estimated 14m 4s remaining.\n",
      "3.5191 s (17%) simulated in 3m 0s, estimated 14m 4s remaining.\n",
      "3.682025 s (18%) simulated in 3m 10s, estimated 14m 3s remaining.\n",
      "3.844025 s (19%) simulated in 3m 20s, estimated 14m 2s remaining.\n",
      "4.0055 s (20%) simulated in 3m 30s, estimated 13m 59s remaining.\n",
      "4.166725 s (20%) simulated in 3m 40s, estimated 13m 57s remaining.\n",
      "4.329025 s (21%) simulated in 3m 50s, estimated 13m 53s remaining.\n",
      "4.490025 s (22%) simulated in 4m 0s, estimated 13m 50s remaining.\n",
      "4.651025 s (23%) simulated in 4m 10s, estimated 13m 46s remaining.\n",
      "4.813025 s (24%) simulated in 4m 20s, estimated 13m 41s remaining.\n",
      "4.972025 s (24%) simulated in 4m 30s, estimated 13m 37s remaining.\n",
      "5.133025 s (25%) simulated in 4m 40s, estimated 13m 32s remaining.\n",
      "5.294025 s (26%) simulated in 4m 50s, estimated 13m 27s remaining.\n",
      "5.454025 s (27%) simulated in 5m 0s, estimated 13m 21s remaining.\n",
      "5.616025 s (28%) simulated in 5m 10s, estimated 13m 15s remaining.\n",
      "5.776025 s (28%) simulated in 5m 20s, estimated 13m 9s remaining.\n",
      "5.936025 s (29%) simulated in 5m 30s, estimated 13m 3s remaining.\n",
      "6.097825 s (30%) simulated in 5m 40s, estimated 12m 56s remaining.\n",
      "6.25565 s (31%) simulated in 5m 50s, estimated 12m 50s remaining.\n",
      "6.414475 s (32%) simulated in 6m 0s, estimated 12m 43s remaining.\n",
      "6.572025 s (32%) simulated in 6m 10s, estimated 12m 37s remaining.\n",
      "6.730025 s (33%) simulated in 6m 20s, estimated 12m 30s remaining.\n",
      "6.888125 s (34%) simulated in 6m 30s, estimated 12m 23s remaining.\n",
      "7.045025 s (35%) simulated in 6m 40s, estimated 12m 16s remaining.\n",
      "7.202025 s (36%) simulated in 6m 50s, estimated 12m 9s remaining.\n",
      "7.35975 s (36%) simulated in 7m 0s, estimated 12m 2s remaining.\n",
      "7.510025 s (37%) simulated in 7m 10s, estimated 11m 56s remaining.\n",
      "7.666875 s (38%) simulated in 7m 20s, estimated 11m 49s remaining.\n",
      "7.815025 s (39%) simulated in 7m 30s, estimated 11m 42s remaining.\n",
      "7.971025 s (39%) simulated in 7m 40s, estimated 11m 35s remaining.\n",
      "8.11935 s (40%) simulated in 7m 50s, estimated 11m 28s remaining.\n",
      "8.261625 s (41%) simulated in 8m 0s, estimated 11m 23s remaining.\n",
      "8.396025 s (41%) simulated in 8m 10s, estimated 11m 18s remaining.\n",
      "8.529025 s (42%) simulated in 8m 20s, estimated 11m 13s remaining.\n",
      "8.666025 s (43%) simulated in 8m 30s, estimated 11m 8s remaining.\n",
      "8.816025 s (44%) simulated in 8m 40s, estimated 11m 0s remaining.\n",
      "8.956675 s (44%) simulated in 8m 50s, estimated 10m 54s remaining.\n",
      "9.095025 s (45%) simulated in 9m 0s, estimated 10m 48s remaining.\n",
      "9.242025 s (46%) simulated in 9m 10s, estimated 10m 41s remaining.\n",
      "9.3867 s (46%) simulated in 9m 20s, estimated 10m 34s remaining.\n",
      "9.534175 s (47%) simulated in 9m 30s, estimated 10m 26s remaining.\n",
      "9.683025 s (48%) simulated in 9m 40s, estimated 10m 19s remaining.\n",
      "9.831025 s (49%) simulated in 9m 50s, estimated 10m 11s remaining.\n",
      "9.98045 s (49%) simulated in 10m 0s, estimated 10m 3s remaining.\n",
      "10.125025 s (50%) simulated in 10m 10s, estimated 9m 56s remaining.\n",
      "10.270025 s (51%) simulated in 10m 20s, estimated 9m 48s remaining.\n",
      "10.415025 s (52%) simulated in 10m 30s, estimated 9m 40s remaining.\n",
      "10.560725 s (52%) simulated in 10m 40s, estimated 9m 33s remaining.\n",
      "10.707275 s (53%) simulated in 10m 50s, estimated 9m 25s remaining.\n",
      "10.853025 s (54%) simulated in 11m 0s, estimated 9m 17s remaining.\n",
      "11.000025 s (55%) simulated in 11m 10s, estimated 9m 9s remaining.\n",
      "11.145025 s (55%) simulated in 11m 20s, estimated 9m 1s remaining.\n",
      "11.291025 s (56%) simulated in 11m 30s, estimated 8m 53s remaining.\n",
      "11.433025 s (57%) simulated in 11m 40s, estimated 8m 45s remaining.\n",
      "11.581025 s (57%) simulated in 11m 50s, estimated 8m 37s remaining.\n",
      "11.722025 s (58%) simulated in 12m 0s, estimated 8m 29s remaining.\n",
      "11.846875 s (59%) simulated in 12m 10s, estimated 8m 23s remaining.\n",
      "11.981025 s (59%) simulated in 12m 20s, estimated 8m 16s remaining.\n",
      "12.119025 s (60%) simulated in 12m 30s, estimated 8m 8s remaining.\n",
      "12.258025 s (61%) simulated in 12m 40s, estimated 8m 1s remaining.\n",
      "12.3967 s (61%) simulated in 12m 50s, estimated 7m 53s remaining.\n",
      "12.5305 s (62%) simulated in 13m 0s, estimated 7m 45s remaining.\n",
      "12.663025 s (63%) simulated in 13m 10s, estimated 7m 38s remaining.\n",
      "12.801025 s (64%) simulated in 13m 20s, estimated 7m 30s remaining.\n",
      "12.930025 s (64%) simulated in 13m 30s, estimated 7m 23s remaining.\n",
      "13.056025 s (65%) simulated in 13m 40s, estimated 7m 17s remaining.\n",
      "13.180025 s (65%) simulated in 13m 51s, estimated 7m 10s remaining.\n",
      "13.3059 s (66%) simulated in 14m 1s, estimated 7m 3s remaining.\n",
      "13.435025 s (67%) simulated in 14m 11s, estimated 6m 56s remaining.\n",
      "13.574025 s (67%) simulated in 14m 21s, estimated 6m 48s remaining.\n",
      "13.723175 s (68%) simulated in 14m 31s, estimated 6m 38s remaining.\n",
      "13.872025 s (69%) simulated in 14m 41s, estimated 6m 29s remaining.\n",
      "14.01465 s (70%) simulated in 14m 51s, estimated 6m 21s remaining.\n",
      "14.155025 s (70%) simulated in 15m 1s, estimated 6m 12s remaining.\n",
      "14.279025 s (71%) simulated in 15m 11s, estimated 6m 5s remaining.\n",
      "14.416025 s (72%) simulated in 15m 21s, estimated 5m 57s remaining.\n",
      "14.553025 s (72%) simulated in 15m 31s, estimated 5m 49s remaining.\n",
      "14.690025 s (73%) simulated in 15m 41s, estimated 5m 40s remaining.\n",
      "14.827025 s (74%) simulated in 15m 51s, estimated 5m 32s remaining.\n",
      "14.9621 s (74%) simulated in 16m 1s, estimated 5m 24s remaining.\n",
      "15.098025 s (75%) simulated in 16m 11s, estimated 5m 15s remaining.\n",
      "15.227175 s (76%) simulated in 16m 21s, estimated 5m 8s remaining.\n",
      "15.352025 s (76%) simulated in 16m 31s, estimated 5m 0s remaining.\n",
      "15.490025 s (77%) simulated in 16m 41s, estimated 4m 52s remaining.\n",
      "15.62945 s (78%) simulated in 16m 51s, estimated 4m 43s remaining.\n",
      "15.770025 s (78%) simulated in 17m 1s, estimated 4m 34s remaining.\n",
      "15.915025 s (79%) simulated in 17m 11s, estimated 4m 25s remaining.\n",
      "16.058025 s (80%) simulated in 17m 21s, estimated 4m 16s remaining.\n",
      "16.200175 s (81%) simulated in 17m 31s, estimated 4m 7s remaining.\n",
      "16.344025 s (81%) simulated in 17m 41s, estimated 3m 57s remaining.\n",
      "16.485025 s (82%) simulated in 17m 51s, estimated 3m 48s remaining.\n",
      "16.627025 s (83%) simulated in 18m 1s, estimated 3m 39s remaining.\n",
      "16.769425 s (83%) simulated in 18m 11s, estimated 3m 30s remaining.\n",
      "16.911525 s (84%) simulated in 18m 21s, estimated 3m 21s remaining.\n",
      "17.0537 s (85%) simulated in 18m 31s, estimated 3m 12s remaining.\n",
      "17.195525 s (85%) simulated in 18m 41s, estimated 3m 3s remaining.\n",
      "17.336025 s (86%) simulated in 18m 51s, estimated 2m 54s remaining.\n",
      "17.478025 s (87%) simulated in 19m 1s, estimated 2m 45s remaining.\n",
      "17.619025 s (88%) simulated in 19m 11s, estimated 2m 36s remaining.\n",
      "17.76175 s (88%) simulated in 19m 21s, estimated 2m 26s remaining.\n",
      "17.90285 s (89%) simulated in 19m 31s, estimated 2m 17s remaining.\n",
      "18.043025 s (90%) simulated in 19m 41s, estimated 2m 8s remaining.\n",
      "18.184825 s (90%) simulated in 19m 51s, estimated 1m 59s remaining.\n",
      "18.325025 s (91%) simulated in 20m 1s, estimated 1m 50s remaining.\n",
      "18.4654 s (92%) simulated in 20m 11s, estimated 1m 41s remaining.\n",
      "18.605375 s (93%) simulated in 20m 21s, estimated 1m 32s remaining.\n",
      "18.745025 s (93%) simulated in 20m 31s, estimated 1m 22s remaining.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.885025 s (94%) simulated in 20m 41s, estimated 1m 13s remaining.\n",
      "19.026025 s (95%) simulated in 20m 51s, estimated 1m 4s remaining.\n",
      "19.165025 s (95%) simulated in 21m 1s, estimated 55s remaining.\n",
      "19.304025 s (96%) simulated in 21m 11s, estimated 46s remaining.\n",
      "19.444825 s (97%) simulated in 21m 21s, estimated 37s remaining.\n",
      "19.584675 s (97%) simulated in 21m 31s, estimated 27s remaining.\n",
      "19.724875 s (98%) simulated in 21m 41s, estimated 18s remaining.\n",
      "19.8598 s (99%) simulated in 21m 51s, estimated 9s remaining.\n",
      "19.991025 s (99%) simulated in 22m 1s, estimated 1s remaining.\n",
      "20. s (100%) simulated in 22m 2s\n"
     ]
    }
   ],
   "source": [
    "# run pt1\n",
    "run(exp_runtime,report='text')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = h5py.File(\"2Hz_deletabl.hdf5\",'a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "if namenoise.find('initial') != -1:\n",
    "    from F_save_data_NoPlasticity import *\n",
    "elif namenoise.find('adapt') != -1:\n",
    "    from F_save_data_NoPlasticity import *\n",
    "elif namenoise.find('plasticity') != -1:\n",
    "    from F_save_data_Plasticity import *\n",
    "else:\n",
    "    print('something is wrong but it should have appeared earlier, weird af')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#visualization check\n",
    "if namenoise.find('initial') != -1:\n",
    "    from G_Plot_NoPlasticity import *\n",
    "elif namenoise.find('adapt') != -1:\n",
    "    from G_Plot_NoPlasticity import *\n",
    "elif namenoise.find('plasticity') != -1:\n",
    "    from G_Plot_Plasticity import *\n",
    "else:\n",
    "    print('something is wrong but it should have appeared earlier, weird af')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<KeysViewHDF5 ['2Hz']>\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from F_save_data_Plasticity import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "#print(y)\n",
    "y_post = np.append(np.zeros(1000),np.ones(19000))\n",
    "print(y_post)\n",
    "print(mon_N_PC_Uncoupled.w_IO_uncoupled)\n",
    "x=np.linspace(0,len(y_post),len(y_post))\n",
    "print(x)\n",
    "plt.subplots(3,1)\n",
    "#plt.title('distribution uncoupled')\n",
    "\n",
    "for k in range(1,2):\n",
    "    x=mon_N_PC_Coupled.freq_dep_PC[k]\n",
    "    x2 = mon_N_PC_Coupled.freq_dep_IO[k]\n",
    "    ax= plt.subplot(211)\n",
    "    plt.plot(x)\n",
    "    plt.plot(x2)\n",
    "    plt.subplot(212,sharex=ax)\n",
    "    plt.plot(mon_N_PC_Coupled.f_lt_PC_coupled[k],color='red')\n",
    "\n",
    "    plt.plot(mon_N_PC_Coupled.f_st_PC_coupled[k],color='black')\n",
    "    #plt.ylim([100,120])\n",
    "    #plt.xlim([5000,10000])\n",
    "    \n",
    "    \n",
    "print(sum(mon_N_PC_Coupled.freq_dep_PC[0][5000:10000]))\n",
    "print(sum(mon_N_PC_Coupled.freq_dep_IO[0][5000:10000]))\n",
    "#plt.xlim([0,30000])    \n",
    "#plt.legend(['w io coupled', 'w pc coupled'])\n",
    "plt.show()\n",
    "print('mean x',np.nanmean(x))\n",
    "print('std x',np.nanstd(x))\n",
    "plt.figure()\n",
    "#plt.title('distribution uncoupled')\n",
    "for k in range(1,20):\n",
    "\n",
    "    plt.plot(mon_N_PC_Coupled.tau[k],color='green')\n",
    "    plt.plot(mon_N_PC_Uncoupled.tau[k],color='red')\n",
    "    \n",
    "    #plt.plot(mon_N_PC_Uncoupled.w_PC_uncoupled[k],color='blue')\n",
    "plt.legend(['w pc unc', 'w io unc'])\n",
    "plt.show()\n",
    "\n",
    "#plt.title('distribution uncoupled')\n",
    "plt.figure()\n",
    "for k in range(0,20):\n",
    "    #plt.plot(mon_N_PC_Uncoupled.f_lt_PC_uncoupled[k],color='red')\n",
    "    #plt.plot(mon_N_PC_Uncoupled.f_st_PC_uncoupled[k],color='black')\n",
    "    #plt.plot(mon_N_PC_Coupled.freq_dep[k],color='red')\n",
    "    #plt.plot(mon_N_PC_Coupled.weight_IO[k],color='black')\n",
    "    #plt.plot(mon_N_PC_Coupled.weight_PC[k],color='red')\n",
    "    plt.plot(mon_N_PC_Uncoupled.max_LTD_IO_uncoupled[k],color='red')\n",
    "\n",
    "    plt.plot(mon_N_PC_Coupled.max_LTD_IO_coupled[k],color='green')\n",
    "\n",
    "#plt.legend(['long term', 'short term'])\n",
    "plt.figure()\n",
    "plt.plot(mon_N_PC_Coupled.weight_IO[k],color='black')\n",
    "plt.plot(mon_N_PC_Coupled.weight_PC[k],color='red')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "#plt.title('distribution uncoupled')\n",
    "for k in range(0,10):\n",
    "    plt.plot(mon_N_PC_Uncoupled.f_lt_PC_uncoupled[k],color='red')\n",
    "    plt.plot(mon_N_PC_Coupled.f_lt_PC_coupled[k],color='black')\n",
    "plt.xlabel('time [ms]')\n",
    "plt.ylabel('frequency [Hz]')\n",
    "plt.show()\n",
    "plt.figure()\n",
    "#plt.title('distribution uncoupled')\n",
    "for k in range(0,10):\n",
    "    plt.plot(mon_N_PC_Uncoupled.mean_freq_IO_uncoupled[k],color='red')\n",
    "    plt.plot(mon_N_PC_Coupled.mean_freq_IO_coupled[k],color='black')\n",
    "plt.xlabel('time [ms]')\n",
    "plt.ylabel('frequency [Hz]')\n",
    "plt.show()\n",
    "plt.figure()\n",
    "#plt.title('distribution uncoupled')\n",
    "for k in range(0,10):\n",
    "    plt.plot(mon_N_PC_Uncoupled.max_LTD_IO_uncoupled[k],color='red')\n",
    "    plt.plot(mon_N_PC_Coupled.max_LTD_IO_coupled[k],color='black')\n",
    "plt.xlabel('time [ms]')\n",
    "plt.ylabel('frequency [Hz]')\n",
    "plt.show()\n",
    "plt.figure()\n",
    "plt.title('PC moving average')\n",
    "for k in range(0,1):\n",
    "    plt.plot(mon_N_PC_Coupled.y[k],color='red')\n",
    "    #plt.plot(mon_N_PC_Coupled.f_st_PC[k],color='black')\n",
    "plt.xlabel('time [ms]')\n",
    "plt.ylabel('frequency [Hz]')\n",
    "plt.show()\n",
    "plt.figure()\n",
    "plt.title('IO moving average')\n",
    "for p in range(0,n_IO):\n",
    "    plt.plot(mon_N_PC_Coupled.f_lt_IO[p],color='red')\n",
    "    plt.plot(mon_N_PC_Coupled.f_st_IO[p], color='black')\n",
    "plt.legend(['long term','short term'])\n",
    "plt.xlabel('time [ms]')\n",
    "plt.ylabel('frequency [Hz]')\n",
    "\n",
    "plt.figure()\n",
    "plt.title('Difference in moving average IO (short term - long term)')\n",
    "#for p in range(0,n_IO):\n",
    "#    difio=mon_N_PC_Coupled.f_st_IO[p]-mon_N_PC_Coupled.f_lt_IO[p]\n",
    "#    idxio = (difio>0).astype(float)\n",
    "#    procentage_LTD = sum(idxio)/1000\n",
    "#    print('depression %',procentage_LTD)\n",
    "#    plt.plot(mon_N_PC_Coupled.f_st_IO[p]-mon_N_PC_Coupled.f_lt_IO[p])\n",
    "#plt.figure()\n",
    "for p in range(0,10):\n",
    "    difio=mon_N_PC_Coupled.f_st_IO[p]-mon_N_PC_Coupled.f_lt_IO[p]\n",
    "\n",
    "    dif=mon_N_PC_Coupled.f_st_PC[p]-mon_N_PC_Coupled.f_lt_PC[p]\n",
    "    idx = (dif>0).astype(float)\n",
    "    #plt.plot(idx)\n",
    "    #plt.ylim([0,1.1])\n",
    "    procentage_LTP = sum(idx)/1000\n",
    "    plt.plot(dif)\n",
    "    plt.plot(difio)\n",
    "    print('potentiated %',procentage_LTP)\n",
    "print(mon_N_PC_Coupled.f_lt_IO.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.floor(-0.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "neuron = 0\n",
    "ex = 2000\n",
    "wpc = mon_N_PC_Coupled.weight_PC[neuron]\n",
    "wio = mon_N_PC_Coupled.weight_IO[neuron]\n",
    "maxDelay = 100\n",
    "gr = (1-1/(1+exp(-ex*(wpc+np.abs(wio)-0.3*0.5))))\n",
    "prop= (np.abs(wio)/(np.abs(wio)+wpc))\n",
    "prop2=(np.abs(wpc)/(np.abs(wio)+wpc))\n",
    "tauIO = maxDelay*(np.abs(wio)/(np.abs(wio)+wpc))*gr\n",
    "tauPC = maxDelay*(np.abs(wpc)/(np.abs(wio)+wpc))*gr\n",
    "\n",
    "fig, axs = plt.subplots(4,1, figsize=(10,20))\n",
    "\n",
    "ax1 = plt.subplot(4,1,1)\n",
    "plt.plot(tauPC)\n",
    "plt.plot(tauIO)\n",
    "\n",
    "ax2 = plt.subplot(4,1,2)\n",
    "plt.plot(wpc)\n",
    "plt.plot(wio)\n",
    "\n",
    "ax3 = plt.subplot(4,1,3)\n",
    "plt.plot(prop2)\n",
    "plt.plot(prop)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= np.linspace(0,20,10000)\n",
    "sin1 = np.sin(x)\n",
    "sin2 = np.sin(x*3)\n",
    "neu = [2.5,5,14,18]\n",
    "yPC = np.ones(len(neu))\n",
    "\n",
    "f, a =plt.subplots(2,1, figsize=(20,15))\n",
    "ax=plt.subplot(211)\n",
    "plt.plot(x,sin1,linewidth=4)\n",
    "for k in neu:\n",
    "    plt.axvline(x=k,color='r',linestyle='--')\n",
    "plt.ylabel('Input current [nA]')\n",
    "plt.subplot(212,sharex=ax)\n",
    "plt.scatter(x=neu,y=yPC,marker='|', color='black',s=1000)\n",
    "plt.xlabel('time [s]')\n",
    "#plt.xlim([0,20])\n",
    "plt.show()\n",
    "plt.figure()\n",
    "plt.plot(x,sin2,linewidth=3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}