{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "# Component reliability, Part 2\n", "\n", "
\n", "

\n", "Task 0:\n", "Tasks to complete during the workshop are provided in boxes like this.\n", "

\n", "
\n", "
\n", "
\n", "

\n", "Explanations in the solution are provided in boxes like this.\n", "

\n", "
\n", "
\n", "Note to students in offshore renewables or floating structures: students in the dikes, dams and breakwaters unit have already done worked with this limit-state function and design scenario, so we encourage you to join a group of students from that unit!!! \n", "
\n", "
\n", "In this workshop, we will perform a reliability analysis of a hydraulic engineering problem: the reliability sea dike against wave overtopping. You can see videos of this process here! If the overtopping discharge is too great, or occurs for too long, the dike will erode and lead to flooding of the polder. This is not good, so we try and prevent it by making sure the probability of exceeding the overtopping capacity of the dike is small. We perform the analysis using the van der Meer equation, which calculates discharge [L/m/s] based on wave characteristics and freeboard, the vertical distance between the top of the dike and the still water level (the water level not considering waves).\n", "
\n", "\n", "The hydraulic boundary conditions are important for this calculation, because in coastal environments there are two main loads to consider: waves and wind setup. Waves are defined by their significant wave height and period, and are generated by a strong wind blowing over a large distance (the fetch). Wind setup occurs in shallow areas, where the wind \"pushes\" water up against the shore, causing an increase in the still water level. Both of these loads are dependent on the wind speed and water depth. We calculate waves using the Brettschneider equations, and setup using a simple 1D model. In summary the calculation process is as follows:\n", "\n", "- estimate: dike crest height, average elevation of the sea bottom offshore of the dike (the foreshore), still water level due to tides\n", "- estimate the wind speed, ideally using a probability distribution (extreme value!)\n", "- calculate the wave conditions\n", "- calculate the wind setup\n", "- calculate the overtopping discharge\n", "\n", "This has been implemented in the function `overtopping_discharge` in the attached file `utilities.py`. Some preliminary work has already been done for you by defining the design values for some of the parameters in the equations. Your task is to calculate and interpret the reliability of the dike against overtopping by setting up a MCS and FORM analysis using the following random variables:\n", "\n", "| Variable | Name | Marginal distribution | Mean | c.o.v | \n", "| --- | --- | --- | --- | --- |\n", "| $ob$ | Bottom elevation [m+NAP] | Normal | -2.0 | 0.15 |\n", "| $h$ | Water surface elevation [m+NAP] | Normal | +2.0 | 0.10 |\n", "| $u_{10}$ | Wind speed [m/s] | WeibullMin | 15.1 | 0.48 |\n", "\n", "Note that you should define the WeibullMin distribution as WeibullMin(17, 2.2) using OpenTURNS (the inputs are the shape and scale parameters).the water surface elevation assumes a high tide situation, and the normal distribution represents the variability in high tide elevation observed throughout the year.\n", "\n", "We know that there are two main hydraulic loads, caused by the wind, which govern overtopping discharge: wind setup and waves. Both of these are also dependent on the water depth, $d=h-ob$.The figure below illustrates the magnitude of each, as a function of the water depth for the 95th percentile wind speed.\n", "\n", "![loads](./WS_03_figures/water_depth_loads.JPG \"Effect of water depth on hydraulic loads.\")\n", "\n", "We can see that both effects have opposite relationships to water depth. Since both effects are also proportional to the overtopping discharge, it becomes difficult to establish what the \"critical case\" is to use in our dike design. Probabilistic methods can help us (by integrating across all combinations of loads), but in the end we still need to determine one set of design values which we will use to actually build the dike (in this case, freeboard). Finding an answer to this question and understanding the role of uncertainty in the solution is one of the main themes of this workshop." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

\n", "Task 1:\n", "There are at least two critical cases to consider for this problem. Imagine you are performing a deterministic analysis (but are still acknowledging that a few variables are random). List at least two design cases (qualitatively) and describe how you might select the load values to use in your overtopping calculation. Justify your decision.\n", "\n", "

\n", "Hint: the design cases can be specified in terms of high or low values of wave height and setup, along with the associated water depth. The load values are the random variables, which should be described as percentiles.\n", "
" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

\n", "The two cases are: 1) large waves with smaller setup (deeper water), and 2) large setup with smaller waves (shallower water). The design loads should be selected based on the maximum allowable failure probability. If we need a failure probability of 0.001, we could choose the 90th percentile for each random variable (0.1$^3$=0.001).\n", "

\n", " There are two things to note here: 1) there are infinite combinations of design variable exceedance values that could lead to the same joint exceedance probability, and 2) if we can identify the most critical cases, we might get close to the actual failure probability. If we consider all failure cases and sum them up, we will asymptotically approach the real failure probability, i.e., integrating over the failure region! (caveat: this only works for joint exceedance cases; in other words, only load variables; for combinations of loads, we need to do FORM or MCS because they are capable of evaluating this more complicated failure region).\n", "

\n", "We call this a 'semi-probabilistic' analysis because we use probability to derive the design values for one or more 'critical cases', but don't consider 'all' of the combinations (i.e., we don't integrate across the failure region!).\n", "

" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now let's get our Python packages set up." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.cm as cm\n", "from scipy.optimize import fsolve # for plotting the LSF" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "The reliability analyses (FORM and MCS) will be performed using [OpenTURNS](https://openturns.github.io). Remember, there is a tutorial in the Probabilistic Design chapter of the HOS online textbook." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import openturns as ot\n", "import openturns.viewer as viewer\n", "ot.Log.Show(ot.Log.NONE)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We also have a few custom methods in `utilities.py`:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from utilities import *" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\u001b[1;31mSignature:\u001b[0m \u001b[0movertopping_discharge\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbottom\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mu10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mDocstring:\u001b[0m\n", "Calculate overtopping discharge from wave and freeboard\n", "\n", "An empirical equation that is set up here to use the wave conditions from\n", "bretschneider() function. Many variables are hard-coded in this function\n", "for use in the HOS prob design unit exercise. Returns discharge as a\n", "volumetric flow per unit length of dike.\n", "\n", "EurOtop equation 5.10 & 5.11.\n", "\n", "Arguments:\n", "bottom: elevation of water body bottom [m + NAP]\n", "h: elevation of water body surface [m + NAP]\n", "u10: wind speed [m/s]\n", "\n", "Returns:\n", "qload: overtopping discharge [L/m/s]\n", "\u001b[1;31mFile:\u001b[0m c:\\users\\rlanzafame\\code\\tudelft-citg\\hos-prob-design\\book\\workshops\\utilities.py\n", "\u001b[1;31mType:\u001b[0m function\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "overtopping_discharge?" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

\n", "Task 2:\n", "Define the three random variables as OpenTURNS distributions, then check whether you can evaluate the limit-state function properly by evaluating the overtopping discharge at the 90th percentile value of each random variable. Based only on this calculation, what do you think the probability of exceedance is for this overtopping discharge?\n", "\n", "

\n", "Hint: think about the exceedance probability of each random variable and the dependence between them.\n", "
" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Discharge computed with 10% probability of exceedance for each RV:\n", " q = 2.56e-03 [L/m/s]\n" ] } ], "source": [ "u10 = ot.WeibullMin(17, 2.2)\n", "ob = ot.Normal(-2, 0.3)\n", "h = ot.Normal(2, 0.2)\n", "q_result = overtopping_discharge(ob.computeInverseSurvivalFunction(.1)[0],\n", " h.computeInverseSurvivalFunction(.1)[0],\n", " u10.computeInverseSurvivalFunction(.1)[0])\n", "print('Discharge computed with 10% probability of exceedance for each RV:\\n',\n", " f' q = {q_result:0.2e} [L/m/s]')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", " \n", "The solution is in the code cell above. Regarding the exceedance probability: it is reasonable to assume that the three random variables are independent, since they don't really have any physical relationship with each other. Therefore the probability of exceeding this overtopping discharge can be estimated as $0.1^3=0.001$. It may surprise you that the discharge is small. That's ok, because it's only one case...if we looked at *all* cases, we would see larger discharge values (more rare combinations of loads) and that the summing of them together starts to approach the failure probability calculated below.\n", " \n", "
\n", "\n", "
" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

\n", "Task 3:\n", "Define the limit-state function (incorporating the maximum allowable discharge of $q=1$ [L/m/s]), multivariate probability distribution and set up the OpenTURNS analysis and solve the reliability problem using MCS and FORM.\n", "

\n", "
" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

\n", "The solution is in the code cell below.\n", "

" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "FORM result, pf = 0.0185\n", "FORM result, beta = 2.086\n", "\n", "The design point in the u space: [0.111151,0.127742,2.07923]\n", "The design point in the x space: [-1.96665,2.02555,31.8292]\n", "pf for MCS: 0.0202\n" ] } ], "source": [ "def myLSF(x):\n", " ''' \n", " Vectorized limit-state function.\n", "\n", " Arguments:\n", " x: vector. x=[u10, ob, h]. \n", " '''\n", " q_max = 1\n", " g = [q_max - overtopping_discharge(x[0], x[1], x[2])]\n", " return g\n", "\n", "# Definition of the dependence structure: here, multivariate normal with correlation coefficient rho between two RV's.\n", "R = ot.CorrelationMatrix(3) \n", "multinorm_copula = ot.NormalCopula(R)\n", "\n", "inputDistribution = ot.ComposedDistribution((ob, h, u10), multinorm_copula)\n", "inputDistribution.setDescription([\"ob\", \"h\", \"u_10\"])\n", "inputRandomVector = ot.RandomVector(inputDistribution)\n", "\n", "myfunction = ot.PythonFunction(3, 1, myLSF)\n", "\n", "# Vector obtained by applying limit state function to X1 and X2\n", "outputvector = ot.CompositeRandomVector(myfunction, inputRandomVector)\n", "\n", "# Define failure event: here when the limit state function takes negative values\n", "failureevent = ot.ThresholdEvent(outputvector, ot.Less(), 0)\n", "failureevent.setName('LSF inferior to 0')\n", "\n", "optimAlgo = ot.Cobyla()\n", "optimAlgo.setMaximumEvaluationNumber(100000)\n", "optimAlgo.setMaximumAbsoluteError(1.0e-10)\n", "optimAlgo.setMaximumRelativeError(1.0e-10)\n", "optimAlgo.setMaximumResidualError(1.0e-10)\n", "optimAlgo.setMaximumConstraintError(1.0e-10)\n", "\n", "# Starting point for FORM\n", "start_pt = []\n", "\n", "algo = ot.FORM(optimAlgo, failureevent, inputDistribution.getMean()) # Maybe change 3rd argument and put start_pt defined above\n", "algo.run()\n", "result = algo.getResult()\n", "x_star = result.getPhysicalSpaceDesignPoint() # Design point: original space\n", "u_star = result.getStandardSpaceDesignPoint() # Design point: standard normal space\n", "pf = result.getEventProbability() # Failure probability\n", "beta = result.getHasoferReliabilityIndex() # Reliability index\n", "print('FORM result, pf = {:.4f}'.format(pf))\n", "print('FORM result, beta = {:.3f}\\n'.format(beta))\n", "print('The design point in the u space: ', u_star)\n", "print('The design point in the x space: ', x_star)\n", "\n", "montecarlosize = 10000\n", "outputSample = outputvector.getSample(montecarlosize)\n", "\n", "number_failures = sum(i < 0 for i in np.array(outputSample))[0] # Count the failures, i.e the samples for which g(x)<0\n", "pf_mc = number_failures/montecarlosize # Calculate the failure probability \n", "\n", "print('pf for MCS: ', pf_mc)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "
\n", "

\n", "Task 4:\n", "Interpret the reliability analyses. Be sure to consider: pf, beta, the design point in the x and u space, linearity of the limit-state function, importance and sensitivity.\n", "

\n", "
" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

\n", "Let's first print and calculate a few of the additional results:\n", "

" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Importance factors\n", "\n", "As presented in the lecture, the importance factors are useful to rank each variable's contribution to the realization of the event. \n", "\n", "OpenTURNS offers built-in methods to compute the importance factors and display them:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ob : 0.0028389, h : 0.00374968, u_10 : 0.993411]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "class=Graph name=Unnamed implementation=class=GraphImplementation name=Unnamed title=Importance Factors from Design Point - LSF inferior to 0 xTitle= yTitle= axes=OFF grid=OFF legendposition= legendFontSize=1 drawables=[class=Drawable name=Unnamed implementation=class=Pie name=Unnamed labels=[ob : 0.3%,h : 0.4%,u_10 : 99.3%] radius=1 center=class=Point name=Unnamed dimension=2 values=[0,0] color palette=[#1f77b4,#ff7f0e,#2ca02c] derived from class=DrawableImplementation name=Unnamed legend= data=class=Sample name=Unnamed implementation=class=SampleImplementation name=Unnamed size=3 dimension=1 data=[[0.0028389],[0.00374968],[0.993411]] color=blue fillStyle=solid lineStyle=solid pointStyle=plus lineWidth=1]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "alpha_ot = result.getImportanceFactors()\n", "print(alpha_ot)\n", "result.drawImportanceFactors()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We also compute the importance factors as they are defined in your textbook in order to compare them. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The importance factors as defined in the textbook are: [0.0532813,0.0612346,0.9967]\n" ] } ], "source": [ "alpha = u_star/beta\n", "print(\"The importance factors as defined in the textbook are: \", alpha)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Sensitivity factors\n", "\n", "We can also access the sensitivity of the reliability index $\\beta$ with regards to the distribution parameters with the built-in method:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The sensitivity factors of the reliability index with regards to the distribution parameters are:\n", "\n", "[mean_0_marginal_0 : -0.177604, standard_deviation_0_marginal_0 : -0.0197409]\n", "[mean_0_marginal_1 : -0.306173, standard_deviation_0_marginal_1 : -0.0391113]\n", "[beta_marginal_2 : -0.209769, alpha_marginal_2 : 1.0166, gamma_marginal_2 : -0.112038]\n", "[R_2_1_copula : 0, R_3_1_copula : 0, R_3_2_copula : 0]\n" ] } ], "source": [ "sens = result.getHasoferReliabilityIndexSensitivity()\n", "print(\"The sensitivity factors of the reliability index \"\n", " \"with regards to the distribution parameters are:\\n\")\n", "for i in range(sens.getSize()):\n", " print(sens.at(i))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "From the results printed above:\n", "\n", "
" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Graphical Interpretation" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "tags": [] }, "outputs": [], "source": [ "def plot_contour(dis, xlim=(-3, -1), ylim=(1,3), ax=None): \n", " ''' Note: x is a row vector of 2 elements: x[0] is first axis, x[1] second. ''' \n", " if ax is None:\n", " f, ax = plt.subplots(1)\n", " else: \n", " f = plt.gcf() \n", "\n", " x_axis = np.linspace(xlim[0], xlim[1], 100)\n", " y_axis = np.linspace(ylim[0], ylim[1], 100)\n", " # Contour plot\n", " X_grid,Y_grid = np.meshgrid(x_axis, y_axis)\n", " pdf = np.zeros(X_grid.shape)\n", " for i in range(X_grid.shape[0]):\n", " for j in range(X_grid.shape[1]):\n", " pdf[i,j] = dis.computePDF([X_grid[i,j], Y_grid[i,j], x_star[2]]) # Change this\n", " ax.contour(X_grid, Y_grid, pdf, levels=8, cmap=cm.Blues)\n", "\n", " ax.set_xlabel(\"ob\", fontsize=14) # Change labels and title\n", " ax.set_ylabel(\"h\", fontsize=14) # CHange label\n", " ax.plot(x_star[0], x_star[1], 'ro', label=\"Design point\") # Adapt this to rest of WS\n", " \n", " y_ls = [h.getMean()[0]]\n", " \n", " for k in x_axis:\n", " temp_func = lambda h: myLSF(np.array([k, h, x_star[2]]))[0]\n", " y_ls.append(fsolve(temp_func, y_ls[-1])[0]) \n", " \n", " y_ls.pop(0)\n", "\n", " # ylim = ax.get_ylim()\n", " ax.plot(x_axis, y_ls, color=\"k\", label=\"LSF\")\n", " ax.fill_between(x_axis, y_ls, ylim[1], color=\"grey\", label=\"Failure region\")\n", " ax.set_title(r\"Limit state function in the plane $(ob, h)$\", fontsize=18) # CHange title\n", " ax.set_xlim(xlim)\n", " ax.set_ylim(ylim)\n", " ax.legend()\n", " return None\n", "\n", "def p_or(dis, x):\n", " ''' Computes the probability P(X1>x1 OR X1>x2). \n", " \n", " Parameters:\n", " dis : OT ComposedDistribution\n", " x: 1D vector. First and second coordinates contain values of x1 and x2, respectively. \n", " '''\n", " return 1 - dis.computeCDF(x)\n", "\n", "def p_and(dis, x):\n", " ''' Computes the probability P(X1>x1 AND X1>x2). \n", " \n", " Parameters:\n", " dis : OT ComposedDistribution\n", " x: 1D vector. First and second coordinates contain values of x1 and x2, respectively. \n", " '''\n", " X1 = dis.getMarginal(0)\n", " X2 = dis.getMarginal(1)\n", " p = 1 - X1.computeCDF(x[0]) - X2.computeCDF(x[1]) + dis.computeCDF(x)\n", " return p\n", "\n", "def plot_and(dis, x, ax=None, contour=False, xlim=(-3, -1), ylim=(1,3)):\n", " \"\"\" Computes the probability P(X>x,Y>y) and draws the related figure. \"\"\"\n", " if ax is None:\n", " f, ax = plt.subplots(1)\n", " else :\n", " f = plt.gcf()\n", " if contour:\n", " plot_contour(dis, ax=ax, xlim=xlim, ylim=ylim)\n", " if xlim is None:\n", " xlim = () # Complete with default limits\n", " if ylim is None:\n", " ylim = () # Complete with default limits\n", " \n", " ax.vlines(x[0], ymin=ylim[0], ymax=ylim[1], colors='k', linestyles=\"dashed\")\n", " ax.hlines(x[1], xmin=xlim[0], xmax=xlim[1], colors='k', linestyles=\"dashed\")\n", " ax.vlines(x[0], ymin=ylim[0], ymax=ylim[1], colors='k', linestyles=\"dashed\")\n", " ax.hlines(x[1], xmin=xlim[0], xmax=xlim[1], colors='k', linestyles=\"dashed\")\n", " ax.fill_between([x[0], xlim[1]], x[1], ylim[1], color=\"lightgrey\", linewidth=2, edgecolor=\"k\", alpha=1, zorder=0)\n", " ax.axis(\"scaled\")\n", " ax.set_xlim(xlim)\n", " ax.set_ylim(ylim)\n", " p = p_and(dis, [x[0], x[1], x_star[2]])\n", " ax.set_title(\"$p_{AND}$\")\n", " if p<0.01:\n", " ax.text(.01, .01, r\"$(P=$\" + \"{:.2e})\".format(p), ha=\"left\", va=\"bottom\", transform=ax.transAxes)\n", " else: \n", " ax.text(.01, .01, r\"$(P=$\" + \"{:.4f})\".format(p), ha=\"left\", va=\"bottom\", transform=ax.transAxes)\n", " ax.set_xlabel(\"ob\") \n", " ax.set_ylabel(\"h\") \n", " return f, ax\n", "\n", "def plot_or(dis, x, ax=None, contour=False, xlim=(-3,-1), ylim=(1,3)):\n", " \"\"\" Computes the probability P(X>x OR Y>y) and draws the related figure. \"\"\"\n", " if ax is None:\n", " f, ax = plt.subplots(1)\n", " else :\n", " f = plt.gcf()\n", " if contour:\n", " plot_contour(dis, ax=ax, xlim=xlim, ylim=ylim)\n", " if xlim is None:\n", " xlim = () # Complete\n", " if ylim is None:\n", " ylim = () # Complete\n", "\n", " ax.vlines(x[0], ymin=x[1], ymax=ylim[1], colors='k', linestyles=\"dashed\")\n", " ax.hlines(x[1], xmin=x[0], xmax=xlim[1], colors='k', linestyles=\"dashed\")\n", " ax.fill_between(np.array([xlim[0], x[0], x[0], xlim[1]]), np.array([x[1], x[1], ylim[0], ylim[0]]), ylim[1], color='lightgrey', linewidth=2, edgecolor=\"k\", zorder=0) \n", " # ax.axvspan(xlim[0],xlim[1],ylim[0],ylim[1], edgecolor=\"k\", linewidth=4, facecolor=\"None\", zorder=zorder+1)\n", " ax.axis(\"scaled\")\n", " p = p_or(dis, [x[0], x[1], x_star[2]])\n", " ax.set_title(\"$p_{OR}$\")\n", " if p<0.01:\n", " ax.text(.01, .01, r\"$(P=$\" + \"{:.2e})\".format(p), ha=\"left\", va=\"bottom\", transform=ax.transAxes)\n", " else: \n", " ax.text(.01, .01, r\"$(P=$\" + \"{:.4f})\".format(p), ha=\"left\", va=\"bottom\", transform=ax.transAxes)\n", " ax.set_xlabel(\"ob\") # Change\n", " ax.set_ylabel(\"h\") # Change\n", " ax.set_xlim(xlim)\n", " ax.set_ylim(ylim)\n", " return f, ax" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\rlanzafame\\AppData\\Local\\Temp\\ipykernel_15544\\2050744889.py:25: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", " temp_func = lambda h: myLSF(np.array([k, h, x_star[2]]))[0]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_contour(inputDistribution)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "From the figure above:\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "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.9.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }