Interactive_Plots.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U4XeVen_jh1y",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Percolation - Theory and Applications\n",
    "Student: _Guglielmo Grillo_  \n",
    "Course: _Multi-scale methods in soft matter physics [145889]_ held by _R. Potestio_  \n",
    "Exam Date: _February 14, 2023_\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T22:35:51.924235Z",
     "start_time": "2023-02-09T22:35:51.920811Z"
    },
    "id": "5ytVu39Px8bU"
   },
   "outputs": [],
   "source": [
    "L = 25 # Size of cluster. It can handle up to 50 but it becomes too slow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T22:26:31.137216Z",
     "start_time": "2023-02-09T22:26:31.131274Z"
    },
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# For the presentation\n",
    "# https://ipython-books.github.io/33-mastering-widgets-in-the-jupyter-notebook/\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import HBox, VBox\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T22:26:31.149882Z",
     "start_time": "2023-02-09T22:26:31.138279Z"
    },
    "id": "P3bylcGFybnk",
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "class Square_Lattice:\n",
    "    def __init__(self, L=20, uniform_coupling=False):\n",
    "        self.uniform_coupling = uniform_coupling\n",
    "        \n",
    "        self.L = L # Lattice side. number of edges in a direction is L-1 \n",
    "        if self.uniform_coupling:\n",
    "            self.__edges_x__ = np.random.uniform(low=0.0, high=1.0, size=(L-1, L) )\n",
    "            self.__edges_y__ = np.random.uniform(low=0.0, high=1.0, size=(L, L-1) )\n",
    "\n",
    "        self.percolate(0)\n",
    "        \n",
    "    def percolate(self, p):\n",
    "        if self.uniform_coupling:\n",
    "            self.x_edges = self.__edges_x__ < p\n",
    "            self.y_edges = self.__edges_y__ < p\n",
    "        else:\n",
    "            self.x_edges = np.random.uniform(low=0.0, high=1.0, size=(L-1, L) ) < p\n",
    "            self.y_edges = np.random.uniform(low=0.0, high=1.0, size=(L, L-1) ) < p\n",
    "        \n",
    "        return (self.x_edges, self.y_edges)\n",
    "    \n",
    "    \n",
    "    def __neighrest_neighbour_cluster__(self, cluster_idx, x, y):\n",
    "        \"\"\"\n",
    "            This function checks for an edge between the given vertex and its nn.\n",
    "            If a vertex is found, the same cluster index is assigned to the nn vertex\n",
    "            and the search is continued (deep-first search).\n",
    "            NB: if the new vertex as already a cluster the assignment is skipped.\n",
    "                This is not a problem thanks to the deep-first search.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Check the point above (NORTH)\n",
    "        if(y<self.y_edges.shape[1] and y<self.__clusters__.shape[1]-1 and # Check that we are not at the border at north\n",
    "            self.y_edges[x][y] and  # The edge between this point and the one above is open\n",
    "            self.__clusters__[x][y+1] == 0): # And the other point is not already in a cluster\n",
    "            \n",
    "            self.__clusters__[x][y+1] = cluster_idx\n",
    "            self.__neighrest_neighbour_cluster__(cluster_idx, x, y+1) # continue searching\n",
    "        \n",
    "        \n",
    "        # Check the point below (SOUTH)\n",
    "        if(y>0 and # Border south\n",
    "            self.y_edges[x][y-1] and  # The edge between the point below and this one is open\n",
    "            self.__clusters__[x][y-1] == 0): # not in a cluster\n",
    "            \n",
    "            self.__clusters__[x][y-1] = cluster_idx\n",
    "            self.__neighrest_neighbour_cluster__(cluster_idx, x, y-1) # DFS\n",
    "            \n",
    "        \n",
    "        # Check the point on the left (WEST)        \n",
    "        if(x>0 and \n",
    "            self.x_edges[x-1][y] and  \n",
    "            self.__clusters__[x-1][y] == 0):\n",
    "            \n",
    "            self.__clusters__[x-1][y] = cluster_idx         \n",
    "            self.__neighrest_neighbour_cluster__(cluster_idx, x-1, y)\n",
    "\n",
    "            \n",
    "        # Check the point on the right (EAST)\n",
    "        if(x < self.x_edges.shape[0] and x<self.__clusters__.shape[0]-1 and\n",
    "            self.x_edges[x][y] and\n",
    "            self.__clusters__[x+1][y] == 0):\n",
    "            \n",
    "            self.__clusters__[x+1][y] = cluster_idx\n",
    "            self.__neighrest_neighbour_cluster__(cluster_idx, x+1, y)\n",
    "           \n",
    "        \n",
    "    \n",
    "    def get_clusters(self):\n",
    "        cluster_idx = 0\n",
    "        self.__clusters__ = np.zeros((self.L, self.L), dtype=int)\n",
    "        \n",
    "        for y in range(self.__clusters__.shape[1]):\n",
    "            for x in range(self.__clusters__.shape[0]):\n",
    "                \n",
    "                # Only update if the point doesn't already belong to a cluster\n",
    "                if self.__clusters__[x][y] == 0:\n",
    "                    cluster_idx+=1\n",
    "                    self.__clusters__[x][y] = cluster_idx\n",
    "                    \n",
    "                    self.__neighrest_neighbour_cluster__(cluster_idx, x, y)\n",
    "        \n",
    "        return self.__clusters__\n",
    "    \n",
    "# Define the two clusters\n",
    "be_lattice = Square_Lattice(L=L, uniform_coupling=False)\n",
    "uc_lattice = Square_Lattice(L=L, uniform_coupling=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T22:27:52.045900Z",
     "start_time": "2023-02-09T22:27:52.038440Z"
    },
    "id": "Q1Rx05hLmt9N",
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plotting utils\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.colors import BASE_COLORS, CSS4_COLORS\n",
    "\n",
    "colors = ['b', 'g', 'k', 'r', 'c', 'm', 'y', 'w'] # list(mcolors.CSS4_COLORS.values()) \n",
    "\n",
    "def plot_edge(x, y, ax, direction, cluster_id=0, alpha=1):\n",
    "    color = colors[cluster_id % len(colors)]\n",
    "    \n",
    "    if direction == 'x':\n",
    "        #ax.annotate(str(cluster_id), (x+1.1, y+0.1))\n",
    "        x = [x, x+1]\n",
    "        y = [y, y]    \n",
    "    else:\n",
    "        #ax.annotate(str(cluster_id), (x+0.1, y+1.1))\n",
    "        x = [x, x]\n",
    "        y = [y, y+1]\n",
    "\n",
    "    ax.plot(x, y, lw=2, color=color, marker='.', alpha=alpha)\n",
    "    \n",
    "    \n",
    "def plot_lattice(lattice, ax, show_clusters=True, alpha=1):\n",
    "    clusters = lattice.get_clusters()\n",
    "    \n",
    "    for x in range(lattice.x_edges.shape[0]):\n",
    "        for y in range(lattice.x_edges.shape[1]):\n",
    "            if(lattice.x_edges[x][y]):\n",
    "                plot_edge(x=x, y=y, ax=ax, cluster_id=clusters[x][y] if show_clusters else 2, direction='x')\n",
    "        \n",
    "    for x in range(lattice.y_edges.shape[0]):\n",
    "        for y in range(lattice.y_edges.shape[1]):\n",
    "            if(lattice.y_edges[x][y]):\n",
    "                plot_edge(x=x, y=y, ax=ax, cluster_id=clusters[x][y] if show_clusters else 2, direction='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bernoulli Percolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e9822c2ae064efe874673ed5239b5bd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Checkbox(value=False, description='nodes'), Checkbox(value=False, description='edges'), …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@widgets.interact(p=(0, 1, 0.1))\n",
    "def what_is_percolation(nodes=False, edges=False, p=0, clusters=False):\n",
    "    global p_old\n",
    "    \n",
    "    if not 'p_old' in globals():\n",
    "        p_old = p\n",
    "        be_lattice.percolate(p)\n",
    "        \n",
    "    if p_old != p:\n",
    "        be_lattice.percolate(p)\n",
    "        p_old = p\n",
    "\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(9, 9))\n",
    "    fig.patch.set_facecolor('xkcd:mint green')\n",
    "\n",
    "    ax.axis('off')\n",
    "    ax.set_xlim(-0.5, L-0.5)\n",
    "    ax.set_ylim(-0.5, L-0.5)\n",
    "\n",
    "    if nodes:\n",
    "        for y in range(L):\n",
    "            for x in range(L):\n",
    "                ax.plot(x, y, marker='.', color='k')\n",
    "    if edges:\n",
    "        for y in range(-1, L):\n",
    "            for x in range(-1, L):\n",
    "                ax.plot( (x, x+1), (y, y), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                ax.plot( (x, x), (y, y+1), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "        \n",
    "    plot_lattice(be_lattice, ax, show_clusters=clusters)\n",
    "\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "##  Bernoulli Percolation vs Uniform Coupling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-02-09T22:27:58.342820Z",
     "start_time": "2023-02-09T22:27:58.222147Z"
    },
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "43336981a45b47c9aecb06e5ad2d1f7b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='p', max=1.0), Output()), _dom_classes=('widget-inter…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@widgets.interact(p=(0, 1, 0.1))\n",
    "def show_differences(p=0):\n",
    "    be_lattice.percolate(p)\n",
    "    uc_lattice.percolate(p)\n",
    "\n",
    "\n",
    "    fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(15, 7))\n",
    "    fig.patch.set_facecolor('xkcd:mint green')\n",
    "\n",
    "    line = plt.Line2D((.5, .5), (0, 1), color=\"gray\", linewidth=2, linestyle=\"--\")\n",
    "    fig.add_artist(line)\n",
    "\n",
    "    for ax in axs:\n",
    "        ax.axis('off')\n",
    "        ax.set_xlim(-0.5, L-0.5)\n",
    "        ax.set_ylim(-0.5, L-0.5)\n",
    "\n",
    "    axs[0].set_title('Bernoulli')\n",
    "    axs[1].set_title('Uniform Coupling')\n",
    "\n",
    "    plot_lattice(be_lattice, axs[0])\n",
    "    plot_lattice(uc_lattice, axs[1])\n",
    "\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Infinite Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def exists_infinite_path(clusters):\n",
    "    L = clusters.shape[0]\n",
    "    origin_cluster = clusters[L//2][L//2]\n",
    "    \n",
    "    # If the origin percolates we should find a point in the\n",
    "    # border which has the same cluster\n",
    "    for cluster_id in clusters[:][L-1]: # North\n",
    "        if cluster_id == origin_cluster: return True\n",
    "    \n",
    "    for cluster_id in clusters[:][0]: # South\n",
    "        if cluster_id == origin_cluster: return True\n",
    "    \n",
    "    for cluster_id in clusters[0][:]: # West\n",
    "        if cluster_id == origin_cluster: return True\n",
    "    \n",
    "    for cluster_id in clusters[L-1][:]: # East\n",
    "        if cluster_id == origin_cluster: return True\n",
    "    \n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "55cca04e9d0542f7a8b12b3a67b0451d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='p', max=1.0, step=0.01), IntSlider(value=0, descript…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@widgets.interact(p=(0, 1, 0.01), max_trials=(0, 10000, 100))\n",
    "def what_is_percolation(p=0, max_trials=0):\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(9, 9))\n",
    "    fig.patch.set_facecolor('xkcd:mint green')\n",
    "    ax.axis('off')\n",
    "    ax.set_xlim(-0.5, L-0.5)\n",
    "    ax.set_ylim(-0.5, L-0.5)\n",
    "\n",
    "\n",
    "    be_lattice.percolate(p)\n",
    "    clusters = be_lattice.get_clusters()\n",
    "\n",
    "    count = 0\n",
    "    while(not exists_infinite_path(clusters) and count < max_trials):\n",
    "        count+=1\n",
    "        be_lattice.percolate(p)\n",
    "        \n",
    "    if count >= max_trials:\n",
    "        print(\"Maximum number of iterations reached. No infinite path found.\")\n",
    "        return\n",
    "    \n",
    "    origin_cluster = clusters[L//2][L//2]\n",
    "    for x in range(be_lattice.x_edges.shape[0]):\n",
    "        for y in range(be_lattice.x_edges.shape[1]):\n",
    "            if(be_lattice.x_edges[x][y]):\n",
    "                plot_edge(x=x, y=y, ax=ax, cluster_id=clusters[x][y], direction='x', alpha= 1 if clusters[x][y]==origin_cluster else 0.05)\n",
    "        \n",
    "    for x in range(be_lattice.y_edges.shape[0]):\n",
    "        for y in range(be_lattice.y_edges.shape[1]):\n",
    "            if(be_lattice.y_edges[x][y]):\n",
    "                plot_edge(x=x, y=y, ax=ax, cluster_id=clusters[x][y], direction='y', alpha= 1 if clusters[x][y]==origin_cluster else 0.05)\n",
    "\n",
    "    ax.plot(L//2, L//2, marker=\"*\", markersize=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Foliation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(7, 7))\n",
    "ax = fig.add_subplot(projection='3d')\n",
    "\n",
    "ax.patch.set_facecolor('xkcd:mint green')\n",
    "\n",
    "for x in range(5):\n",
    "    for y in range(5):\n",
    "        for z in range(5):\n",
    "            ax.scatter(x, y, z, marker='o', color=colors[x % len(colors)])\n",
    "            ax.plot([x, x], [y, y], [z-0.5, z+0.5], linestyle=\"--\", color=colors[x % len(colors)], alpha=0.7)\n",
    "            ax.plot([x, x], [y-0.5, y+0.5], [z, z], linestyle=\"--\", color=colors[x % len(colors)], alpha=0.7)\n",
    "            ax.plot([x-0.5, x+0.5], [y, y], [z, z], linestyle=\"--\", color='grey', alpha=0.3)\n",
    "\n",
    "ax.set_xlabel('X')\n",
    "ax.set_ylabel('Y')\n",
    "ax.set_zlabel('Z')\n",
    "ax.view_init(10, 80)\n",
    "\n",
    "ax.set_xticks(range(5))\n",
    "ax.set_yticks(range(5))\n",
    "ax.set_zticks(range(5))\n",
    "ax.grid('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dual graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_dual = 10\n",
    "be_lattice_for_dual = Square_Lattice(L=L_dual, uniform_coupling=False)\n",
    "be_lattice_for_dual.percolate(0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_dual_lattice(lattice, ax, alpha=1):  \n",
    "    for x in range(lattice.x_edges.shape[0]):\n",
    "        for y in range(lattice.x_edges.shape[1]):\n",
    "            if(not lattice.x_edges[x][y]):\n",
    "                # horizontal edge missing, draw its perpendicular\n",
    "                plot_edge(x=x+0.5, y=y-0.5, ax=ax, cluster_id=0, direction='y')\n",
    "        \n",
    "    for x in range(lattice.y_edges.shape[0]):\n",
    "        for y in range(lattice.y_edges.shape[1]):\n",
    "            if(not lattice.y_edges[x][y]):\n",
    "                # vertical edge missing, draw its perpendicular\n",
    "                plot_edge(x=x-0.5, y=y+0.5, ax=ax, cluster_id=0, direction='x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "908508a600c2450ebb4e4f65582cbd36",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Checkbox(value=False, description='nodes'), Checkbox(value=False, description='edges'), …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@widgets.interact(p=(0, 1, 0.1))\n",
    "def what_is_percolation(nodes=False, edges=False, dual_node=False, dual_edges=False, p=0):\n",
    "    global p_old_dual\n",
    "    \n",
    "    if not 'p_old_dual' in globals():\n",
    "        p_old_dual = p\n",
    "        be_lattice_for_dual.percolate(p)\n",
    "        \n",
    "    if p_old_dual != p:\n",
    "        be_lattice_for_dual.percolate(p)\n",
    "        p_old_dual = p\n",
    "\n",
    "    fig, axs = plt.subplots(nrows=1, ncols=3, figsize=(15, 5))\n",
    "    fig.patch.set_facecolor('xkcd:mint green')\n",
    "    \n",
    "    line_sx = plt.Line2D((.34, .34), (0, 1), color=\"gray\", linewidth=2, linestyle=\"--\")\n",
    "    line_dx = plt.Line2D((.663, .663), (0, 1), color=\"gray\", linewidth=2, linestyle=\"--\")\n",
    "    fig.add_artist(line_sx)\n",
    "    fig.add_artist(line_dx)\n",
    "\n",
    "    for ax in axs:\n",
    "        ax.axis('off')\n",
    "        ax.set_xlim(-0.5, L_dual-0.5)\n",
    "        ax.set_ylim(-0.5, L_dual-0.5)\n",
    "        \n",
    "    axs[0].set_title('Both')\n",
    "    axs[1].set_title('Direct Graph')\n",
    "    axs[2].set_title('Dual Graph')\n",
    "\n",
    "    if nodes:\n",
    "        for y in range(L_dual):\n",
    "            for x in range(L_dual):\n",
    "                axs[0].plot(x, y, marker='.', color='k')\n",
    "                axs[1].plot(x, y, marker='.', color='k')\n",
    "    if edges:\n",
    "        for y in range(L_dual):\n",
    "            for x in range(L_dual):\n",
    "                axs[0].plot( (x, x+1), (y, y), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                axs[0].plot( (x, x), (y, y+1), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                \n",
    "                axs[1].plot( (x, x+1), (y, y), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                axs[1].plot( (x, x), (y, y+1), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "        \n",
    "    if dual_node:\n",
    "        for y in range(L_dual-1):\n",
    "            for x in range(L_dual-1):\n",
    "                axs[0].plot(x+0.5, y+0.5, marker='D', markersize=3, color='b')\n",
    "                axs[2].plot(x+0.5, y+0.5, marker='D', markersize=3, color='b')\n",
    "\n",
    "    if dual_edges:\n",
    "        for y in range(-1, L_dual-1):\n",
    "            for x in range(-1, L_dual-1):\n",
    "                axs[0].plot( (x+0.5, x+1.5), (y+0.5, y+0.5), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                axs[0].plot( (x+0.5, x+0.5), (y+0.5, y+1.5), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                \n",
    "                axs[2].plot( (x, x+1.5), (y+0.5, y+0.5), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "                axs[2].plot( (x+0.5, x+0.5), (y+0.5, y+1.5), marker='', lw='0.5', color='gray', alpha=0.5, linestyle='--')\n",
    "    \n",
    "    plot_lattice(be_lattice_for_dual, axs[0], show_clusters=False)\n",
    "    plot_lattice(be_lattice_for_dual, axs[1], show_clusters=False)\n",
    "\n",
    "    if p>0:\n",
    "        plot_dual_lattice(be_lattice_for_dual, axs[0])\n",
    "        plot_dual_lattice(be_lattice_for_dual, axs[2])\n",
    "    \n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monte Carlo percolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "class MC_Square_Lattice:\n",
    "    def __init__(self, L=20):\n",
    "        self.L = L # Lattice side. number of edges in a direction is L-1 \n",
    "        \n",
    "        self.__edges_x__ = np.zeros((L-1, L), dtype='?')\n",
    "        self.__edges_y__ = np.zeros((L, L-1), dtype='?')\n",
    "            \n",
    "        \n",
    "    def open_random_edge(self):\n",
    "        edge_opened = False\n",
    "        \n",
    "        while(not edge_opened):\n",
    "            # Get random direction\n",
    "            direction = np.random.choice(a=[False, True])\n",
    "        \n",
    "            if direction:\n",
    "                # Get random coordinates\n",
    "                x = np.random.randint(low=0, high=self.__edges_x__.shape[0], dtype=int)\n",
    "                y = np.random.randint(low=0, high=self.__edges_x__.shape[1], dtype=int)\n",
    "                \n",
    "                # If the edge is closed then open it\n",
    "                if not self.__edges_x__[x][y]:\n",
    "                    self.__edges_x__[x][y] = True\n",
    "                    edge_opened = True\n",
    "            else:\n",
    "                # Same\n",
    "                x = np.random.randint(low=0, high=self.__edges_y__.shape[0], dtype=int)\n",
    "                y = np.random.randint(low=0, high=self.__edges_y__.shape[1], dtype=int)\n",
    "                \n",
    "                if not self.__edges_y__[x][y]:\n",
    "                    self.__edges_y__[x][y] = True\n",
    "                    edge_opened = True\n",
    "        \n",
    "        return (self.__edges_x__, self.__edges_y__)\n",
    "    \n",
    "    \n",
    "    def __neighrest_neighbour_cluster__(self, x, y):\n",
    "        #if x == self.L-1 or x == 0 or y == self.L-1 or y==0:\n",
    "        #    print(x, y)\n",
    "        #    return True\n",
    "        \n",
    "        # Check the point above (NORTH)\n",
    "        if(y<self.__edges_y__.shape[1] and self.__edges_y__[x][y] and not self.__clusters__[x][y+1]):\n",
    "            self.__clusters__[x][y+1] = True\n",
    "            \n",
    "            if y == self.L-2: return True\n",
    "            elif self.__neighrest_neighbour_cluster__(x, y+1):\n",
    "                return True\n",
    "        \n",
    "        \n",
    "        # Check the point below (SOUTH)\n",
    "        if(self.__edges_y__[x][y-1] and not self.__clusters__[x][y-1]):\n",
    "            self.__clusters__[x][y-1] = True\n",
    "            \n",
    "            if y == 1: return True\n",
    "            elif self.__neighrest_neighbour_cluster__(x, y-1):\n",
    "                return True\n",
    "            \n",
    "        \n",
    "        # Check the point on the left (WEST)        \n",
    "        if(self.__edges_x__[x-1][y] and not self.__clusters__[x-1][y]):\n",
    "            self.__clusters__[x-1][y] = True\n",
    "\n",
    "            if x==1: return True\n",
    "            elif self.__neighrest_neighbour_cluster__(x-1, y):\n",
    "                return True\n",
    "\n",
    "            \n",
    "        # Check the point on the right (EAST)\n",
    "        if(x<self.__edges_x__.shape[0] and self.__edges_x__[x][y] and not self.__clusters__[x+1][y]):\n",
    "            self.__clusters__[x+1][y] = True\n",
    "            \n",
    "            if x== self.L-2: return True\n",
    "            elif self.__neighrest_neighbour_cluster__(x+1, y):\n",
    "                return True\n",
    "        \n",
    "        return False\n",
    "        \n",
    "    \n",
    "    def is_percolating(self):\n",
    "        self.__clusters__ = np.zeros((self.L, self.L), dtype='?')\n",
    "        \n",
    "        # The origin belongs to the cluster of the origin\n",
    "        self.__clusters__[self.L//2][self.L//2] = True\n",
    "        \n",
    "        return self.__neighrest_neighbour_cluster__(self.L//2, self.L//2)\n",
    "    \n",
    "    def get_probability(self):\n",
    "        number_of_open_edges = np.sum(self.__edges_x__) + np.sum(self.__edges_y__)\n",
    "        number_of_total_edges = self.__edges_x__.shape[0] * self.__edges_x__.shape[1] + \\\n",
    "                                self.__edges_y__.shape[0] * self.__edges_y__.shape[1]\n",
    "        return number_of_open_edges/number_of_total_edges"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "source": [
    "%%html\n",
    "<style>\n",
    "    .jp-OutputArea-child {\n",
    "        display: inline-block;\n",
    "    }\n",
    "</style>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "source": [
    "L = 7; mc_sl = MC_Square_Lattice(L=L)\n",
    "\n",
    "percolating = False\n",
    "while(not percolating):\n",
    "    mc_sl.open_random_edge()\n",
    "    percolating = mc_sl.is_percolating()\n",
    "\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(3, 3))\n",
    "    fig.patch.set_facecolor('xkcd:mint green')\n",
    "    \n",
    "    ax.axis(\"on\"); ax.set_xlim(-0.5, L-0.5); ax.set_ylim(-0.5, L-0.5)\n",
    "    ax.set_xticks(range(L)); ax.set_yticks(range(L))\n",
    "    rectangle = plt.Rectangle((0,0), L-1, L-1, alpha=0.5)\n",
    "    ax.add_patch(rectangle)\n",
    "    \n",
    "    plt.plot(L//2, L//2, marker=\"*\", markersize=20)\n",
    "    for x in range(mc_sl.__edges_x__.shape[0]):\n",
    "        for y in range(mc_sl.__edges_x__.shape[1]):\n",
    "            if(mc_sl.__edges_x__[x][y]):\n",
    "                ax.annotate(f\"({x},{y})\", (x+0.1, y+0.1), fontsize=7)\n",
    "                plot_edge(x=x, y=y, ax=ax, cluster_id=2 if mc_sl.__clusters__[x+1][y] else 0, direction='x')\n",
    "\n",
    "    for x in range(mc_sl.__edges_y__.shape[0]):\n",
    "        for y in range(mc_sl.__edges_y__.shape[1]):\n",
    "            if(mc_sl.__edges_y__[x][y]):\n",
    "                ax.annotate(f\"({x},{y})\", (x+0.1, y+0.1), fontsize=7)\n",
    "                plot_edge(x=x, y=y, ax=ax, cluster_id=2 if mc_sl.__clusters__[x][y+1] else 0, direction='y')\n",
    "\n",
    "    ax.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "649e8a9e33894ae4986a05a19014cfe8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='n_runs', options=(10, 100, 1000), value=10), IntSlider(value=10, d…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tqdm.notebook import trange, tqdm\n",
    "# https://rstudio-pubs-static.s3.amazonaws.com/241232_eebe419a0aaa4eb89398ee2a61ad3dc2.html\n",
    "\n",
    "def monete_carlo_run(L):\n",
    "    mc_sl = MC_Square_Lattice(L)\n",
    "    \n",
    "    while(not mc_sl.is_percolating()):\n",
    "        mc_sl.open_random_edge()\n",
    "    \n",
    "    return mc_sl.get_probability()\n",
    "\n",
    "@widgets.interact_manual(n_runs=[10, 100, 1000], L=(10, 100, 10))\n",
    "def pc_graph(n_runs=10, L=10):\n",
    "    n_bins = 100\n",
    "    n_runs = int(n_runs)\n",
    "    theta_esteems = np.zeros(n_bins)\n",
    "    pc_esteems = np.zeros(n_bins)\n",
    "    x = np.linspace(0, 1, n_bins)\n",
    "    \n",
    "    pc = 0\n",
    "    pc2 = 0 #square for confidence interval\n",
    "\n",
    "    for i in tqdm(range(n_runs)):\n",
    "        pc_esteem = monete_carlo_run(L=L)\n",
    "        bin_ = int(pc_esteem*n_bins)\n",
    "        theta_esteems[bin_:]+=1\n",
    "        pc_esteems[bin_]+=1\n",
    "        \n",
    "        pc +=pc_esteem\n",
    "        pc2 += pc_esteem**2\n",
    "\n",
    "    theta_esteems /= n_runs\n",
    "    pc = pc/n_runs\n",
    "    std = np.sqrt(pc2/n_runs - pc**2)\n",
    "    sigma = 1.96*std/np.sqrt(n_runs)\n",
    "    significant_figures = int(-1*np.log10(sigma)+1)\n",
    "    \n",
    "    sigma = np.round(sigma, significant_figures)\n",
    "    pc = np.round(pc, significant_figures)\n",
    "    \n",
    "    fig, axs = plt.subplots(nrows=2, ncols=1, figsize=(10, 7), height_ratios=[3, 1])\n",
    "    fig.patch.set_facecolor('xkcd:mint green')\n",
    "    axs[0].set_xlabel(r\"p\"); axs[1].set_xlabel(r\"p\")\n",
    "    axs[0].set_ylabel(r\"$\\theta(p)$\"); axs[1].set_ylabel(r\"$p_c$ counts\")\n",
    "    axs[0].set_xticks([tick/10 for tick in range(10)]); axs[0].set_yticks([tick/10 for tick in range(10)])\n",
    "    axs[0].grid('on'); axs[1].grid('on')\n",
    "    \n",
    "    # Plot verical line corresponding to esteem of pc\n",
    "    axs[0].axvspan(pc-sigma, pc+sigma, alpha=0.1, color='r')\n",
    "    axs[0].vlines(x=pc, ymin=0, ymax=1, color='r', linestyle=\"--\", label=f\"$p_c\\simeq {pc} \\pm {sigma}$\", alpha=0.7)\n",
    "        \n",
    "    axs[1].vlines(x=pc, ymin=0, ymax=max(pc_esteems), color='r', linestyle=\"--\", label=f\"$p_c\\simeq$ {pc}\", alpha=0.5)\n",
    "    axs[1].axvspan(pc-sigma, pc+sigma, alpha=0.1, color='r')\n",
    "    \n",
    "    # Plot theta(p)\n",
    "    axs[0].plot(x, theta_esteems, marker='.', label=r\"$\\theta(p)$\")\n",
    "    axs[1].plot(x, pc_esteems, marker='.', label=r\"$p_c$ counts\")\n",
    "    \n",
    "    axs[0].set_xlim([0, 1])\n",
    "    axs[0].legend(loc='upper left')\n",
    "    axs[1].legend(loc='upper left')\n",
    "    \n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "provenance": []
  },
  "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.11.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}