Flex_Pub.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import scipy.io\n",
    "import scipy.stats as ss\n",
    "import os\n",
    "import matplotlib.collections as collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_parser_pearson_module_affilitor(PyMatrix,NumOfModules,IdOfSub,TBD,OP,SavingAddress,ModulHyp):\n",
    "    \"\"\"\n",
    "    This function will receive the signal matrix and divide it to asked TBD-point windows, calculating Pearson Matrix.\n",
    "    \n",
    "    Inputs:\n",
    "    PyMatrix = A matrix of brain activity with columns as ROI and rows as time points.\n",
    "    NumOfModules = Number of Modules\n",
    "    TBD = TimeBlocksDuration, for example 20 means there are 20 time points in each block to calculate the pearson coeff of\n",
    "    OP = OverlapPercentage, for example 0.25 means each 2 TimeBlock will have 25% of overlap\n",
    "    SavingAddress = Where to save the output (the folder)\n",
    "    ModulHyp = The optional prior module assignment we had\n",
    "    \n",
    "    Output:\n",
    "    The function creats folders in your desired address named IdOfSub (string) each containing numpy matrices named\n",
    "    SampleXFromTimeY_to_Z.npy, where X is the subject num, Y is the starting time point and Z is the last time point (for the\n",
    "    calculation of Pearson coeff)\n",
    "    The nupmy matrix is a matrix with the rows as module affiliation ratio (sums to 1 if all positive) and columns as nodes\n",
    "    \"\"\"\n",
    "    ######################################\n",
    "    ModSize = np.zeros((NumOfModules,1))\n",
    "    for i in range(1,NumOfModules+1):\n",
    "        ModSize[i-1,0]  = np.count_nonzero(ModulHyp == i)\n",
    "    \n",
    "    ######################################\n",
    "    w, h = np.shape(PyMatrix)[1], np.shape(PyMatrix)[1];\n",
    "    print(w,h)\n",
    "    DataLength = np.shape(PyMatrix)[0]\n",
    "    #Length of the data (time dimension)\n",
    "    BlockNum = int((DataLength - int(OP*TBD)) / (TBD - int(OP*TBD))) -1\n",
    "    #To calculate how many TimeBlocks will exist in out data considering the overlap\n",
    "    for timeblock in range(0,BlockNum):\n",
    "        ParsedPearsonMatrix = np.zeros((w,h))\n",
    "        for i in range(0,w):\n",
    "            for j in range(0,h):\n",
    "                ParsedPearsonMatrix[i][j] = ss.pearsonr(PyMatrix[timeblock*TBD - timeblock*(int(OP*TBD)):(timeblock+1)*TBD - timeblock*(int(OP*TBD)),i],PyMatrix[timeblock*TBD - timeblock*(int(OP*TBD)):(timeblock+1)*TBD - timeblock*(int(OP*TBD)),j])[0]\n",
    "        \n",
    "        #Now we have a parsed pearson matrix which is needed to be observed as a picture of the system at that time.\n",
    "        for i in range (0,w):\n",
    "            ParsedPearsonMatrix[i][i] = 0\n",
    "        ModulCoeff = np.zeros((NumOfModules,np.shape(PyMatrix)[1]))\n",
    "        for i in range(0,w):\n",
    "            for j in range(0,h):\n",
    "                k = int(ModulHyp[j][0]-1)\n",
    "                ModulCoeff[k][i] = ModulCoeff[k][i]+((ParsedPearsonMatrix[i][j])**2)**(1./2)\n",
    "        \n",
    "        ModulCoeff2 = np.zeros((np.shape(ModulCoeff)[0],np.shape(ModulCoeff)[1]))\n",
    "        ModulCoeff2  = ModulCoeff\n",
    "        ModulCoeff2 = ModulCoeff2/ModSize\n",
    "        \n",
    "        sums = ModulCoeff.sum(axis=0,keepdims=1); \n",
    "        sums[sums==0] = 1\n",
    "        #This is to avoid dividing by zero\n",
    "        \n",
    "        #Cause we have negative numbers and we want to have something between 0 to 1 after division we divide by the positive value (^2^1/2):\n",
    "        sums2 = ModulCoeff2.sum(axis=0,keepdims=1); \n",
    "        sums2[sums2==0] = 1\n",
    "        \n",
    "        \n",
    "        ModulCoeff = ModulCoeff/sums\n",
    "        ModulCoeff2 = ModulCoeff2/sums2\n",
    "        #Now we have a matrix with the rows as module affiliation ratio (sums to 1 if all positive) and columns as nodes.\n",
    "        \n",
    "        \n",
    "        if not os.path.isdir(SavingAddress+'/%s/'%(IdOfSub)):\n",
    "            os.mkdir(SavingAddress +'/%s/'%(IdOfSub))\n",
    "        initial = timeblock*TBD - timeblock*(int(OP*TBD))\n",
    "        final = (timeblock+1)*TBD - timeblock*(int(OP*TBD))\n",
    "        if not os.path.isdir(SavingAddress+'/%s/Normalized'%(IdOfSub)):\n",
    "            os.mkdir(SavingAddress +'/%s/Normalized'%(IdOfSub))\n",
    "        np.save(SavingAddress + '/%s/Subject_%s_FromTime%d_to_%d.npy'%(IdOfSub,IdOfSub,initial,final),ModulCoeff)\n",
    "        np.save(SavingAddress + '/%s/Normalized/Normalized_Subject_%s_FromTime%d_to_%d.npy'%(IdOfSub,IdOfSub,initial,final),ModulCoeff2)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mat_to_numpy_converter(address,TableName):\n",
    "    \"\"\"\n",
    "    Converts the .mat Matlab matrices to numpy arrays\n",
    "    \"\"\"\n",
    "    \n",
    "    inputMatrix = scipy.io.loadmat(address)\n",
    "    PyMatrix = np.array(inputMatrix[TableName])\n",
    "    #print(np.shape(PyMatrix))\n",
    "    return PyMatrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModulHypAdd = 'Needed_Address.mat'\n",
    "TableName = 'a'\n",
    "ModulHyp = mat_to_numpy_converter(ModulHypAdd,'a')\n",
    "NumOfModules = len(np.unique(ModulHyp))\n",
    "SavingAddress = \"Needed_Address'\n",
    "#time_parser_pearson_module_affilitor(ts,15,'PSY00029',15,0.95,SavingAddress,ModulHyp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for sub in ids:\n",
    "    timeseriesadd = \"Needed_Address%s.npy\"%sub\n",
    "    ts = np.load(timeseriesadd)\n",
    "    SavingAddress = \"Needed_Address/%s/\"%sub\n",
    "    time_parser_pearson_module_affilitor(ts,15,sub,15,0.95,SavingAddress,ModulHyp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SavingAddress =\"Needed_Address\"\n",
    "address= 'Needed_Address/15Affiliation.mat'\n",
    "TableName= 'a'\n",
    "TBD= 15\n",
    "OP= 0.95\n",
    "DataLength= 128\n",
    "NumOfModules= 15\n",
    "NumOfSubs= len(ids)\n",
    "NumofBrainRegions= 246\n",
    "SubjectSelection= True\n",
    "SubjectIds = ids\n",
    " \n",
    "\n",
    "\n",
    "NumOfGroupSubs = len(ids)\n",
    "    \n",
    "BlockNum = int((DataLength - int(OP*TBD)) / (TBD - int(OP*TBD))) -1\n",
    "    \n",
    "#Plot Info:\n",
    "NumOfPlotsColumns = 5\n",
    "NumOfPlotsRows = (NumOfSubs//5) +1\n",
    "\n",
    "#Average over population measures:\n",
    "AveMat = np.zeros((NumOfModules,BlockNum))\n",
    "#NumOfChangedROIs is the NumOfSubs*BlockNum-1 matrix which contains the number of nodes that change their \n",
    "#affiliation in each time step. A row for each subject.\n",
    "NumOfChangedROIs = np.zeros((NumOfSubs,BlockNum-1))\n",
    "NumOfPriorChangedROIs = np.zeros((NumOfSubs,BlockNum-1))\n",
    "    \n",
    "    \n",
    "inputMatrix = scipy.io.loadmat(address)\n",
    "PriorAffil = np.array(inputMatrix[TableName])\n",
    "PriorAffil = np.transpose(PriorAffil)\n",
    "if SubjectSelection == True :\n",
    "    SubRange = SubjectIds\n",
    "else:\n",
    "    SubRange = np.arange(1,NumOfSubs+1)\n",
    "    \n",
    "NumOfSubs = len(SubRange)\n",
    "    \n",
    "    \n",
    "for subject in SubRange:\n",
    "    print(subject)\n",
    "    print(SubRange.index(subject))\n",
    "    MatTot = np.zeros((1,NumofBrainRegions))\n",
    "    NumofSampInt = subject\n",
    "    WinningModuleTot = np.zeros((1,NumofBrainRegions))\n",
    "    for timeblock in range(0,BlockNum): \n",
    "        initial = timeblock*TBD - timeblock*(int(OP*TBD))\n",
    "        final = (timeblock+1)*TBD - timeblock*(int(OP*TBD))\n",
    "        Mat = np.load(SavingAddress +'/%s/%s/Subject_%s_FromTime%d_to_%d.npy'%(NumofSampInt,NumofSampInt,NumofSampInt,initial,final))\n",
    "        WinningModuleinT = np.zeros((1,NumofBrainRegions))\n",
    "        for i in range(0,NumofBrainRegions):\n",
    "            WinningModuleinT[0,i] = np.argmax(Mat[:,i])   \n",
    "        MatTot = np.concatenate((MatTot,Mat), axis=0)\n",
    "        WinningModuleTot = np.concatenate((WinningModuleTot,WinningModuleinT), axis=0)\n",
    "\n",
    "    #WinningModuleTot is a BlockNum*ROINum matrix which shows the the affiliation of all ROIs to the winning modules in\n",
    "    #time window (BlockNum)\n",
    "    #This MatTot is the concatenated matrix for all nodes of a single subject for all time windows\n",
    "    MatTot = np.delete(MatTot, (0), axis=0)\n",
    "    #print(np.shape(MatTot))\n",
    "    WinningModuleTot = np.delete(WinningModuleTot, (0), axis=0)\n",
    "\n",
    "    WinningModuleTot = WinningModuleTot + 1\n",
    "        \n",
    "    ##################################################\n",
    "    #Now That we have WinningModuleTot which is showing us the affiliations over time for each node, we want\n",
    "    #to track how many of the nodes are changing their affiliation in each step: NumOfChangedROIs = np.zeros(NumOfSubs,BlockNum-1)\n",
    "    for ii in range(0,BlockNum-1):\n",
    "        Dif = 0\n",
    "        for jj in range (0, NumofBrainRegions):\n",
    "            if (WinningModuleTot[ii,jj]) != (WinningModuleTot[ii+1,jj]):\n",
    "                Dif = Dif+1\n",
    "        NumOfChangedROIs[SubRange.index(subject),ii] = Dif    \n",
    "        ##################################################\n",
    "    #This is another way of change-calc, were we compare them with the default one at each step.\n",
    "    #(and not with the previous step)\n",
    "    for ii in range(0,BlockNum-1):\n",
    "        Dif = 0\n",
    "        for jj in range (0, NumofBrainRegions):\n",
    "            if (WinningModuleTot[ii,jj]) != (PriorAffil[0,jj]):\n",
    "                Dif = Dif+1\n",
    "        NumOfPriorChangedROIs[SubRange.index(subject),ii] = Dif\n",
    "        #################################################\n",
    "    ModulDistr = np.zeros((NumOfModules,BlockNum))\n",
    "    #ModulDistr is a 9*13 (NumofModules*Time) matrix where each element (i,j) shows the number of nodes in the i-th module at time j.\n",
    "    for i in range (0,NumOfModules):\n",
    "        for j in range (0,BlockNum):\n",
    "            ModulDistr[i,j] = np.count_nonzero(WinningModuleTot[j,:]==i+1)\n",
    "\n",
    "    AveMat = np.add(AveMat, ModulDistr)\n",
    "\n",
    "    x = list(range(1,BlockNum+1))\n",
    "\n",
    "    labels = []\n",
    "    for mol in range(1,NumOfModules+1):\n",
    "        labels.append(\"Module {0}\".format(mol+1))\n",
    "        \n",
    "    np.save(SavingAddress + '/%s/%s/ModuleDistrbOfSubject_%s.npy'%(NumofSampInt,NumofSampInt,NumofSampInt),ModulDistr)\n",
    "        #ax[(subject-1)//NumOfPlotsColumns,(subject-1)%NumOfPlotsColumns].stackplot(x, ModulDistr,labels=labels)\n",
    "        \n",
    "    #plt.show()\n",
    "AveMat = AveMat/NumOfSubs\n",
    "print(np.shape(AveMat))\n",
    "print(AveMat)\n",
    "\n",
    "x = list(range(1,BlockNum+1))\n",
    "    #####################################\n",
    "    #Changing population calculation:\n",
    "    #print(AveMat)\n",
    "AffilChange = np.zeros((1,BlockNum-1))\n",
    "    #AffilChange is a row vector showing the total number of changing agents per time steps.\n",
    "for j in range(0,BlockNum-1):\n",
    "        #for i in range (0,NumOfModules):\n",
    "    AffilChange[0,j] = (1/2) * sum(abs(AveMat[:,j] - AveMat[:,j+1]))\n",
    "    \n",
    "xdata = np.arange(1,BlockNum)\n",
    "    #print(AffilChange)\n",
    "fig, ax = plt.subplots()\n",
    "plt.plot(xdata,np.transpose(AffilChange))\n",
    "plt.title('Population of affiliation change per time step')\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "    \n",
    "    \n",
    "#####################################\n",
    "#NumOfChangedROIs average plotting:\n",
    "    \n",
    "AffilChangeSum = NumOfChangedROIs.sum(axis=0)\n",
    "AffilChangeSum = AffilChangeSum/NumOfSubs\n",
    "    \n",
    "xdata = np.arange(3,BlockNum-3)\n",
    "#print(AffilChangeSum)\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "plt.plot(xdata,np.transpose(AffilChangeSum[3:BlockNum-3]))\n",
    "plt.title('change in modular affiliation of regions from each time point to the next averaged across subjects')\n",
    "plt.xlabel('windows')\n",
    "#plt.plot(xdata,np.transpose(NumOfChangedROIs[5,:]))\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "    \n",
    "    \n",
    "######################################\n",
    "#Prior Affilchange plotting\n",
    "PriorAffilChangeSum = NumOfPriorChangedROIs.sum(axis=0)\n",
    "PriorAffilChangeSum = PriorAffilChangeSum/NumOfSubs\n",
    "    \n",
    "xdata = np.arange(1,BlockNum)\n",
    "#print(AffilChangeSum)\n",
    "fig, ax = plt.subplots()\n",
    "plt.plot(xdata,np.transpose(PriorAffilChangeSum))\n",
    "plt.title('Changing the Affiliation compared to the prior one averaged over subjects')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "\n",
    "    \n",
    "####################################\n",
    "labelsTot = []\n",
    "for mol in range(1,NumOfModules+1):\n",
    "    labelsTot.append(\"Module {0} average pop\".format(mol+1))\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.stackplot(x, AveMat,labels=labelsTot)\n",
    "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.5), ncol=3, fancybox=True, shadow=True)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject (Average)')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.xlabel('Time')\n",
    "plt.show()\n",
    "\n",
    "##################################\n",
    "labelsTot = [\"Module 1 average pop\",\"Module 4 average pop\",\"Module 14 average pop\"]\n",
    "y1 = AveMat[0,:]\n",
    "y2 = AveMat[1,:]\n",
    "y3 = AveMat[2,:]\n",
    "y4 = AveMat[3,:]\n",
    "y5 = AveMat[4,:]\n",
    "y6 = AveMat[5,:]\n",
    "y7 = AveMat[6,:]\n",
    "y8 = AveMat[7,:]\n",
    "y9 = AveMat[8,:]\n",
    "y10 = AveMat[9,:]\n",
    "y11 = AveMat[10,:]\n",
    "y12 = AveMat[11,:]\n",
    "y13 = AveMat[12,:]\n",
    "y14 = AveMat[13,:]\n",
    "y15 = AveMat[14,:]\n",
    "\n",
    "y = np.vstack([y1, y4, y14])\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y,labels=labelsTot)\n",
    "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.5), ncol=3, fancybox=True, shadow=True)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Modules BN_anterior_salience(1),BN_dDMN(4),BN_Visuospatial(14)')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "##############################################\n",
    "#All Modules of the 15 Module system ploted:\n",
    "##############################################\n",
    "#     fig, ax = plt.subplots(figsize=(20, 5))\n",
    "#     ax.stackplot(x, y1)\n",
    "#     plt.title('Changing the Population of Dependencies over Time for All Subject in Module One, BN_anterior_salience')\n",
    "#     plt.ylabel('Average Dependent Nodes Population')\n",
    "#     plt.xlabel('Time')\n",
    "#     plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "#     plt.show()\n",
    "############################\n",
    "###########################\n",
    "#     fig, ax = plt.subplots(figsize=(20, 5))\n",
    "#     ax.stackplot(x, y3)\n",
    "#     plt.title('Changing the Population of Dependencies over Time for All Subject in Module Three, BN_Basal_Ganglia')\n",
    "#     plt.ylabel('Average Dependent Nodes Population')\n",
    "#     plt.xlabel('Time')\n",
    "#     plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "#     plt.show()\n",
    "############################\n",
    "###########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y4)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Four, BN_dDMN')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "############################\n",
    "###########################\n",
    "#     fig, ax = plt.subplots(figsize=(20, 5))\n",
    "#     ax.stackplot(x, y5)\n",
    "#     plt.title('Changing the Population of Dependencies over Time for All Subject in Module Five, BN_high_Visual')\n",
    "#     plt.ylabel('Average Dependent Nodes Population')\n",
    "#     plt.xlabel('Time')\n",
    "#     plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "#     plt.show()\n",
    "############################\n",
    "###########################\n",
    "#     fig, ax = plt.subplots(figsize=(20, 5))\n",
    "#     ax.stackplot(x, y12)\n",
    "#     plt.title('Changing the Population of Dependencies over Time for All Subject in Module Twelve, BN_Sensorimotor')\n",
    "#     plt.ylabel('Average Dependent Nodes Population')\n",
    "#     plt.xlabel('Time')\n",
    "#     plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "#     plt.show()\n",
    "############################\n",
    "###########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y13)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Thirteen, BN_vDMN')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "############################\n",
    "###########################\n",
    "#     fig, ax = plt.subplots(figsize=(20, 5))\n",
    "#     ax.stackplot(x, y14)\n",
    "#     plt.title('Changing the Population of Dependencies over Time for All Subject in Module Fourteen, BN_Visuospatial')\n",
    "#     plt.ylabel('Average Dependent Nodes Population')\n",
    "#     plt.xlabel('Time')\n",
    "#     plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "#     plt.show()\n",
    "############################\n",
    "###########################\n",
    "\n",
    "#     fig, ax = plt.subplots(figsize=(20, 5))\n",
    "#     ax.stackplot(x, y15)\n",
    "#     plt.title('Changing the Population of Dependencies over Time for All Subject in Module Fifteen, UD')\n",
    "#     plt.ylabel('Average Dependent Nodes Population')\n",
    "#     plt.xlabel('Time')\n",
    "#     plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "#     plt.show()\n",
    "############################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Average Plotter\n",
    "#ModulHyp is the pre-specified modules we have intruduced   \n",
    "ModulHypAdd = 'Needed_Address/15Affiliation.mat'\n",
    "TableName = 'a'\n",
    "ModulHyp = mat_to_numpy_converter(ModulHypAdd,'a')\n",
    "NumOfModules = len(np.unique(ModulHyp))\n",
    "TBD = 15\n",
    "OP = 0.95\n",
    "DataLength = 128\n",
    "\n",
    "SavingAddress =\"Needed_Address\"\n",
    "NumOfGroupSubs = len(ids) - 100\n",
    "# all_subjects_average_plotter(SavingAddress,ModulHypAdd,TableName,TBD,OP,DataLength,\n",
    "#                                    NumOfModules,NumOfGroupSubs,246,\n",
    "#                                    SubjectSelection = True,SubjectIds=ids)\n",
    "#Jess.all_subjects_average_plotter(SavingAddress,address,TableName,15,0.95,128,15,176,246,True,SubjectIds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ids = ['subject_a','subject_b','subject_c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Non_Normalized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "###Variables######################\n",
    "SavingAddress =\"Needed_Address\"\n",
    "address= 'Needed_Address/15Affiliation.mat'\n",
    "TableName= 'a'\n",
    "TBD= 15\n",
    "OP= 0.95\n",
    "DataLength= 128\n",
    "NumOfModules= 15\n",
    "NumOfSubs= len(ids)\n",
    "NumofBrainRegions= 246\n",
    "SubjectSelection= True\n",
    "SubjectIds = ids\n",
    "NumOfGroupSubs = len(ids)\n",
    "###################################\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "BlockNum = int((DataLength - int(OP*TBD)) / (TBD - int(OP*TBD))) -1\n",
    "    \n",
    "#Plot Info:\n",
    "NumOfPlotsColumns = 5\n",
    "NumOfPlotsRows = (NumOfSubs//5) +1\n",
    "\n",
    "\n",
    "#Average over population measures:\n",
    "AveMat = np.zeros((NumOfModules,BlockNum))\n",
    "#NumOfChangedROIs is the NumOfSubs*BlockNum-1 matrix which contains the number of nodes that change their \n",
    "#affiliation in each time step. A row for each subject.\n",
    "NumOfChangedROIs = np.zeros((NumOfSubs,BlockNum-1))\n",
    "NumOfPriorChangedROIs = np.zeros((NumOfSubs,BlockNum-1))\n",
    "    \n",
    "    \n",
    "inputMatrix = scipy.io.loadmat(address)\n",
    "PriorAffil = np.array(inputMatrix[TableName])\n",
    "PriorAffil = np.transpose(PriorAffil)\n",
    "if SubjectSelection == True :\n",
    "    SubRange = SubjectIds\n",
    "else:\n",
    "    SubRange = np.arange(1,NumOfSubs+1)\n",
    "    \n",
    "NumOfSubs = len(SubRange)\n",
    "    \n",
    "    \n",
    "for subject in SubRange:\n",
    "    MatTot = np.zeros((1,NumofBrainRegions))\n",
    "    NumofSampInt = subject\n",
    "    WinningModuleTot = np.zeros((1,NumofBrainRegions))\n",
    "    for timeblock in range(0,BlockNum): \n",
    "        initial = timeblock*TBD - timeblock*(int(OP*TBD))\n",
    "        final = (timeblock+1)*TBD - timeblock*(int(OP*TBD))\n",
    "        Mat = np.load(SavingAddress +'/%s/%s/Subject_%s_FromTime%d_to_%d.npy'%(NumofSampInt,NumofSampInt,NumofSampInt,initial,final))\n",
    "        WinningModuleinT = np.zeros((1,NumofBrainRegions))\n",
    "        for i in range(0,NumofBrainRegions):\n",
    "            WinningModuleinT[0,i] = np.argmax(Mat[:,i])   \n",
    "        MatTot = np.concatenate((MatTot,Mat), axis=0)\n",
    "        WinningModuleTot = np.concatenate((WinningModuleTot,WinningModuleinT), axis=0)\n",
    "\n",
    "    #WinningModuleTot is a BlockNum*ROINum matrix which shows the the affiliation of all ROIs to the winning modules in\n",
    "    #time window (BlockNum)\n",
    "    #This MatTot is the concatenated matrix for all nodes of a single subject for all time windows\n",
    "    MatTot = np.delete(MatTot, (0), axis=0)\n",
    "    #print(np.shape(MatTot))\n",
    "    WinningModuleTot = np.delete(WinningModuleTot, (0), axis=0)\n",
    "\n",
    "    WinningModuleTot = WinningModuleTot + 1\n",
    " \n",
    "    ##################################################\n",
    "    #Now That we have WinningModuleTot which is showing us the affiliations over time for each node, we want\n",
    "    #to track how many of the nodes are changing their affiliation in each step: NumOfChangedROIs = np.zeros(NumOfSubs,BlockNum-1)\n",
    "    for ii in range(0,BlockNum-1):\n",
    "        Dif = 0\n",
    "        for jj in range (0, NumofBrainRegions):\n",
    "            if (WinningModuleTot[ii,jj]) != (WinningModuleTot[ii+1,jj]):\n",
    "                Dif = Dif+1\n",
    "        NumOfChangedROIs[SubRange.index(subject),ii] = Dif    \n",
    "        ##################################################\n",
    "    #This is another way of change-calc, were I compare them with the default one at each step.\n",
    "    #(and not with the previous step)\n",
    "    for ii in range(0,BlockNum-1):\n",
    "        Dif = 0\n",
    "        for jj in range (0, NumofBrainRegions):\n",
    "            if (WinningModuleTot[ii,jj]) != (PriorAffil[0,jj]):\n",
    "                Dif = Dif+1\n",
    "        NumOfPriorChangedROIs[SubRange.index(subject),ii] = Dif\n",
    "        #################################################\n",
    "    ModulDistr = np.zeros((NumOfModules,BlockNum))\n",
    "    #print(np.shape(ModulDistr))\n",
    "    #ModulDistr is a 9*13 (NumofModules*Time) matrix where each element (i,j) shows the number of nodes in the i-th module at time j.\n",
    "    for i in range (0,NumOfModules):\n",
    "        for j in range (0,BlockNum):\n",
    "            ModulDistr[i,j] = np.count_nonzero(WinningModuleTot[j,:]==i+1)\n",
    "\n",
    "    AveMat = np.add(AveMat, ModulDistr)\n",
    "\n",
    "    #print(ModulDistr)\n",
    "    x = list(range(1,BlockNum+1))\n",
    "\n",
    "    labels = []\n",
    "    for mol in range(1,NumOfModules+1):\n",
    "        labels.append(\"Module {0}\".format(mol+1))\n",
    "        \n",
    "    np.save(SavingAddress + '/%s/%s/ModuleDistrbOfSubject_%s.npy'%(NumofSampInt,NumofSampInt,NumofSampInt),ModulDistr)\n",
    "        #ax[(subject-1)//NumOfPlotsColumns,(subject-1)%NumOfPlotsColumns].stackplot(x, ModulDistr,labels=labels)\n",
    "        \n",
    "    #plt.show()\n",
    "AveMat = AveMat/NumOfSubs\n",
    "# print(np.shape(AveMat))\n",
    "# print(AveMat)\n",
    "\n",
    "x = list(range(1,BlockNum+1))\n",
    "    #####################################\n",
    "    #Changing population calculation:\n",
    "    #print(AveMat)\n",
    "AffilChange = np.zeros((1,BlockNum-1))\n",
    "    #AffilChange is a row vector showing the total number of changing agents per time steps.\n",
    "for j in range(0,BlockNum-1):\n",
    "        #for i in range (0,NumOfModules):\n",
    "    AffilChange[0,j] = (1/2) * sum(abs(AveMat[:,j] - AveMat[:,j+1]))\n",
    "    \n",
    "# xdata = np.arange(1,BlockNum)\n",
    "#     #print(AffilChange)\n",
    "# fig, ax = plt.subplots()\n",
    "# plt.plot(xdata,np.transpose(AffilChange))\n",
    "# plt.title('Population of affiliation change per time step')\n",
    "# plt.grid(True)\n",
    "# plt.show()\n",
    "    \n",
    "    \n",
    "    #####################################\n",
    "    #NumOfChangedROIs average plotting:\n",
    "    \n",
    "AffilChangeSum = NumOfChangedROIs.sum(axis=0)\n",
    "AffilChangeSum = AffilChangeSum/NumOfSubs\n",
    "    \n",
    "    \n",
    "\n",
    "xdata = np.arange(3,BlockNum-3)\n",
    "#print(AffilChangeSum)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "# collection = collections.BrokenBarHCollection.span_where(xdata, ymin=0, ymax=100, where= np.transpose(AffilChangeSum[3:BlockNum-3])> 0, facecolor='green', alpha=0.5)\n",
    "# ax.add_collection(collection)\n",
    "\n",
    "\n",
    "\n",
    "plt.plot(xdata,np.transpose(AffilChangeSum[3:BlockNum-3])/246)\n",
    "plt.title('change in modular affiliation of regions from each time point to the next averaged across subjects')\n",
    "plt.xlabel('windows')\n",
    "plt.ylabel('Flexibility')\n",
    "#plt.plot(xdata,np.transpose(NumOfChangedROIs[5,:]))\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "\n",
    "for i in range (0,15):\n",
    "    plt.axvline(7.6*(i+1), linestyle='dashed',color='grey')\n",
    "    if i%4==0:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFD0E6', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min((AffilChangeSum[3:BlockNum-3])/246), \"0back\", fontdict=None)\n",
    "    if i%4==1:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "    if i%4==2:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFE6CA', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min((AffilChangeSum[3:BlockNum-3])/246), \"2back\", fontdict=None)\n",
    "    if i%4==3:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "\n",
    "plt.show()\n",
    "    \n",
    "    \n",
    "######################################\n",
    "#Prior Affilchange plotting\n",
    "PriorAffilChangeSum = NumOfPriorChangedROIs.sum(axis=0)\n",
    "PriorAffilChangeSum = PriorAffilChangeSum/NumOfSubs\n",
    "    \n",
    "xdata = np.arange(1,BlockNum)\n",
    "#print(AffilChangeSum)\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "plt.plot(xdata,np.transpose(PriorAffilChangeSum)/246)\n",
    "plt.title('Changing the Affiliation compared to the prior one averaged over subjects')\n",
    "#plt.plot(xdata,np.transpose(NumOfChangedROIs[5,:]))\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "\n",
    "for i in range (0,15):\n",
    "    plt.axvline(7.6*(i+1), linestyle='dashed',color='grey')\n",
    "    if i%4==0:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFD0E6', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min(np.transpose(PriorAffilChangeSum)/246), \"0back\", fontdict=None)\n",
    "    if i%4==1:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "    if i%4==2:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFE6CA', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min(np.transpose(PriorAffilChangeSum)/246), \"2back\", fontdict=None)\n",
    "    if i%4==3:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "    \n",
    "    ####################################\n",
    "labelsTot = []\n",
    "for mol in range(1,NumOfModules+1):\n",
    "    labelsTot.append(\"Module {0} average pop\".format(mol+1))\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, AveMat,labels=labelsTot)\n",
    "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.5), ncol=3, fancybox=True, shadow=True)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject (Average)')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.xlabel('Time')\n",
    "plt.show()\n",
    "\n",
    "##################################\n",
    "labelsTot = [\"Module 1 average pop\",\"Module 4 average pop\",\"Module 14 average pop\"]\n",
    "y1 = AveMat[0,:]\n",
    "y2 = AveMat[1,:]\n",
    "y3 = AveMat[2,:]\n",
    "y4 = AveMat[3,:]\n",
    "y5 = AveMat[4,:]\n",
    "y6 = AveMat[5,:]\n",
    "y7 = AveMat[6,:]\n",
    "y8 = AveMat[7,:]\n",
    "y9 = AveMat[8,:]\n",
    "y10 = AveMat[9,:]\n",
    "y11 = AveMat[10,:]\n",
    "y12 = AveMat[11,:]\n",
    "y13 = AveMat[12,:]\n",
    "y14 = AveMat[13,:]\n",
    "y15 = AveMat[14,:]\n",
    "\n",
    "y = np.vstack([y1, y4, y14])\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y,labels=labelsTot)\n",
    "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.5), ncol=3, fancybox=True, shadow=True)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Modules BN_anterior_salience(1),BN_dDMN(4),BN_Visuospatial(14)')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "##############################################\n",
    "#All Modules of the 15 Module system ploted:\n",
    "##############################################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y1)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module One, BN_anterior_salience')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y3)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Three, BN_Basal_Ganglia')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y4)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Four, BN_dDMN')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y5)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Five, BN_high_Visual')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y12)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Twelve, BN_Sensorimotor')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y13)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Thirteen, BN_vDMN')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y14)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Fourteen, BN_Visuospatial')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y15)\n",
    "plt.title('Changing the Population of Dependencies over Time for All Subject in Module Fifteen, UD')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Normalized:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "###Variables######################\n",
    "SavingAddress =\"Needed_Address\"\n",
    "address= 'Needed_Address/15Affiliation.mat'\n",
    "TableName= 'a'\n",
    "TBD= 15\n",
    "OP= 0.95\n",
    "DataLength= 128\n",
    "NumOfModules= 15\n",
    "NumOfSubs= len(lis)\n",
    "NumofBrainRegions= 246\n",
    "SubjectSelection= True\n",
    "SubjectIds = lis\n",
    "NumOfGroupSubs = len(lis)\n",
    "###################################\n",
    "\n",
    "BlockNum = int((DataLength - int(OP*TBD)) / (TBD - int(OP*TBD))) -1\n",
    "    \n",
    "#Plot Info:\n",
    "NumOfPlotsColumns = 5\n",
    "NumOfPlotsRows = (NumOfSubs//5) +1\n",
    "\n",
    "\n",
    "#Average over population measures:\n",
    "AveMat = np.zeros((NumOfModules,BlockNum))\n",
    "#NumOfChangedROIs is the NumOfSubs*BlockNum-1 matrix which contains the number of nodes that change their \n",
    "#affiliation in each time step. A row for each subject.\n",
    "NumOfChangedROIs = np.zeros((NumOfSubs,BlockNum-1))\n",
    "NumOfPriorChangedROIs = np.zeros((NumOfSubs,BlockNum-1))\n",
    "    \n",
    "    \n",
    "inputMatrix = scipy.io.loadmat(address)\n",
    "PriorAffil = np.array(inputMatrix[TableName])\n",
    "PriorAffil = np.transpose(PriorAffil)\n",
    "if SubjectSelection == True :\n",
    "    SubRange = SubjectIds\n",
    "else:\n",
    "    SubRange = np.arange(1,NumOfSubs+1)\n",
    "    \n",
    "NumOfSubs = len(SubRange)\n",
    "    \n",
    "    \n",
    "for subject in SubRange:\n",
    "    MatTot = np.zeros((1,NumofBrainRegions))\n",
    "    NumofSampInt = subject\n",
    "    WinningModuleTot = np.zeros((1,NumofBrainRegions))\n",
    "    for timeblock in range(0,BlockNum): \n",
    "        initial = timeblock*TBD - timeblock*(int(OP*TBD))\n",
    "        final = (timeblock+1)*TBD - timeblock*(int(OP*TBD))\n",
    "        Mat = np.load(SavingAddress +'/%s/%s/Normalized/Normalized_Subject_%s_FromTime%d_to_%d.npy'%(NumofSampInt,NumofSampInt,NumofSampInt,initial,final))\n",
    "        WinningModuleinT = np.zeros((1,NumofBrainRegions))\n",
    "        for i in range(0,NumofBrainRegions):\n",
    "            WinningModuleinT[0,i] = np.argmax(Mat[:,i])   \n",
    "        MatTot = np.concatenate((MatTot,Mat), axis=0)\n",
    "        WinningModuleTot = np.concatenate((WinningModuleTot,WinningModuleinT), axis=0)\n",
    "\n",
    "    #WinningModuleTot is a BlockNum*ROINum matrix which shows the the affiliation of all ROIs to the winning modules in\n",
    "    #time window (BlockNum)\n",
    "    #This MatTot is the concatenated matrix for all nodes of a single subject for all time windows\n",
    "    MatTot = np.delete(MatTot, (0), axis=0)\n",
    "    #print(np.shape(MatTot))\n",
    "    WinningModuleTot = np.delete(WinningModuleTot, (0), axis=0)\n",
    "\n",
    "    WinningModuleTot = WinningModuleTot + 1\n",
    "    #print(np.shape(WinningModuleTot))\n",
    "    #print(WinningModuleTot)\n",
    "        \n",
    "    ##################################################\n",
    "    #Now That we have WinningModuleTot which is showing us the affiliations over time for each node, we want\n",
    "    #to track how many of the nodes are changing their affiliation in each step: NumOfChangedROIs = np.zeros(NumOfSubs,BlockNum-1)\n",
    "    for ii in range(0,BlockNum-1):\n",
    "        Dif = 0\n",
    "        for jj in range (0, NumofBrainRegions):\n",
    "            if (WinningModuleTot[ii,jj]) != (WinningModuleTot[ii+1,jj]):\n",
    "                Dif = Dif+1\n",
    "        NumOfChangedROIs[SubRange.index(subject),ii] = Dif    \n",
    "        ##################################################\n",
    "    #This is another way of change-calc, were I compare them with the default one at each step.\n",
    "    #(and not with the previous step)\n",
    "    for ii in range(0,BlockNum-1):\n",
    "        Dif = 0\n",
    "        for jj in range (0, NumofBrainRegions):\n",
    "            if (WinningModuleTot[ii,jj]) != (PriorAffil[0,jj]):\n",
    "                Dif = Dif+1\n",
    "        NumOfPriorChangedROIs[SubRange.index(subject),ii] = Dif\n",
    "        #################################################\n",
    "    ModulDistr = np.zeros((NumOfModules,BlockNum))\n",
    "    #print(np.shape(ModulDistr))\n",
    "    #ModulDistr is a 9*13 (NumofModules*Time) matrix where each element (i,j) shows the number of nodes in the i-th module at time j.\n",
    "    for i in range (0,NumOfModules):\n",
    "        for j in range (0,BlockNum):\n",
    "            ModulDistr[i,j] = np.count_nonzero(WinningModuleTot[j,:]==i+1)\n",
    "\n",
    "    AveMat = np.add(AveMat, ModulDistr)\n",
    "\n",
    "    #print(ModulDistr)\n",
    "    x = list(range(1,BlockNum+1))\n",
    "\n",
    "    labels = []\n",
    "    for mol in range(1,NumOfModules+1):\n",
    "        labels.append(\"Module {0}\".format(mol+1))\n",
    "        \n",
    "    #np.save(SavingAddress + '/%s/%s/Normalized/Normalized_ModuleDistrbOfSubject_%s.npy'%(NumofSampInt,NumofSampInt,NumofSampInt),ModulDistr)\n",
    "        #ax[(subject-1)//NumOfPlotsColumns,(subject-1)%NumOfPlotsColumns].stackplot(x, ModulDistr,labels=labels)\n",
    "        \n",
    "    #plt.show()\n",
    "AveMat = AveMat/NumOfSubs\n",
    "# print(np.shape(AveMat))\n",
    "# print(AveMat)\n",
    "\n",
    "x = list(range(1,BlockNum+1))\n",
    "    #####################################\n",
    "    #Changing population calculation:\n",
    "    #print(AveMat)\n",
    "AffilChange = np.zeros((1,BlockNum-1))\n",
    "    #AffilChange is a row vector showing the total number of changing agents per time steps.\n",
    "for j in range(0,BlockNum-1):\n",
    "        #for i in range (0,NumOfModules):\n",
    "    AffilChange[0,j] = (1/2) * sum(abs(AveMat[:,j] - AveMat[:,j+1]))\n",
    "    \n",
    "# xdata = np.arange(1,BlockNum)\n",
    "#     #print(AffilChange)\n",
    "# fig, ax = plt.subplots()\n",
    "# plt.plot(xdata,np.transpose(AffilChange))\n",
    "# plt.title('Population of affiliation change per time step')\n",
    "# plt.grid(True)\n",
    "# plt.show()\n",
    "    \n",
    "    \n",
    "    #####################################\n",
    "    #NumOfChangedROIs average plotting:\n",
    "    \n",
    "AffilChangeSum = NumOfChangedROIs.sum(axis=0)\n",
    "AffilChangeSum = AffilChangeSum/NumOfSubs\n",
    "    \n",
    "    \n",
    "\n",
    "xdata = np.arange(3,BlockNum-3)\n",
    "#print(AffilChangeSum)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "# collection = collections.BrokenBarHCollection.span_where(xdata, ymin=0, ymax=100, where= np.transpose(AffilChangeSum[3:BlockNum-3])> 0, facecolor='green', alpha=0.5)\n",
    "# ax.add_collection(collection)\n",
    "\n",
    "\n",
    "\n",
    "plt.plot(xdata,np.transpose(AffilChangeSum[3:BlockNum-3]/246))\n",
    "plt.title('Normalized, change in modular affiliation of regions from each time point to the next averaged across subjects')\n",
    "plt.xlabel('windows', fontsize=22)\n",
    "plt.ylabel('Flexibility', fontsize=22)\n",
    "matplotlib.rc('font', size=10)\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "\n",
    "\n",
    "\n",
    "                       \n",
    "for i in range (0,15):\n",
    "    plt.axvline(7.6*(i+1), linestyle='dashed',color='grey')\n",
    "    if i%4==0:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFD0E6', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min(AffilChangeSum[3:BlockNum-3]/246), \"0back\", fontdict=None)\n",
    "    if i%4==1:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "    if i%4==2:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFE6CA', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25),  min(AffilChangeSum[3:BlockNum-3]/246), \"2back\", fontdict=None)\n",
    "    if i%4==3:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "\n",
    "ax.tick_params(axis=\"y\", labelsize=5)\n",
    "plt.show()\n",
    "    \n",
    "    \n",
    "######################################\n",
    "#Prior Affilchange plotting\n",
    "PriorAffilChangeSum = NumOfPriorChangedROIs.sum(axis=0)\n",
    "PriorAffilChangeSum = PriorAffilChangeSum/NumOfSubs\n",
    "    \n",
    "xdata = np.arange(1,BlockNum)\n",
    "#print(AffilChangeSum)\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "plt.plot(xdata,np.transpose(PriorAffilChangeSum)/246)\n",
    "plt.title('Normalized, Changing the Affiliation compared to the prior one averaged over subjects')\n",
    "#plt.plot(xdata,np.transpose(NumOfChangedROIs[5,:]))\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "\n",
    "for i in range (0,15):\n",
    "    plt.axvline(7.6*(i+1), linestyle='dashed',color='grey')\n",
    "    if i%4==0:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFD0E6', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min(np.transpose(PriorAffilChangeSum)/246), \"0back\", fontdict=None)\n",
    "    if i%4==1:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "    if i%4==2:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFE6CA', alpha=0.5)\n",
    "        matplotlib.pyplot.text(7.6*(i+0.25), min(np.transpose(PriorAffilChangeSum)/246), \"2back\", fontdict=None)\n",
    "    if i%4==3:\n",
    "        plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "    \n",
    "    ####################################\n",
    "labelsTot = []\n",
    "for mol in range(1,NumOfModules+1):\n",
    "    labelsTot.append(\"Module {0} average pop\".format(mol+1))\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, AveMat,labels=labelsTot)\n",
    "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.5), ncol=3, fancybox=True, shadow=True)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject (Average)')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.xlabel('Time Windows')\n",
    "plt.show()\n",
    "\n",
    "##################################\n",
    "labelsTot = [\"Module 1 average pop\",\"Module 4 average pop\",\"Module 14 average pop\"]\n",
    "y1 = AveMat[0,:]\n",
    "y2 = AveMat[1,:]\n",
    "y3 = AveMat[2,:]\n",
    "y4 = AveMat[3,:]\n",
    "y5 = AveMat[4,:]\n",
    "y6 = AveMat[5,:]\n",
    "y7 = AveMat[6,:]\n",
    "y8 = AveMat[7,:]\n",
    "y9 = AveMat[8,:]\n",
    "y10 = AveMat[9,:]\n",
    "y11 = AveMat[10,:]\n",
    "y12 = AveMat[11,:]\n",
    "y13 = AveMat[12,:]\n",
    "y14 = AveMat[13,:]\n",
    "y15 = AveMat[14,:]\n",
    "\n",
    "y = np.vstack([y1, y4, y14])\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y,labels=labelsTot)\n",
    "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.5), ncol=3, fancybox=True, shadow=True)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Modules BN_anterior_salience(1),BN_dDMN(4),BN_Visuospatial(14)')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "##############################################\n",
    "#All Modules of the 15 Module system ploted:\n",
    "##############################################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y1)\n",
    "plt.title('Normalized,,Changing the Population of Dependencies over Time for All Subject in Module One, BN_anterior_salience')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y3)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Three, BN_Basal_Ganglia')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y4)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Four, BN_dDMN')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "# for i in range (0,15):\n",
    "#     plt.axvline(7.6*(i+1), linestyle='dashed',color='grey')\n",
    "#     if i%4==0:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFD0E6', alpha=0.5)\n",
    "#         matplotlib.pyplot.text(7.6*(i+0.25), 10, \"0back\", fontdict=None)\n",
    "#     if i%4==1:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "#     if i%4==2:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFE6CA', alpha=0.5)\n",
    "#         matplotlib.pyplot.text(7.6*(i+0.25), 10, \"2back\", fontdict=None)\n",
    "#     if i%4==3:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "\n",
    "\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y5)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Five, BN_high_Visual')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y12)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Twelve, BN_Sensorimotor')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y13)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Thirteen, BN_vDMN')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y14)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Fourteen, BN_Visuospatial')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "\n",
    "# for i in range (0,15):\n",
    "#     plt.axvline(7.6*(i+1), linestyle='dashed',color='grey')\n",
    "#     if i%4==0:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFD0E6', alpha=0.5)\n",
    "#         matplotlib.pyplot.text(7.6*(i+0.25), 10, \"0back\", fontdict=None)\n",
    "#     if i%4==1:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "#     if i%4==2:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#BFE6CA', alpha=0.5)\n",
    "#         matplotlib.pyplot.text(7.6*(i+0.25), 10, \"2back\", fontdict=None)\n",
    "#     if i%4==3:\n",
    "#         plt.axvspan(7.6*i, 7.6*(i+1), facecolor='#FFFFFF', alpha=0.5)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plt.show()\n",
    "###########################\n",
    "##########################\n",
    "fig, ax = plt.subplots(figsize=(20, 5))\n",
    "ax.stackplot(x, y15)\n",
    "plt.title('Normalized, Changing the Population of Dependencies over Time for All Subject in Module Fifteen, UD')\n",
    "plt.ylabel('Average Dependent Nodes Population')\n",
    "plt.xlabel('Time Windows')\n",
    "plt.grid(color='b', linestyle=':', linewidth=0.2)\n",
    "plt.show()\n",
    "###########################"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}