{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dee889ee",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "reliability",
     "11"
    ]
   },
   "source": [
    "# Parallel computing and reusing realizations\n",
    "\n",
    "In this example, we demonstrate two features of the library that help reduce calculation time:\n",
    "* Parallel computing – a method of performing multiple calculations simultaneously to improve efficiency.\n",
    "* Reusing realizations – avoiding redundant computations by utilizing previously generated realizations.\n",
    "\n",
    "We apply these features to calculate the probability of levee failure due to wave overtopping.\n",
    "\n",
    "First, we import the necessary packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6bf2b9f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from probabilistic_library import ReliabilityProject, DistributionType, ReliabilityMethod\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6290a8ca",
   "metadata": {},
   "source": [
    "We consider a limit state function for wave overtopping (which we have artificially slowed down):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7e65369d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.models import ZFunctionOvertopping"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11302453",
   "metadata": {},
   "source": [
    "And the following project, in which we apply the `crude_monte_carlo` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "29284d44",
   "metadata": {},
   "outputs": [],
   "source": [
    "def define_project():\n",
    "\n",
    "    project = ReliabilityProject()\n",
    "    project.model = ZFunctionOvertopping.z_sleep\n",
    "    \n",
    "    project.variables[\"h\"].distribution = DistributionType.log_normal\n",
    "    project.variables[\"h\"].mean = 1.5\n",
    "    project.variables[\"h\"].deviation = 0.05\n",
    "\n",
    "    project.variables[\"hm0\"].distribution = DistributionType.log_normal\n",
    "    project.variables[\"hm0\"].mean = 1.5\n",
    "    project.variables[\"hm0\"].deviation = 0.25\n",
    "\n",
    "    project.variables[\"tm10\"].distribution = DistributionType.log_normal\n",
    "    project.variables[\"tm10\"].mean = 3\n",
    "    project.variables[\"tm10\"].deviation = 0.5\n",
    "\n",
    "    project.variables[\"wave_direction\"].distribution = DistributionType.deterministic\n",
    "    project.variables[\"wave_direction\"].mean = 0.0\n",
    "\n",
    "    project.variables[\"dike_normal\"].distribution = DistributionType.deterministic\n",
    "    project.variables[\"dike_normal\"].mean = 0.0\n",
    "\n",
    "    project.variables[\"y_crest\"].distribution = DistributionType.deterministic\n",
    "    project.variables[\"y_crest\"].mean = 6.0\n",
    "\n",
    "    project.variables[\"q_crit\"].distribution = DistributionType.log_normal\n",
    "    project.variables[\"q_crit\"].mean = 0.001\n",
    "    project.variables[\"q_crit\"].deviation = 0.01\n",
    "\n",
    "    project.settings.reliability_method = ReliabilityMethod.crude_monte_carlo\n",
    "    project.settings.minimum_samples = 1000\n",
    "    project.settings.maximum_samples = 1000\n",
    "    project.settings.variation_coefficient = 0.02\n",
    "\n",
    "    return project"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6acef4c",
   "metadata": {},
   "source": [
    "### Parallel computing\n",
    "\n",
    "If not specified, the calculations are performed on a single processor. To utilize multiple processors, we adjust the setting `project.settings.max_parallel_processes`. \n",
    "\n",
    "With the following code, we analyze the effect of parallel computing on the calculation time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba79727",
   "metadata": {
    "tags": [
     "gallery",
     "reliability"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max parallel processes: 1\n",
      "Time elapsed: 100.65113615989685 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.227\n",
      " Probability of failure = 0.11\n",
      " Convergence = 0.08995 (not converged)\n",
      " Model runs = 1001\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = -0.04342, x = 1.502\n",
      " hm0: alpha = -0.3716, x = 1.596\n",
      " tm10: alpha = -0.6051, x = 3.346\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.7027, x = 1.562e-05\n",
      "\n",
      "Max parallel processes: 4\n",
      "Time elapsed: 25.75580382347107 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.227\n",
      " Probability of failure = 0.11\n",
      " Convergence = 0.08995 (not converged)\n",
      " Model runs = 1001\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = -0.04342, x = 1.502\n",
      " hm0: alpha = -0.3716, x = 1.596\n",
      " tm10: alpha = -0.6051, x = 3.346\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.7027, x = 1.562e-05\n",
      "\n",
      "Max parallel processes: 8\n",
      "Time elapsed: 13.256065130233765 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.227\n",
      " Probability of failure = 0.11\n",
      " Convergence = 0.08995 (not converged)\n",
      " Model runs = 1001\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = -0.04342, x = 1.502\n",
      " hm0: alpha = -0.3716, x = 1.596\n",
      " tm10: alpha = -0.6051, x = 3.346\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.7027, x = 1.562e-05\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Elapsed time (s)')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_parallel_processes = [1, 4, 8]\n",
    "elapsed = []\n",
    "\n",
    "for val in max_parallel_processes:\n",
    "\n",
    "    project = define_project()\n",
    "    project.settings.max_parallel_processes = val\n",
    "\n",
    "    t = time.time()\n",
    "    project.run()\n",
    "    elapsed.append(time.time() - t)\n",
    "    \n",
    "    print(f\"Max parallel processes: {val}\")\n",
    "    print(f\"Time elapsed: {elapsed[-1]} seconds\")\n",
    "\n",
    "    project.design_point.print()\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(max_parallel_processes, elapsed, 'o--')\n",
    "plt.grid()\n",
    "plt.xlabel('Max parallel processes (#)')\n",
    "plt.ylabel('Elapsed time (s)')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5117b55b",
   "metadata": {},
   "source": [
    "### Reusing realizations\n",
    "\n",
    "Another useful feature of the library is the ability to reuse realizations - this is possible if the project is not redefined when it is run again.\n",
    "\n",
    "This functionality is particularly valuable in sensitivity analyses (if multiple model outputs are required). It is also beneficial when applying the Crude Monte Carlo method in reliability analysis. For instance, if a calculation is first performed with $200$ samples and later extended to $250$ samples, the initial $200$ samples are reused in the second run, avoiding unnecessary recomputation. \n",
    "\n",
    "This is demonstrated in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5701b1dc",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial run\n",
      "Time elapsed: 20.227248907089233 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.254\n",
      " Probability of failure = 0.105\n",
      " Convergence = 0.2064 (not converged)\n",
      " Model runs = 201\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = 0.01244, x = 1.498\n",
      " hm0: alpha = -0.4622, x = 1.629\n",
      " tm10: alpha = -0.5703, x = 3.331\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.679, x = 1.599e-05\n",
      "\n",
      "Run repeated\n",
      "Time elapsed: 0.0009968280792236328 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.254\n",
      " Probability of failure = 0.105\n",
      " Convergence = 0.2064 (not converged)\n",
      " Model runs = 0\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = 0.01244, x = 1.498\n",
      " hm0: alpha = -0.4622, x = 1.629\n",
      " tm10: alpha = -0.5703, x = 3.331\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.679, x = 1.599e-05\n",
      "\n",
      "Additional 50 runs\n",
      "Time elapsed: 5.025488615036011 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.305\n",
      " Probability of failure = 0.096\n",
      " Convergence = 0.1941 (not converged)\n",
      " Model runs = 50\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = 0.003841, x = 1.499\n",
      " hm0: alpha = -0.3906, x = 1.61\n",
      " tm10: alpha = -0.5775, x = 3.352\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.7169, x = 1.334e-05\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project = define_project()\n",
    "samples = [200, 200, 250]\n",
    "run_message = [\"Initial run\", \"Run repeated\", \"Additional 50 runs\"]\n",
    "\n",
    "for id in range(3):\n",
    "    project.settings.minimum_samples = samples[id]\n",
    "    project.settings.maximum_samples = samples[id]\n",
    "\n",
    "    t = time.time()\n",
    "    project.run()\n",
    "    elapsed = time.time() - t\n",
    "\n",
    "    print(f\"{run_message[id]}\")\n",
    "    print(f\"Time elapsed: {elapsed} seconds\")\n",
    "\n",
    "    project.design_point.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09a2ed88",
   "metadata": {},
   "source": [
    "It is also possible to disable the reuse of realizations by setting the `project.settings.reuse_calculations` property. This can be done as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "72855da4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Additional 50 runs\n",
      "Time elapsed: 25.2289559841156 seconds\n",
      "Reliability:\n",
      " Reliability index = 1.305\n",
      " Probability of failure = 0.096\n",
      " Convergence = 0.1941 (not converged)\n",
      " Model runs = 251\n",
      "Alpha values:\n",
      " self: alpha = 0, x = 0\n",
      " h: alpha = 0.003841, x = 1.499\n",
      " hm0: alpha = -0.3906, x = 1.61\n",
      " tm10: alpha = -0.5775, x = 3.352\n",
      " wave_direction: alpha = 0, x = 0\n",
      " dike_normal: alpha = 0, x = 0\n",
      " y_crest: alpha = 0, x = 6\n",
      " q_crit: alpha = 0.7169, x = 1.334e-05\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project.settings.reuse_calculations = False\n",
    "\n",
    "project.settings.minimum_samples = samples[-1]\n",
    "project.settings.maximum_samples = samples[-1]\n",
    "\n",
    "t = time.time()\n",
    "project.run()\n",
    "elapsed = time.time() - t\n",
    "\n",
    "print(f\"{run_message[id]}\")\n",
    "print(f\"Time elapsed: {elapsed} seconds\")\n",
    "\n",
    "project.design_point.print()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.12.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}