{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "46ea4f25",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "reliability",
     "6"
    ]
   },
   "source": [
    "# Hybrid reliability methods\n",
    "\n",
    "In this example, we demonstrate the usage of the so-called hybrid reliability methods:\n",
    "* FDIR (`form_then_directional_sampling`) - reliability calculations are first performed using FORM. If FORM does not converge, the calculations are completed using Directional Sampling.\n",
    "* DSFI (`directional_sampling_then_form`) - reliability calculations are initially performed with Directional Sampling, after which FORM is used to re-calculate the design point.\n",
    "\n",
    "### Define model\n",
    "\n",
    "First, let's import the necessary classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c0d851fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from probabilistic_library import ReliabilityMethod, ReliabilityProject, DistributionType"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00bceae",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Next, we define a simple limit state function: \n",
    "\n",
    "$Z = 1.9 - (a+b)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ea8b7c51",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.models import linear_a_b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96d6a96d",
   "metadata": {},
   "source": [
    "### Define reliability project\n",
    "\n",
    "We define the reliability project and the random variables $a$ and $b$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "42d26675",
   "metadata": {},
   "outputs": [],
   "source": [
    "project = ReliabilityProject()\n",
    "project.model = linear_a_b\n",
    "\n",
    "project.variables[\"a\"].distribution = DistributionType.uniform\n",
    "project.variables[\"a\"].minimum = -1\n",
    "project.variables[\"a\"].maximum = 1\n",
    "\n",
    "project.variables[\"b\"].distribution = DistributionType.uniform\n",
    "project.variables[\"b\"].minimum = -1\n",
    "project.variables[\"b\"].maximum = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cd8c1eb",
   "metadata": {},
   "source": [
    "### Run calculations with FORM\n",
    "\n",
    "We begin by running `form` calculations and consider two cases: one with convergence and one without."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ff523bf",
   "metadata": {},
   "source": [
    "### With convergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ea25b24c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reliability (FORM)\n",
      " Reliability index = 2.773\n",
      " Probability of failure = 0.002778\n",
      " Convergence = 0.008383 (converged)\n",
      " Model runs = 126\n",
      "Alpha values:\n",
      " a: alpha = -0.7071, x = 0.9501\n",
      " b: alpha = -0.7071, x = 0.9501\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project.settings.reliability_method = ReliabilityMethod.form\n",
    "project.settings.relaxation_factor = 0.15\n",
    "project.settings.maximum_iterations = 50\n",
    "project.settings.epsilon_beta = 0.01\n",
    "\n",
    "project.run()\n",
    "\n",
    "project.design_point.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca30b4b2",
   "metadata": {},
   "source": [
    "#### Without convergence\n",
    "\n",
    "By reducing the maximum number of iterations, we create a case where `form` does not converge:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "68ded867",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reliability (FORM)\n",
      " Reliability index = 2.348\n",
      " Probability of failure = 0.009427\n",
      " Convergence = 1.224 (not converged)\n",
      " Model runs = 30\n",
      "Alpha values:\n",
      " a: alpha = -0.7071, x = 0.9032\n",
      " b: alpha = -0.7071, x = 0.9032\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project.settings.reliability_method = ReliabilityMethod.form\n",
    "project.settings.relaxation_factor = 0.15\n",
    "project.settings.maximum_iterations = 10\n",
    "project.settings.epsilon_beta = 0.01\n",
    "\n",
    "project.run()\n",
    "\n",
    "project.design_point.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aa82b90",
   "metadata": {},
   "source": [
    "### Calculations with Directional Sampling\n",
    "\n",
    "We also run the reliability calculations with `directional_sampling`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7ac3db34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reliability (Directional Sampling)\n",
      " Reliability index = 3.018\n",
      " Probability of failure = 0.001273\n",
      " Convergence = 0.02 (converged)\n",
      " Model runs = 109683\n",
      "Alpha values:\n",
      " a: alpha = -0.7065, x = 0.967\n",
      " b: alpha = -0.7077, x = 0.9673\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project.settings.reliability_method = ReliabilityMethod.directional_sampling\n",
    "project.settings.variation_coefficient = 0.02\n",
    "project.settings.minimum_directions = 10000\n",
    "project.settings.maximum_directions = 50000\n",
    "\n",
    "project.run()\n",
    "\n",
    "project.design_point.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c42f2630",
   "metadata": {},
   "source": [
    "### Run calculations with FDIR\n",
    "\n",
    "We now perform calculations using `form_then_directional_sampling`.\n",
    "\n",
    "If `form` converges, the results should match the `form` results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "702ae2f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reliability (FORM)\n",
      " Reliability index = 2.773\n",
      " Probability of failure = 0.002778\n",
      " Convergence = 0.008383 (converged)\n",
      " Model runs = 126\n",
      "Alpha values:\n",
      " a: alpha = -0.7071, x = 0.9501\n",
      " b: alpha = -0.7071, x = 0.9501\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project.settings.reliability_method = ReliabilityMethod.form_then_directional_sampling\n",
    "project.settings.relaxation_factor = 0.15\n",
    "project.settings.maximum_iterations = 50\n",
    "project.settings.epsilon_beta = 0.01\n",
    "project.settings.variation_coefficient = 0.02\n",
    "project.settings.minimum_directions = 10000\n",
    "project.settings.maximum_directions = 20000\n",
    "\n",
    "project.run()\n",
    "\n",
    "project.design_point.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9124344",
   "metadata": {},
   "source": [
    "When `form` does not converge, the results should match those of `directional_sampling`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "56af65d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reliability (Directional Sampling)\n",
      " Reliability index = 3.018\n",
      " Probability of failure = 0.001273\n",
      " Convergence = 0.02 (converged)\n",
      " Model runs = 109683\n",
      "Alpha values:\n",
      " a: alpha = -0.7065, x = 0.967\n",
      " b: alpha = -0.7077, x = 0.9673\n",
      "\n",
      "Contributing design points:\n",
      "  Reliability (FORM)\n",
      "   Reliability index = 2.348\n",
      "   Probability of failure = 0.009427\n",
      "   Convergence = 1.224 (not converged)\n",
      "   Model runs = 30\n",
      "  Alpha values:\n",
      "   a: alpha = -0.7071, x = 0.9032\n",
      "   b: alpha = -0.7071, x = 0.9032\n",
      "\n"
     ]
    }
   ],
   "source": [
    "project.settings.reliability_method = ReliabilityMethod.form_then_directional_sampling\n",
    "project.settings.relaxation_factor = 0.15\n",
    "project.settings.maximum_iterations = 10\n",
    "project.settings.epsilon_beta = 0.01\n",
    "project.settings.variation_coefficient = 0.02\n",
    "project.settings.minimum_directions = 10000\n",
    "project.settings.maximum_directions = 50000\n",
    "\n",
    "project.run()\n",
    "\n",
    "project.design_point.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b51fc714",
   "metadata": {},
   "source": [
    "### Calculations with DSFI\n",
    "\n",
    "We now perform reliability calculations using `directional_sampling_then_form`. The resulting reliability index (beta) must match the reliability index calculated with `directional_sampling`. However, the design point is re-calculated using `form` and, therefore, differs from the one obtained with `directional_sampling`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "65ef5535",
   "metadata": {
    "tags": [
     "gallery",
     "reliability"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reliability (Dir. Sampling then FORM)\n",
      " Reliability index = 3.018\n",
      " Probability of failure = 0.001273\n",
      " Model runs = 0\n",
      "Alpha values:\n",
      " a: alpha = -0.7071, x = 0.9499\n",
      " b: alpha = -0.7071, x = 0.9499\n",
      "\n",
      "Contributing design points:\n",
      "  Reliability (Directional Sampling)\n",
      "   Reliability index = 3.018\n",
      "   Probability of failure = 0.001273\n",
      "   Convergence = 0.02 (converged)\n",
      "   Model runs = 109683\n",
      "  Alpha values:\n",
      "   a: alpha = -0.7065, x = 0.967\n",
      "   b: alpha = -0.7077, x = 0.9673\n",
      "\n",
      "  Reliability (FORM)\n",
      "   Reliability index = 2.771\n",
      "   Probability of failure = 0.002798\n",
      "   Convergence = 0.009011 (converged)\n",
      "   Model runs = 54\n",
      "  Alpha values:\n",
      "   a: alpha = -0.7071, x = 0.9499\n",
      "   b: alpha = -0.7071, x = 0.9499\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "project.settings.reliability_method = ReliabilityMethod.directional_sampling_then_form\n",
    "project.settings.relaxation_factor = 0.15\n",
    "project.settings.maximum_iterations = 50\n",
    "project.settings.epsilon_beta = 0.01\n",
    "project.settings.variation_coefficient = 0.02\n",
    "project.settings.minimum_directions = 10000\n",
    "project.settings.maximum_directions = 50000\n",
    "\n",
    "project.run()\n",
    "\n",
    "project.design_point.print()\n",
    "project.design_point.plot_alphas()\n"
   ]
  }
 ],
 "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
}