Partitioning chemical simulations.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from networkit import *\n",
    "import math\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cd \"/Users/Henning/Documents/workspace/NetworKit/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# deactivate vertex that represents the special part and needs to be deactivated\n",
    "def deactivateNode(G, x):\n",
    "    neigh = G.neighbors(x)\n",
    "    weights = {}\n",
    "\n",
    "    for u in neigh:\n",
    "        weights[u] = (G.weight(x, u))\n",
    "        G.removeEdge(x, u)\n",
    "    G.removeNode(x)\n",
    "    \n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# partition G with PLMR and different gamma resolutions\n",
    "def partition(G, x, Gname):\n",
    "    n = G.numberOfNodes()\n",
    "    gammaBy10 = 15 # scaled by 10 due to floating point errors in Python...\n",
    "    while gammaBy10 >= 5:\n",
    "        # perform partitioning/clustering\n",
    "        communities = community.detectCommunities(G, algo=community.PLM(G, True, gammaBy10 / 10))\n",
    "\n",
    "        # put deactivated vertex back in (as singleton cluster) and connect it to old neighbors\n",
    "        if (x >= 0):\n",
    "            communities.toSingleton(x)\n",
    "\n",
    "        # save communities to file\n",
    "        path = \"output/physchem/\" + Gname + \"-x=\" + str(x) + \"-gamma=\" + str(gammaBy10 / 10) + \".ptn\"\n",
    "        community.writeCommunities(communities, path)\n",
    "\n",
    "        ## compute edge cut comparison to continuous solution\n",
    "        # use number of clusters from PLM solution\n",
    "        # subtract 1 to account for special vertex\n",
    "        k = communities.numberOfSubsets() - 1\n",
    "\n",
    "        # compute continuous partition (and \"repair\" it)\n",
    "        avgSize = math.ceil(n / k)   \n",
    "        contPart = community.ClusteringGenerator().makeSingletonClustering(G)\n",
    "        for v in G.nodes():\n",
    "            contPart.moveToSubset(round(math.floor(v / avgSize)), v)\n",
    "        if (x >= 0):\n",
    "            contPart.toSingleton(x)\n",
    "\n",
    "        # modularity score for comparison\n",
    "        print(\"Modularity: \" + str(community.Modularity().getQuality(contPart, G)))\n",
    "\n",
    "        # save continuous to file for comparison\n",
    "        path = \"output/physchem/\" + Gname + \"-contPart-k=\" + str(k) + \".ptn\"\n",
    "        community.writeCommunities(contPart, path)\n",
    "\n",
    "        # print both coverage values\n",
    "        print(\"*** COVERAGE COMPARISON ***\")\n",
    "        plmrCov = community.Coverage().getQuality(communities, G)\n",
    "        contCov = community.Coverage().getQuality(contPart, G)\n",
    "        print(\"PLMR: \" + str(plmrCov))\n",
    "        print(\"CONT: \" + str(contCov))\n",
    "\n",
    "        # infer and print both edge cut values: EC = total edges - internal edges\n",
    "        tew = G.totalEdgeWeight()\n",
    "        print(\"*** EDGE CUT COMPARISON *** total edge weight: \", tew)\n",
    "        plmrEC = tew * (1.0 - plmrCov)\n",
    "        contEC = tew * (1.0 - contCov)\n",
    "        print(\"PLMR: \" + str(plmrEC))\n",
    "        print(\"CONT: \" + str(contEC))\n",
    "        if (contEC != 0.0):\n",
    "            print(\"!!! Improvement in percent: \", (1 - plmrEC / contEC) * 100, \" !!!\")\n",
    "        else:\n",
    "            print(\"!!! CONT is perfect!\")\n",
    "        print(\"\\n\")\n",
    "\n",
    "        # set coarseness parameter\n",
    "        gammaBy10 = gammaBy10 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# specify graphs to be processed\n",
    "Gnames = [\"bacteriorhodopsin-10-2.5\", \"bacteriorhodopsin-10-5\", \"bacteriorhodopsin-10-10\", \"br_corr_2\", \"bubble\", \"ubiquitin\"]\n",
    "specialNodes = [215, 215, 215, 210, -1, -1] # ggf. auch mit 216 als spez. Knoten\n",
    "specialNodes2 = [216, 216, 216, 211, -1, -1] # ggf. auch mit 216 als spez. Knoten\n",
    "\n",
    "# process all graphs in list\n",
    "i = 0\n",
    "for Gname in Gnames:\n",
    "    G = readGraph(\"input/physchem/\" + Gname + \".graph\", Format.METIS)\n",
    "    profile = profiling.Profile.create(G)\n",
    "    profile.show()\n",
    "    \n",
    "    x = specialNodes[i]\n",
    "    if (x >= 0):\n",
    "        G = deactivateNode(G, x)\n",
    "    partition(G, x, Gname)\n",
    "    \n",
    "    y = specialNodes2[i]\n",
    "    if (y >= 0):\n",
    "        G = deactivateNode(G, y)\n",
    "    partition(G, y, Gname)    \n",
    "    \n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "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.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}