sixteen_pier_capacity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run -i one_bridge_geometry.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bridge_component = input() #arch, pier, foundation, no matter lower/upper case\n",
    "print(bridge_component)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://www.freecodecamp.org/news/python-switch-statement-switch-case-example/\n",
    "#https://www.geeksforgeeks.org/check-multiple-conditions-in-if-statement-python/\n",
    "if bridge_component == 'pier':\n",
    "    %store -r pier_capacity_geometry_variables\n",
    "    capacity_geometry_variables = pier_capacity_geometry_variables\n",
    "elif bridge_component == 'arch':\n",
    "    %store -r arch_capacity_geometry_variables\n",
    "    capacity_geometry_variables = arch_capacity_geometry_variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(capacity_geometry_variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://www.geeksforgeeks.org/python-string-concatenation/\n",
    "#https://www.datacamp.com/tutorial/case-conversion-python\n",
    "b=capacity_geometry_variables[\"\".join([\"b\",\"_\",bridge_component.lower()])] #https://www.w3schools.com/python/python_dictionaries_access.asp\n",
    "t=capacity_geometry_variables[\"\".join([\"t\",\"_\",bridge_component.lower()])]\n",
    "e=capacity_geometry_variables[\"\".join([\"e\",\"_\",bridge_component.lower()])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#if arch masonry = pier masonry, then masonry_compressive_resistance_realisations are the same\n",
    "#in the latter, if arch_capacity has already run, there is no need to run the below statement\n",
    "# %run -i three_compressive_resistance_sampling.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store -r compressive_resistance_realisations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Rc=compressive_resistance_realisations\n",
    "# type(Rc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Rc = compressive_resistance_realisations\n",
    "# Rc = np.random.normal(100, 20, 100_000) #to run the code with fake Rc realisations during implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run -i fifteen_pier_condition_factor.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store -r condition_factor\n",
    "%store -r pier_local_scour_depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deterministic_coefficient = 0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def determine_compressive_capacity():\n",
    "\n",
    "    for i in range(len(condition_factor[0])):\n",
    "        compressive_capacity = deterministic_coefficient * condition_factor[0][i] * (Rc*1000*b*(t-2*e)) #https://en.wikipedia.org/wiki/Normal_distribution#Operations_on_a_single_normal_variable\n",
    "        pier_compressive_capacity.append(compressive_capacity)\n",
    "    \n",
    "    print(pier_compressive_capacity[0:5])\n",
    "\n",
    "    return pier_compressive_capacity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "determine_compressive_capacity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pier_compressive_capacity = pd.DataFrame(pier_compressive_capacity)\n",
    "#https://www.geeksforgeeks.org/create-a-pandas-dataframe-from-lists/\n",
    "#https://stackoverflow.com/questions/48864746/replicating-excel-calculation-in-python-dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pier_compressive_capacity.insert(0, \"scour depth\", pier_local_scour_depth[0], True) \n",
    "df_pier_compressive_capacity.insert(1, \"condition factor\", condition_factor[0], True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pier_compressive_capacity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store df_pier_compressive_capacity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#to check if df_arch_compressive_capacity is stored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_mean = [] #calculation of mean value of capacity realisations for each investigated condition factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_vector = np.array(pier_compressive_capacity)  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of capacity pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pier_compressive_capacity_mean_calculation():\n",
    "    \n",
    "    for i in range(len(pier_compressive_capacity_vector)):\n",
    "        pier_compressive_capacity_vector_mean = np.mean(pier_compressive_capacity_vector[i])\n",
    "        pier_compressive_capacity_mean.append(pier_compressive_capacity_vector_mean)\n",
    "    \n",
    "    return pier_compressive_capacity_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_mean_calculation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_std=[] #calculation of std value of capacity realisations for each investigated condition factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pier_compressive_capacity_std_calculation():\n",
    "    \n",
    "    for i in range(len(pier_compressive_capacity_vector)):\n",
    "        pier_compressive_capacity_vector_std = np.std(pier_compressive_capacity_vector[i])\n",
    "        pier_compressive_capacity_std.append(pier_compressive_capacity_vector_std)\n",
    "    \n",
    "    return pier_compressive_capacity_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_std_calculation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_indexes = (np.array(pier_local_scour_depth) > 1.00).nonzero() #https://stackoverflow.com/questions/16094563/numpy-get-index-where-value-is-true\n",
    "first_example_indexes = example_indexes[1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_pdf_input = np.linspace(pier_compressive_capacity_mean[first_example_indexes]-3*pier_compressive_capacity_std[first_example_indexes], pier_compressive_capacity_mean[first_example_indexes]+3*pier_compressive_capacity_std[first_example_indexes], len(Rc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pier_compressive_capacity_pdf = scipy.stats.norm.pdf(pier_compressive_capacity_pdf_input, pier_compressive_capacity_mean[first_example_indexes], pier_compressive_capacity_std[first_example_indexes])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(pier_compressive_capacity_pdf_input, pier_compressive_capacity_pdf, color='black')\n",
    "plt.xlabel(\"Compressive resistance force\")\n",
    "plt.ylabel(\"Probability density\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "ad2bdc8ecc057115af97d19610ffacc2b4e99fae6737bb82f5d7fb13d2f2c186"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}