diff --git a/Pipeline Icing.ipynb b/Pipeline Icing.ipynb index e149316..5801167 100644 --- a/Pipeline Icing.ipynb +++ b/Pipeline Icing.ipynb @@ -2,48 +2,359 @@ "cells": [ { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperatures are in degrees C\n", + "h is in w/m2k\n", + "k is in w2/m2k\n", + "length is in meters\n", + "pipe radius is in cm\n", + "time is in minutes\n" + ] + }, { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c65b8f183b3425f9345db53d2dd2a9f", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "0.4242161224603258" + "interactive(children=(FloatSlider(value=-10.0, description='Fluid_Temp', max=50.0, min=-273.0, step=1.0), Floa…" ] }, - "execution_count": 5, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "from math import log\n", - "Fluid_temp=-10 #F\n", - "Air_temp=25 #C\n", - "Fluid_h=10 #w/m2k\n", - "Water_h=2250 #w/m2k\n", - "Air_h=50 #w/m2k\n", - "Pipe_k=16 #w/m*k\n", - "Pipe_Length=1 #m\n", - "L=Pipe_Length\n", - "Pipe_Radius_Internal=4 #cm\n", - "Ri=Pipe_Radius_Internal\n", - "Pipe_Radius_External=4.2 #cm\n", - "Ro=Pipe_Radius_External\n", - "Tf=Fluid_temp\n", - "Ice_Radius=100 #cm\n", - "Rice=Ice_Radius\n", - "Resistance_fluid= 1/(Fluid_h)*(2)*(3.14159)*(Ri)*(L)\n", - "Resistance_Pipe=(log((Ro/Ri),2.71828))/(2*3.14*Pipe_k*L)\n", - "Resistance_Iceonwall= 1 / (Water_h)*(2)*(3.14159)*(Ro)*(L)\n", - "Resistance_IceExterior= 1 / (Water_h)*(2)*(3.14159)*(Rice)*(L)\n", - "Resistance_AirandIce = 1 / (Air_h)*(2)*(3.14159)*(Rice)*(L)\n", - "Resistance_Total=Resistance_fluid + Resistance_Pipe + Resistance_Iceonwall + Resistance_IceExterior + Resistance_AirandIce\n", - "UA=1/Resistance_Total\n", - "q=(UA)*(Fluid_temp-Air_temp)\n", - "UA_final=1/Resistance_AirandIce\n", - "Temp_Surface=(q/(UA_final))+(Air_temp)\n", - "Temp_Surface" + "from math import sqrt\n", + "from ipywidgets import widgets, interact\n", + "from IPython.display import display\n", + "%matplotlib inline\n", + "import seaborn as sbn\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.core.pylabtools import figsize\n", + "from ipywidgets import widgets, interact\n", + "from IPython.display import display\n", + "%matplotlib inline\n", + "import seaborn as sbn\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.core.pylabtools import figsize\n", + "figsize(12, 10)\n", + "sbn.set_context(\"talk\", font_scale=1)\n", + "figsize(12, 10)\n", + "sbn.set_context(\"talk\", font_scale=1)\n", + "def Rice(Fluid_temp,\n", + " Air_temp,\n", + " Fluid_h,\n", + " Pipe_k,\n", + " Pipe_Radius_Internal,\n", + " Pipe_Radius_External,\n", + " Pipe_Length=1,\n", + " Water_h=2250,\n", + " Air_h=50,\n", + " Tsurf=273.15\n", + " ):\n", + "\n", + " Tair=(Air_temp+273.15)\n", + " WA_h=Air_h/Water_h\n", + " L=Pipe_Length\n", + " Ri=(Pipe_Radius_Internal*0.01) #m\n", + " Ro=(Pipe_Radius_External*0.01) #m\n", + " Tfluid=(Fluid_temp+273.15)\n", + " Resistance_fluid = 1/(Fluid_h)*(2)*(3.14159)*(Ri)*(L)\n", + " Resistance_Pipe=(Ro/Ri)/(2*3.14*Pipe_k)\n", + " Resistance_Iceonwall= 1 / (Water_h)*(2)*(3.14159)*(Ro)*(L)\n", + " Resistance_Sub=Resistance_fluid+Resistance_Pipe+Resistance_Iceonwall\n", + "\n", + " Rice=-100*((WA_h+1)*(Tsurf-Tair)-(Tfluid-Tair))/(((Resistance_Sub)+(Tsurf-Tair))*(Air_h*2*3.14159*L))\n", + " return Rice\n", + "def Rate(Air_temp,\n", + " Fluid_temp,\n", + " time,\n", + " k=2.22,\n", + " roe=1000,\n", + " Hia=10,\n", + " fusion=334 #j\n", + " ):\n", + "\n", + " Tair=(Air_temp+273.15)\n", + " Tfluid=(Fluid_temp+273.15)\n", + " t=(time*30)\n", + "\n", + " Rate=sqrt(((2*k)/(roe*fusion))*(abs(Tfluid-Tair))*t+((k/Hia)*(k/Hia)))-(k/Hia)\n", + " return Rate\n", + "\n", + "print (\"Temperatures are in degrees C\\nh is in w/m2k\\nk is in w2/m2k\\nlength is in meters\\npipe radius is in cm\\ntime is in minutes\")\n", + "@interact(Fluid_Temp=widgets.FloatSlider(value=-10, min=-273, max=50, step=1), \n", + " Air_Temp=widgets.FloatSlider(value=25, min=10, max=100, step=1),\n", + " h_of_Fluid=widgets.FloatSlider(value=10, min=0.1, max=100, step=.1), \n", + " k_of_Pipe=widgets.FloatSlider(value=16, min=0.1, max=100, step=0.1), \n", + " Pipe_R_int=widgets.FloatSlider(value=1, min=0.1, max=20, step=0.1),\n", + " Pipe_R_ext=widgets.FloatSlider(value=1, min=0.1, max=20, step=0.1),\n", + " time=widgets.FloatSlider(value=5, min=0, max=100, step=.5))\n", + "def final(Fluid_Temp,Air_Temp,h_of_Fluid,k_of_Pipe,Pipe_R_int,Pipe_R_ext,time):\n", + " ball = Rice(Fluid_temp = Fluid_Temp,\n", + " Air_temp = Air_Temp,\n", + " Fluid_h = h_of_Fluid,\n", + " Pipe_k = k_of_Pipe,\n", + " Pipe_Radius_Internal = Pipe_R_int,\n", + " Pipe_Radius_External = Pipe_R_ext,\n", + " Pipe_Length = 1,\n", + " Water_h=2250,\n", + " Air_h=50,\n", + " Tsurf=273.15\n", + " )\n", + " growth = Rate(Fluid_temp = Fluid_Temp,\n", + " Air_temp = Air_Temp,\n", + " time = time,\n", + " k=2.22,\n", + " roe=1000,\n", + " Hia=10,\n", + " fusion=334\n", + " )\n", + "\n", + " \n", + " if Pipe_R_int > Pipe_R_ext:\n", + " return print(\"The internal radius cannot be larger that the external radius\")\n", + " if ball>0 and growth0 and growth>=ball:\n", + " return print(\"The current thickness of the ice is {} cm\".format(round(ball, 2)),\"\\nThe max thickness of the ice is {} cm\".format(round(ball, 2)))\n", + " else:\n", + " return print(\"The thickness of the ice is 0 cm\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "number_sims = 1000\n", + "\n", + "# Make some random data in the correct ranges\n", + "mc_Fluid_Temp = np.random.uniform(2.3, 22, number_sims)\n", + "mc_Air_Temp = np.random.uniform(50, 100, number_sims)\n", + "mc_h_of_Fluid = np.random.uniform(0, 80, number_sims)\n", + "mc_k_of_Pipe = np.random.uniform(0, 80, number_sims)\n", + "mc_Ri = np.random.uniform(0.5, 24, number_sims)\n", + "mc_Ro = np.random.uniform(0.5, 24, number_sims)\n", + "\n", + "\n", + "data = np.array((mc_Fluid_Temp, \n", + " mc_Air_Temp, \n", + " mc_h_of_Fluid, \n", + " mc_k_of_Pipe, \n", + " mc_Ri,\n", + " mc_Ro\n", + " ))\n", + "\n", + "y = Rice(mc_Fluid_Temp, \n", + " mc_Air_Temp, \n", + " mc_h_of_Fluid, \n", + " mc_k_of_Pipe, \n", + " mc_Ri,\n", + " mc_Ro\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6, 1000)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import SALib\n", + "from SALib.sample import morris as ms\n", + "from SALib.analyze import morris as ma\n", + "from SALib.plotting import morris as mp\n", + "morris_problem = {\n", + " # There are six variables\n", + " 'num_vars': 7,\n", + " # These are their names\n", + " 'names': ['Fluid_Temp', 'Air_Tem', 'h_of_Fluid', 'k_of_Pipe', 'Pipe_Length', 'Pipe_R_in', 'Pipe_R_ext'],\n", + " # These are their plausible ranges over which we'll move the variables\n", + " 'bounds': [[-273, 50], \n", + " [10, 100], \n", + " [0.1, 100], \n", + " [0.1, 100], \n", + " [0.1, 100], \n", + " [0.1, 20], \n", + " [0.1, 20] \n", + " ],\n", + " # I don't want to group any of these variables together\n", + " 'groups': None\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(80000, 7)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_levels = 4\n", + "grid_jump = 2\n", + "trajectories = int(1e4)\n", + "sample = ms.sample(morris_problem, trajectories, num_levels, grid_jump)\n", + "sample.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(7, 80000)\n", + "[[ 5.00000000e+01 5.00000000e+01 5.00000000e+01 ... -1.65333333e+02\n", + " -1.65333333e+02 -1.65333333e+02]\n", + " [ 1.00000000e+02 1.00000000e+02 4.00000000e+01 ... 4.00000000e+01\n", + " 4.00000000e+01 1.00000000e+02]\n", + " [ 1.00000000e-01 1.00000000e-01 1.00000000e-01 ... 1.00000000e-01\n", + " 1.00000000e-01 1.00000000e-01]\n", + " ...\n", + " [ 6.67000000e+01 6.67000000e+01 6.67000000e+01 ... 6.67000000e+01\n", + " 6.67000000e+01 6.67000000e+01]\n", + " [ 2.00000000e+01 2.00000000e+01 2.00000000e+01 ... 6.73333333e+00\n", + " 6.73333333e+00 6.73333333e+00]\n", + " [ 1.00000000e-01 1.33666667e+01 1.33666667e+01 ... 1.00000000e-01\n", + " 1.00000000e-01 1.00000000e-01]]\n" + ] + } + ], + "source": [ + "print(sample.T.shape)\n", + "print(sample.T)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(80000,)\n", + "[-1.73500773e+00 2.70238019e-03 2.32964176e-03 ... 1.46178038e+01\n", + " 1.46176730e+01 5.41911051e+00]\n" + ] + } + ], + "source": [ + "output = Rice(*sample.T)\n", + "print(output.shape)\n", + "print(output)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Name mu mu_star sigma\n", + "Fluid_Temp - 10.14 10.63 31.56\n", + "Air_Tem - 7.23 9.00 28.41\n", + "h_of_Fluid - 1.16 1.60 13.88\n", + "k_of_Pipe 0.61 0.99 8.74\n", + "Pipe_Length 1.45 2.02 13.94\n", + "Pipe_R_in - 0.09 0.61 6.80\n", + "Pipe_R_ext - 10.49 13.27 34.30\n" + ] + } + ], + "source": [ + "Si = ma.analyze(morris_problem, \n", + " sample, \n", + " output, \n", + " print_to_console=False, \n", + " grid_jump=grid_jump, \n", + " num_levels=num_levels)\n", + "print(\"{:20s} {:>7s} {:>7s} {:>7s}\".format(\"Name\", \"mu\", \"mu_star\", \"sigma\"))\n", + "for name, s1, st, mean in zip(morris_problem['names'], Si['mu'], Si['mu_star'], Si['sigma']):\n", + " print(\"{:20s} {:=7.2f} {:=7.2f} {:=7.2f}\".format(name, s1, st, mean))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1,2)\n", + "mp.horizontal_bar_plot(ax1, Si, param_dict={})\n", + "mp.covariance_plot(ax2, Si, {})" ] }, { diff --git a/Pipeline Icing_heat_transfer_of_fluid.ipynb b/Pipeline Icing_heat_transfer_of_fluid.ipynb new file mode 100644 index 0000000..b7978b7 --- /dev/null +++ b/Pipeline Icing_heat_transfer_of_fluid.ipynb @@ -0,0 +1,495 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-3.6136086249067567" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from math import log\n", + "Fluid_temp=-10 #F\n", + "Air_temp=25 #C\n", + "Fluid_h=10 #w/m2k\n", + "Water_h=2250 #w/m2k\n", + "Air_h=50 #w/m2k\n", + "Pipe_k=16 #w/m*k\n", + "Pipe_Length=1 #m\n", + "L=Pipe_Length\n", + "Pipe_Radius_Internal=4 #cm\n", + "Ri=Pipe_Radius_Internal\n", + "Pipe_Radius_External=4.2 #cm\n", + "Ro=Pipe_Radius_External\n", + "Tf=Fluid_temp\n", + "Ice_Radius=100 #cm\n", + "Rice=Ice_Radius\n", + "Resistance_fluid= 1/(Fluid_h)*(2)*(3.14159)*(Ri)*(L)\n", + "Resistance_Pipe=(log((Ro/Ri),2.71828))/(2*3.14*Pipe_k*L)\n", + "Resistance_Iceonwall= 1 / (Water_h)*(2)*(3.14159)*(Ro)*(L)\n", + "Resistance_IceExterior= 1 / (Water_h)*(2)*(3.14159)*(Rice)*(L)\n", + "Resistance_AirandIce = 1 / (Air_h)*(2)*(3.14159)*(Rice)*(L)\n", + "Resistance_Total=Resistance_fluid + Resistance_Pipe + Resistance_Iceonwall + Resistance_IceExterior + Resistance_AirandIce\n", + "UA=1/Resistance_Total\n", + "q=(UA)*(Fluid_temp-Air_temp)\n", + "UA_final=1/Resistance_AirandIce\n", + "Temp_Surface=(q/(UA_final))+(Air_temp)\n", + "Temp_Surface" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5ee0d7655914130ab94199bbe5ad340", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=-120.0, description='temperature', max=-45.0, min=-150.0), Output()), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b93c5c57d56f40fdaa0d2e1f4c0c968a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=-120.0, description='temperature', max=-45.0, min=-150.0), Output()), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac2a6552661a4cf59d1c5d3f15b35a20", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=-120.0, description='temperature', max=-45.0, min=-150.0), Output()), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c98fed3f34240caa71de92d73513e33", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=-120.0, description='temperature', max=-45.0, min=-150.0), Output()), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6b69eb1849b41f5a6a72ad638544d78", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=-120.0, description='temperature', max=-45.0, min=-150.0), Output()), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from ipywidgets import widgets, interact, fixed\n", + "%matplotlib inline\n", + "import seaborn as sbn\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "import scipy.interpolate\n", + "\n", + "\n", + "@interact (temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "def Prandtl_liquidPP(temperature):\n", + " T = [-187.7, -173, -153, -133, -113.2, -93.2, -73.2, -53.2, -42.4]\n", + " Pr_PP= [99.44, 35.88, 15.11, 8.89, 6.29, 4.94, 4.14, 3.63, 3.43]\n", + " interpolation = scipy.interpolate.interp1d(T, Pr_PP, kind=\"quadratic\")\n", + "\n", + " return float(interpolation(temperature))\n", + " \n", + "@interact (temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "def ThermalConductivity_liquidPP(temperature):\n", + " T = [-150, -125, -100, -75, -50,-44]\n", + " k_PP= 1e-3*np.array ([193, 179, 164, 149,134, 129])\n", + " interpolation = scipy.interpolate.interp1d(T, k_PP, kind=\"quadratic\")\n", + " print('Thermal Conductivity (W/mK)')\n", + " return float(interpolation(temperature))\n", + "\n", + "@interact (temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "#Density calculation\n", + "def density_liquidPP(temperature):\n", + " T = [-187.7, -173, -153, -133, -113.2, -93.2, -73.2, -53.2, -42.4]\n", + " rho_PP = [733.1, 718.2, 697.8, 677.6, 657.3, 636.7, 615.5, 593.5 ,581.2]\n", + " interpolation = scipy.interpolate.interp1d(T, rho_PP, kind=\"quadratic\")\n", + "\n", + " return float(interpolation(temperature))\n", + "\n", + "@interact (temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "#Dynamic Viscosity Calculation\n", + "def DynamicViscosity_liquidPP(temperature):\n", + " T = [-187.7, -173, -153, -133, -113.2, -93.2, -73.2, -53.2, -42.4]\n", + " miu_D_PP = 1e-6*np.array([10970, 3778, 1502, 822.9, 535.5, 382.5, 288.2, 224.3,197.9])\n", + " interpolation = scipy.interpolate.interp1d(T, miu_D_PP, kind=\"quadratic\")\n", + "\n", + " return float(interpolation(temperature))\n", + "\n", + "@interact (temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "#Kinematic Viscosity Calculation\n", + "def KinematicViscosity_liquidPP(temperature):\n", + " T = [-187.7, -173, -153, -133, -113.2, -93.2, -73.2, -53.2, -42.4]\n", + " miu_K_PP = 1e-6*np.array([14.72, 5.26, 2.152, 1.214, 0.8147, 0.6008,0.4683, 0.3779, 0.3405])\n", + " interpolation = scipy.interpolate.interp1d(T, miu_K_PP, kind=\"quadratic\")\n", + " print('Kinematic Viscosity m^2/s')\n", + " return float(interpolation(temperature))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7cd68e76ccb942559d3d05f0fafbde49", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=10.0, description='velocity', max=20.0), FloatSlider(value=1.0, descri…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\"Reynolds Number calculation\"\n", + "@interact (velocity=widgets.FloatSlider(value=10, min=0, max=20), \n", + " lengthscale=widgets.FloatSlider(value=1, min=0.5, max=2), \n", + " temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "def Reynolds_liquidPP(velocity, lengthscale, temperature):\n", + " rho_PP = density_liquidPP(temperature)\n", + " miu_D_PP = DynamicViscosity_liquidPP(temperature)\n", + " Reynolds_liquidPP = rho_PP * velocity * lengthscale / miu_D_PP\n", + " return Reynolds_liquidPP" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d581d9475a774381afbdfdefaf44d12f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=10.0, description='velocity', max=20.0), FloatSlider(value=1.0, descri…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@interact (velocity=widgets.FloatSlider(value=10, min=0, max=20), \n", + " lengthscale=widgets.FloatSlider(value=1, min=0.5, max=2), \n", + " temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "def Nusselt_liquidPP(velocity, lengthscale, temperature):\n", + " Re_PP = Reynolds_liquidPP(velocity, lengthscale, temperature)\n", + " Pr_PP = Prandtl_liquidPP(temperature)\n", + " Nusselt_liquidPP = 0.023 * Re_PP**(4/5) * Pr_PP**0.4\n", + " return Nusselt_liquidPP" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "78ec96a6042c4abd9d739d385f341eca", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=10.0, description='velocity', max=20.0), FloatSlider(value=1.0, descri…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Boundary layer thickness of Propane\n", + "@interact (velocity=widgets.FloatSlider(value=10, min=0, max=20), \n", + " lengthscale=widgets.FloatSlider(value=1, min=0.5, max=2), \n", + " temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "def Boundary_PP(velocity, lengthscale, temperature):\n", + " mu_k_PP = KinematicViscosity_liquidPP (temperature)\n", + " Pr_PP = Prandtl_liquidPP(temperature)\n", + " Boundary_PP = 0.37 * lengthscale / (velocity*lengthscale/mu_k_PP)**0.2\n", + " return Boundary_PP" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95945f0c9487406685673ee145b1a7a8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=10.0, description='velocity', max=20.0), FloatSlider(value=1.0, descri…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Heat transfer coeffecient of Propane from -150 C to -45 C\n", + "@interact (velocity=widgets.FloatSlider(value=10, min=0, max=20), \n", + " lengthscale=widgets.FloatSlider(value=1, min=0.5, max=2), \n", + " temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n", + "def heat_transfer_coefficient_PP (velocity, lengthscale, temperature):\n", + " Nu_PP = Nusselt_liquidPP(velocity, lengthscale, temperature)\n", + " k_PP = ThermalConductivity_liquidPP(temperature)\n", + " L = Boundary_PP(velocity, lengthscale, temperature)\n", + " h_PP = Nu_PP * k_PP / lengthscale\n", + " return h_PP" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#Morris Method\n", + "import SALib\n", + "from SALib.sample import morris as ms\n", + "from SALib.analyze import morris as ma\n", + "from SALib.plotting import morris as mp" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "morris_problem = {\n", + " # There are three variables\n", + " 'num_vars': 3,\n", + " 'names': ['velocity', 'lengthscale', 'temperature'],\n", + " # These are their ranges over which we'll move the variables\n", + " 'bounds': [[0, 20], #velocity (m/s)\n", + " [1, 2], # length (m)\n", + " [-150, -45], # temperature (C) \n", + " ],\n", + " 'groups': None\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(40000, 3)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_levels = 4\n", + "grid_jump = 2\n", + "trajectories = int(1e4)\n", + "sample = ms.sample(morris_problem, trajectories, num_levels, grid_jump)\n", + "sample.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 40000)\n", + "[[ 0. 0. 0. ... 0.\n", + " 0. 0. ]\n", + " [ 1.33333333 2. 2. ... 1.66666667\n", + " 1.66666667 1. ]\n", + " [-115. -115. -45. ... -115.\n", + " -45. -45. ]]\n" + ] + } + ], + "source": [ + "print(sample.T.shape)\n", + "print(sample.T)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "only size-1 arrays can be converted to Python scalars", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mheat_transfer_coefficient_PP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mheat_transfer_coefficient_PP\u001b[0;34m(velocity, lengthscale, temperature)\u001b[0m\n\u001b[1;32m 4\u001b[0m temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n\u001b[1;32m 5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mheat_transfer_coefficient_PP\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mvelocity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengthscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mNu_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNusselt_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvelocity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengthscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mk_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mThermalConductivity_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mL\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBoundary_PP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvelocity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengthscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mNusselt_liquidPP\u001b[0;34m(velocity, lengthscale, temperature)\u001b[0m\n\u001b[1;32m 3\u001b[0m temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n\u001b[1;32m 4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mNusselt_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvelocity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengthscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mRe_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mReynolds_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvelocity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengthscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mPr_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPrandtl_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mNusselt_liquidPP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.023\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mRe_PP\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mPr_PP\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m0.4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mReynolds_liquidPP\u001b[0;34m(velocity, lengthscale, temperature)\u001b[0m\n\u001b[1;32m 4\u001b[0m temperature=widgets.FloatSlider(value=-120, min=-150, max=-45))\n\u001b[1;32m 5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mReynolds_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvelocity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengthscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mrho_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdensity_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mmiu_D_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDynamicViscosity_liquidPP\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mReynolds_liquidPP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrho_PP\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mvelocity\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mlengthscale\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mmiu_D_PP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdensity_liquidPP\u001b[0;34m(temperature)\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0mrho_PP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m733.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m718.2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m697.8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m677.6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m657.3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m636.7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m615.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m593.5\u001b[0m \u001b[0;34m,\u001b[0m\u001b[0;36m581.2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0minterpolation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterpolate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterp1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrho_PP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkind\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"quadratic\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterpolation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0minteract\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mwidgets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloatSlider\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m120\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m150\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m45\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: only size-1 arrays can be converted to Python scalars" + ] + } + ], + "source": [ + "output = heat_transfer_coefficient_PP(*sample.T)\n", + "print(output.shape)\n", + "print(output)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "output = heat_transfer_coefficient_PP(*sample.T)\n", + "Si = ma.analyze(morris_problem, \n", + " sample, \n", + " output, \n", + " print_to_console=False, \n", + " grid_jump=grid_jump, \n", + " num_levels=num_levels)\n", + "print(\"{:20s} {:>7s} {:>7s} {:>7s}\".format(\"Name\", \"mu\", \"mu_star\", \"sigma\"))\n", + "for name, s1, st, mean in zip(morris_problem['names'], Si['mu'], Si['mu_star'], Si['sigma']):\n", + " print(\"{:20s} {:=7.2f} {:=7.2f} {:=7.2f}\".format(name, s1, st, mean))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Scatter plots\n", + "number_sims = 1000\n", + "mc_velocity = np.random.uniform(0, 20, number_sims)\n", + "mc_lengthscale = np.random.uniform(1, 2, number_sims)\n", + "mc_temperature = np.random.uniform(-150, -45, number_sims)\n", + "data = np.array((mc_velocity, mc_lengthscale, mc_temperature))\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for thing in data:\n", + " print(thing.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "heat_transfer_coefficient_PP(data[0], data[1], data[2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}