{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from prody import *\n",
    "import numpy as np\n",
    "from os.path import basename\n",
    "import fnmatch\n",
    "import os\n",
    "import networkx as nx\n",
    "from networkx.algorithms import community\n",
    "from itertools import chain, combinations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Community composition analysis (i) between segments and (ii) residue by residue. RGB coloring scheme for _$\\Omega$_ = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### __Beware that your pdb and dcd should have the same name and you can write a string pattern for batch calculation__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next cell, please write start, stop and stride of the dcd file that you want to analyze.\n",
    "Point out the maximum community size you want to write to output files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "starting_frame = 20 # write starting frame of your dcd\n",
    "stopping_frame = 120 # last frame of your dcd\n",
    "stride = 10 # stride of your dcd file\n",
    "max_community_size = 5 #maximum number of communities/omega"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write the file string pattern or your pdb file. Please realize that, that file name also will be used for parsing related dcd file. Further, please select atoms you want to coarse-grain and analyze as nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_string_pattern = '*.pdb' #if you write *.pdb, it will go through all the pdb's in the \n",
    "                                        #working directory and use the dcd files with the same name\n",
    "atom_selection_string = \"(name CB and protein) or (name CA and resname GLY)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three different calculation scheme for dynamic community composition.\n",
    "\n",
    "**1) Community sharing segments over time.**\n",
    "This calculates the community sharing fraction between two pre-assigned structural segments based on their residue numbers. By using this calculation, the user can understand the underlying changes over the commumity composition through the MD trajectory, and the user can detect the number of community seperation that is needed to seperate two segments. This is important since some of the effects may cancel on average.\n",
    "\n",
    "**2) Average residue by residue community co-occupancy.**\n",
    "\n",
    "Here, for each $\\Omega$, the user can calculate the fraction of community sharing of each residue on time average. By using this information, the user can detect the group of residues that tend to be in the same community throught the MD trajectory.\n",
    "\n",
    "**3) Protein structure coloring by RGB scheme that calculated by community sharing of reference residues.**\n",
    "\n",
    "By deciding, three reference residues for red, green and blue, the user can calculate the fraction of community sharing belonging to other nodes based on the color code of reference nodes. This process may be done for certain $\\Omega$, and the default is $\\Omega$ = 4.\n",
    "\n",
    "Please assign, True or False, for each calculation to be done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Between the segments\n",
    "\n",
    "segment_calculation = True\n",
    "\n",
    "segment_1 = list(range(299, 311)) \n",
    "segment_2 = list(range(2, 10)) \n",
    "\n",
    "#Res by Res calculation \n",
    "res_by_res_calculation = True\n",
    "\n",
    "#RGS scheme coloring matrix\n",
    "rgb_scheme = True\n",
    "rgb_community = 4\n",
    "red = [316]\n",
    "green = [392]\n",
    "blue = [372]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "@> 1902 atoms and 1 coordinate set(s) were parsed in 0.01s.\n",
      "@> DCD file contains 1199 coordinate sets for 1902 atoms.\n",
      "@> DCD file was parsed in 0.00 seconds.\n",
      "@> 26.13 MB parsed at input rate 8984.83 MB/s.\n",
      "@> 1199 coordinate sets parsed at input rate 412345 frame/s.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the residue index of the nodes\n",
      "299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 2 3 4 5 6 7 8 9\n",
      "\n",
      "\n",
      "Index of MD-simulation frame 0\n",
      "Index of MD-simulation frame 1\n",
      "Index of MD-simulation frame 2\n",
      "Index of MD-simulation frame 3\n",
      "Index of MD-simulation frame 4\n",
      "Index of MD-simulation frame 5\n",
      "Index of MD-simulation frame 6\n",
      "Index of MD-simulation frame 7\n",
      "Index of MD-simulation frame 8\n",
      "Index of MD-simulation frame 9\n"
     ]
    }
   ],
   "source": [
    "for file in os.listdir('.'):\n",
    "    if fnmatch.fnmatch(file, file_string_pattern): \n",
    "        #Find the pdb and parse it\n",
    "        pdb_name = file\n",
    "        #print(pdb_name)\n",
    "        structure = parsePDB(str(pdb_name))\n",
    "        file_name_wh_ex = str(os.path.splitext(pdb_name)[0])\n",
    "        structure_beta = structure.select(atom_selection_string)\n",
    "        residues = structure_beta.getResnums()\n",
    "        residue_number = len(structure_beta)\n",
    "        conf_size = len(range(starting_frame, stopping_frame, stride))\n",
    "        #Initiate variables\n",
    "        BC_data_matrix = np.zeros((residue_number, conf_size))\n",
    "        comm_mat_btw_segment = np.zeros((max_community_size-1,conf_size))\n",
    "        community_all_data_matrix = np.zeros((residue_number, residue_number, conf_size, max_community_size-1))\n",
    "        rgb_matrix = np.zeros((residue_number, conf_size, 3))\n",
    "        #Parse the dcd file\n",
    "        for frame_interval in [[starting_frame,stopping_frame]]:\n",
    "            ensemble_cov_2 = parseDCD(str(file_name_wh_ex)+\".dcd\",\n",
    "                                      frame_interval[0],frame_interval[1],stride);\n",
    "            \n",
    "            #select the nodes from the protein structure\n",
    "            res_index = structure_beta.getResnums()\n",
    "            print(\"Here is the residue index of the nodes\")\n",
    "            print(' '.join(map(str, res_index)))\n",
    "            print(\"\\n\")\n",
    "            #bind the dcd and pdb files\n",
    "            ensemble_cov_2_mean = (ensemble_cov_2.getCoordsets()).mean(0)\n",
    "            ensemble_cov_2.setAtoms(structure_beta);\n",
    "            ensemble_cov_2.setCoords(ensemble_cov_2_mean);\n",
    "            #start the loop for the frames in dcd\n",
    "            for conformation_num in range(len(ensemble_cov_2)):\n",
    "                betas_gly_alphas = ensemble_cov_2[conformation_num].getAtoms()\n",
    "                betas_gly_alphas_coords = ensemble_cov_2[conformation_num].getCoords()\n",
    "                nodes = betas_gly_alphas\n",
    "                nodes_range = len(nodes)\n",
    "                nodes_list = nodes.getResnums()\n",
    "#                print(nodes_list)\n",
    "                print(\"Index of MD-simulation frame \"+str(conformation_num))\n",
    "    \n",
    "                #Contruct the network, please locate the cut-off value\n",
    "                ia_list = []\n",
    "                for i in range(nodes_range-1):\n",
    "                    for j in range(i+1, nodes_range):\n",
    "                        dist = calcDistance(betas_gly_alphas_coords[i], betas_gly_alphas_coords[j])\n",
    "                        if dist > 6.7:\n",
    "                            continue\n",
    "                        ia_list.append((nodes[i].getResnum(), nodes[j].getResnum()))\n",
    "    \n",
    "                protein_graph = nx.Graph()\n",
    "                protein_graph.add_nodes_from(nodes_list)\n",
    "                protein_graph.add_edges_from(ia_list)\n",
    "            ############################################\n",
    "                #### Calculate the node betweenness centrality\n",
    "                betwen_cent = nx.betweenness_centrality(protein_graph, normalized=True)\n",
    "                betwen_cent = np.asarray(list(betwen_cent.values()))\n",
    "                betwen_cent = betwen_cent.reshape((residue_number,1))\n",
    "                BC_data_matrix[:,conformation_num] = betwen_cent[:,0]\n",
    "    \n",
    "            ###########################################\n",
    "            ###Calculate Girwan-Newman communities\n",
    "                partition_girvan_newman = list(community.girvan_newman(protein_graph))\n",
    "                partition_girvan_newman = partition_girvan_newman[0:max_community_size-1]\n",
    "            ########## SEG by SEG community composition calculation\n",
    "                if segment_calculation is True:\n",
    "                    for i in range(max_community_size-1):\n",
    "                        for comm in partition_girvan_newman[i]:\n",
    "                            comm = list(comm)\n",
    "                            if ((any(list(item in segment_1 for item in comm)) and any(list(item in segment_2 for item in comm)))) == True:\n",
    "                                comm_mat_btw_segment[i,conformation_num] = 1\n",
    "                                \n",
    "            \n",
    "            ####### RES BY RES community composition calculation\n",
    "                if res_by_res_calculation is True:\n",
    "                    for i in range(residue_number):\n",
    "                        for j in range(residue_number):\n",
    "                            for level in partition_girvan_newman:\n",
    "                                for comm in level:\n",
    "                                    comm = list(comm)\n",
    "                                    if (residues[i] in comm) and (residues[j] in comm) == True:\n",
    "                                        community_all_data_matrix[i, j, conformation_num, partition_girvan_newman.index(level)] = 1\n",
    "            #### RGB scheme calculation                        \n",
    "                if rgb_scheme is True:\n",
    "                    for i in range(residue_number):\n",
    "                        for comm in partition_girvan_newman[rgb_community-2]:\n",
    "                            comm = list(comm)\n",
    "                            if (red in comm):\n",
    "                                is_in = np.isin(residues, comm)\n",
    "                                rgb_matrix[np.where(is_in)[0], conformation_num, 0] = 1\n",
    "                            if (green in comm):\n",
    "                                is_in = np.isin(residues, comm)\n",
    "                                rgb_matrix[np.where(is_in)[0], conformation_num, 1] = 1\n",
    "                            if (blue in comm):\n",
    "                                is_in = np.isin(residues, comm)\n",
    "                                rgb_matrix[np.where(is_in)[0], conformation_num, 2] = 1\n",
    "                                \n",
    "                                \n",
    "                                \n",
    "        ###Write output files\n",
    "        np.savetxt(file_name_wh_ex+\"_node_BC.dat\", \n",
    "                   np.transpose([np.mean(BC_data_matrix, axis=1), np.divide(np.std(BC_data_matrix, axis=1),\n",
    "                                                                            np.sqrt(conf_size-1))]))\n",
    "        if res_by_res_calculation is True:\n",
    "            for i in range(max_community_size-1):\n",
    "                np.savetxt(file_name_wh_ex+\"_community_\"+str(i+2)+\"_res_by_res_matrix.dat\",\n",
    "                           np.mean(community_all_data_matrix[:,:,:,i], axis=2), fmt='%1.2f')\n",
    "        if segment_calculation is True:\n",
    "            np.savetxt(file_name_wh_ex+\"_comm_btw_segments.dat\", comm_mat_btw_segment.T, fmt='%1d')\n",
    "        if rgb_scheme is True:\n",
    "            rgb_matrix = np.mean(rgb_matrix, axis=1)\n",
    "            np.savetxt(file_name_wh_ex+\"_rgb_data_matrix.dat\", rgb_matrix, fmt='%1.1f')\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot node BC by using the standard error as error bars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "\n",
    "BC = np.loadtxt(file_name_wh_ex+\"_node_BC.dat\") #Load the data\n",
    "fig, ax = plt.subplots(figsize=(9,5))\n",
    "ax.set_ylabel('Node BC'); #set label names\n",
    "ax.set_xlabel('Node Index');\n",
    "plt.yticks(fontsize=12, fontname = \"Arial\")\n",
    "plt.xticks(fontsize=12, fontname = \"Arial\")\n",
    "plt.xticks(np.arange(0,residue_number,10), residues[0:-1:10])\n",
    "ax.errorbar(np.arange(residue_number), BC[:,0], BC[:,1], color='black', ecolor='black', marker= 'o'); # plot x, y and errors\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Segment by segment co-occupancy fraction over the MD trajectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title(file_name_wh_ex) #set the title\n",
    "\n",
    "plt.pcolormesh(np.loadtxt(file_name_wh_ex+\"_comm_btw_segments.dat\").T, edgecolors='k', linewidth=1, \n",
    "               cmap=cm.binary, vmin=0.00001) # load the data and plot\n",
    "ax = plt.gca()\n",
    "ax.set_aspect('equal')\n",
    "plt.xticks(np.arange(0.5, conf_size+0.5),np.arange(conf_size)) # set the ticks of x axis\n",
    "plt.yticks(np.arange(0.5, max_community_size-0.5),np.arange(max_community_size-1)+2 ) # set the ticks of y axis\n",
    "\n",
    "plt.yticks(fontsize=10, fontname = \"Arial\")\n",
    "plt.xticks(fontsize=10, fontname = \"Arial\")\n",
    "#plt.grid(color='black', linestyle='-', linewidth=1) # set the grid thickness\n",
    "ax.set_ylabel(r'$\\Omega$'); #set label names\n",
    "ax.set_xlabel('Timestamp of frames');\n",
    "#plt.savefig(file_name_wh_ex+\"_comm_btw_segments\", dpi=600, bbox_inches='tight') #comment in if you want to save the graph\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the average community sharing between two segments for $\\Omega$ = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For omega = 5: 0.60 ± 0.16\n"
     ]
    }
   ],
   "source": [
    "#Load the data from the previous computation\n",
    "segment_btw_comm = np.loadtxt(file_name_wh_ex+\"_comm_btw_segments.dat\")\n",
    "#Here is the tricky one, rows indicate the frames of MD-trajectory, by putting ':', we take all of the frames into account.\n",
    "#For omega = 5, we write '3' to the column part, since indices start with '0' in python, the first column will have the information for omega = 2.\n",
    "#So by writing '3' to the column section, we do the calculation for omega = 5.\n",
    "mean = np.mean(segment_btw_comm[:,3])\n",
    "#There are 10 frames (now here is a variable), so for error we normalize std by sqare-root of the frame count\n",
    "std_err = np.std(segment_btw_comm[:,3])/np.sqrt(conf_size-1)\n",
    "#Let's print the output\n",
    "print('{}: {:.2f} ± {:.2f}'.format(\"For omega = 5\",mean, std_err))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Average residue by residue co-occupancy fraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "full_mat_tot = np.loadtxt(file_name_wh_ex+\"_community_5_res_by_res_matrix.dat\") #let's load the data for omega=4\n",
    "plt.title(file_name_wh_ex) # set title\n",
    "plt.imshow(full_mat_tot, cmap=cm.binary, origin='lower', vmin=0, vmax=1) # plot the heatmap\n",
    "cbar = plt.colorbar() # Don't forget the colorbar\n",
    "ax = plt.gca()\n",
    "ax.set_aspect('equal')\n",
    "\n",
    "\n",
    "plt.yticks(np.arange(0,residue_number,10), residues[0:-1:10]) #Arrange the ticks\n",
    "plt.xticks(np.arange(0,residue_number,10), residues[0:-1:10])\n",
    "\n",
    "plt.yticks(fontsize=10, fontname = \"Arial\")\n",
    "plt.xticks(fontsize=10, fontname = \"Arial\", rotation=45)\n",
    "#plt.savefig(file_name_wh_ex+\"_community_4_res_by_res_matrix\", dpi=600, bbox_inches='tight') # comment in to save the plot\n",
    "plt.show()\n",
    "plt.close()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here we write the vmd file contains the RGB coloring information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/7p/q8xp6f956jgglgh04hjl6dqr0000gn/T/ipykernel_50110/966306853.py:4: RuntimeWarning: invalid value encountered in divide\n",
      "  full_mat_tot = full_mat_tot/full_mat_tot_row_sums[:, np.newaxis];\n"
     ]
    }
   ],
   "source": [
    "full_mat_tot = np.loadtxt(file_name_wh_ex+\"_rgb_data_matrix.dat\")\n",
    "full_mat_tot = np.round(full_mat_tot, decimals=1)\n",
    "full_mat_tot_row_sums = np.sum(full_mat_tot, axis=1)\n",
    "full_mat_tot = full_mat_tot/full_mat_tot_row_sums[:, np.newaxis];\n",
    "full_mat_tot[np.isnan(full_mat_tot)] = 0\n",
    "full_mat_tot = np.round(full_mat_tot, decimals=1)\n",
    "full_mat_tot_uniq = np.unique(full_mat_tot, axis=0)\n",
    "\n",
    "coloria = red+blue+green\n",
    "\n",
    "f = open(file_name_wh_ex+\"_color.vmd\", 'w')\n",
    "f.write(\"\"\"\n",
    "display projection Orthographic\n",
    "color change rgb  32 1 1 1 \n",
    "color Display Background 32\n",
    "axes location Off\n",
    "display depthcue off\n",
    "color scale method RGB\n",
    "\\n\n",
    "\"\"\")\n",
    "f.write(\"mol new {}.pdb\\n\".format(str(file_name_wh_ex)))\n",
    "f.write(\"mol modstyle 0 0 NewCartoon {0.300000 50.000000 4.100000 0}\\n\")\n",
    "\n",
    "for i in range(len(full_mat_tot_uniq)):\n",
    "    f.write(\"color change rgb  {:d} {:03.1f} {:03.1f} {:03.1f}\\n\".format(i, full_mat_tot_uniq[i][0], full_mat_tot_uniq[i][1], full_mat_tot_uniq[i][2]))\n",
    "    f.write(\"mol addrep 0\\n\")\n",
    "    f.write(\"mol modselect {:d} 0 resid {}\\n\".format(i+1,' '.join(map(str, residues[np.where(np.all(full_mat_tot==full_mat_tot_uniq[i], axis=1))[0]]))))\n",
    "    f.write(\"mol modstyle {:d} 0 NewCartoon {{0.300000 50.000000 4.100000 0}}\\n\".format(i+1))\n",
    "    f.write(\"mol modcolor {:d} 0 ColorID {:d}\\n\".format(i+1,i))\n",
    "    \n",
    "\n",
    "f.write(\"mol addrep 0\\n\")\n",
    "f.write(\"mol modselect {:d} 0 resid {} and name CA\\n\".format(int(len(full_mat_tot_uniq)+1), red[0]))\n",
    "f.write(\"mol modstyle {:d} 0 CPK {{6.000000 0.300000 40.000000 40.000000}}\\n\".format(int(len(full_mat_tot_uniq)+1)))\n",
    "f.write(\"mol modcolor {:d} 0 ColorID {:d}\\n\".format(int(len(full_mat_tot_uniq)+1),np.where(np.all(full_mat_tot_uniq == full_mat_tot[np.where(residues == red[0])], axis=1))[0][0]))\n",
    "\n",
    "f.write(\"mol addrep 0\\n\")\n",
    "f.write(\"mol modselect {:d} 0 resid {} and name CA\\n\".format(int(len(full_mat_tot_uniq)+2), blue[0]))\n",
    "f.write(\"mol modstyle {:d} 0 CPK {{6.000000 0.300000 40.000000 40.000000}}\\n\".format(int(len(full_mat_tot_uniq)+2)))\n",
    "f.write(\"mol modcolor {:d} 0 ColorID {:d}\\n\".format(int(len(full_mat_tot_uniq)+2),np.where(np.all(full_mat_tot_uniq == full_mat_tot[np.where(residues == blue[0])], axis=1))[0][0]))\n",
    "\n",
    "f.write(\"mol addrep 0\\n\")\n",
    "f.write(\"mol modselect {:d} 0 resid {} and name CA\\n\".format(int(len(full_mat_tot_uniq)+3), green[0]))\n",
    "f.write(\"mol modstyle {:d} 0 CPK {{6.000000 0.300000 40.000000 40.000000}}\\n\".format(int(len(full_mat_tot_uniq)+3)))\n",
    "f.write(\"mol modcolor {:d} 0 ColorID {:d}\\n\".format(int(len(full_mat_tot_uniq)+3),np.where(np.all(full_mat_tot_uniq == full_mat_tot[np.where(residues == green[0])], axis=1))[0][0]))\n",
    "\n",
    "f.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}