Total_Power_of_Node.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Tr_centrality_measure\n",
    "import Graph_Entropy_measure\n",
    "import Selection_Algorithm\n",
    "import Constraint_Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from datetime import timedelta\n",
    "\n",
    "start_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate PI and make the PI to have all positive result\n",
    "\n",
    "PI_table1 = pd.DataFrame(Graph_Entropy_measure.PI_Rank, columns = ('PI','PI_i'))\n",
    "PI_table = PI_table1.copy()\n",
    "i = math.sqrt(2)\n",
    "PI_table.PI_i = PI_table.PI_i.where(lambda x: x > 0, lambda x: x + i)\n",
    "\n",
    "#calculate  TC \n",
    "\n",
    "TC_table = pd.DataFrame(Tr_centrality_measure.TC_Rank, columns = ('TC','TC_i'))\n",
    "\n",
    "#calculate  CC\n",
    "\n",
    "CC_table = pd.DataFrame(Constraint_Coefficient.sorted_x, columns = ('CC','CC_i'))\n",
    "\n",
    "#joint the three \"PI,C,TC\" table together\n",
    "\n",
    "Result_table = pd.concat([TC_table, PI_table, CC_table], axis=1, sort=False)\n",
    "\n",
    "#create a table containing the Top three Rank Nodes\n",
    "\n",
    "Top_three = pd.DataFrame(Result_table.loc[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Top_three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Result_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#return the total power of node i.\n",
    "\n",
    "def TPN(i):\n",
    "    PI_ofi = 1/Graph_Entropy_measure.PI_of(i)\n",
    "    TC_ofi = Tr_centrality_measure.TC_of(i)\n",
    "    CC_ofi = Constraint_Coefficient.CC_of(i)\n",
    "    \n",
    "    #Weight to normalize the measures\n",
    "    dn=PI_ofi+TC_ofi+CC_ofi\n",
    "    n1=round(TC_ofi/dn, 2)\n",
    "    n2=round(PI_ofi/dn, 2)\n",
    "    n3=round(CC_ofi/dn, 2)\n",
    "    \n",
    "    #equation [Total Power of Node]\n",
    "    TPN_i  = (n1*TC_ofi)+(n2*PI_ofi)+(n3*CC_ofi)     \n",
    "\n",
    "    return TPN_i\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loop total power of node all i\n",
    "\n",
    "def loop_TPN():\n",
    "    i=0    \n",
    "    #concantinate the unique nodes in top_three ranking, with will remove duplicate \n",
    "    unique_top_three = list(pd.concat([Top_three['TC'], Top_three['PI'], Top_three['CC']]).unique())\n",
    "    \n",
    "    TPN_listing =[]    \n",
    "    for i in unique_top_three:          \n",
    "        TPN_ = TPN(i)\n",
    "        i_TPN = [i, TPN_]\n",
    "        TPN_listing.append(i_TPN)\n",
    "    return  TPN_listing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ranking the total power of node i\n",
    "\n",
    "def TPN_Ranking( val ):\n",
    "      return val [1]\n",
    "\n",
    "TPN_Rank = loop_TPN()\n",
    "TPN_Rank.sort(key=lambda elem: elem[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#return table containing the TPN ranking[TPN_table]\n",
    "\n",
    "TPN = pd.DataFrame(TPN_Rank, columns = ('TPN','TPN_i'))\n",
    "TPN.index = TPN.index + 1\n",
    "\n",
    "#TPN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#return table containing ALL the Measures\n",
    "Propose_Result_table = pd.concat([TC_table, PI_table, CC_table, TPN], axis=1, sort=False)\n",
    "Top_rank = pd.DataFrame(Propose_Result_table.loc[0:4])\n",
    "\n",
    "#return table containing Top_rank node ranking\n",
    "top_rank_table = pd.concat([Top_rank['TC'], Top_rank['PI'],  Top_rank['CC'],Top_rank['TPN']], axis=1, sort=False)\n",
    "\n",
    "#print(top_rank_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#save CSV file\n",
    "\n",
    "#Result_table.to_csv('result/kc--/propose/propose_result_table_kc.csv')#save the value of (TC,TC_i),(PI,PI_i),(CC,CC_i)\n",
    "#top_rank_table.to_csv('result/kc--/propose/top_rank_table_kc.csv')#save top three of(TC,PI,CC,TPN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution took: 0:00:01 secs (Wall clock time)\n"
     ]
    }
   ],
   "source": [
    "elapsed_time_secs = time.time() - start_time\n",
    "\n",
    "msg = \"Execution took: %s secs (Wall clock time)\" % timedelta(seconds=round(elapsed_time_secs))\n",
    "\n",
    "print(msg)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}