diff --git a/ME_2016/.ipynb_checkpoints/final_project/main.py b/ME_2016/.ipynb_checkpoints/final_project/main.py new file mode 100644 index 0000000..e69de29 diff --git a/ME_2016/final_project/.ipynb_checkpoints/final_project-checkpoint.ipynb b/ME_2016/final_project/.ipynb_checkpoints/final_project-checkpoint.ipynb new file mode 100644 index 0000000..28847f0 --- /dev/null +++ b/ME_2016/final_project/.ipynb_checkpoints/final_project-checkpoint.ipynb @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "e8c2ea85-5a97-4b92-9b54-26ef084d8929", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "96f46ebc-ffb4-48d4-9c57-a3ba23d0949d", + "metadata": {}, + "outputs": [], + "source": [ + "def diff_eq(t, s, params):\n", + " s_dot = params.alpha*s**2 + params.beta*s + params.gamma + params.delta/s\n", + " return s\n", + "\n", + "def reach_sk(t, s, params):\n", + " s_k = 1/params.alpha\n", + " return s-s_k" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8930e691-06ed-4224-a030-65e140aa03e5", + "metadata": {}, + "outputs": [], + "source": [ + "N_total = 68301\n", + "N_average = N_total/65\n", + "#Define parametrs\n", + "alpha = 40/N_average**2\n", + "beta = 260/N_average\n", + "gamma = 1\n", + "delta = 1\n", + "N_0 = 40000\n", + "\n", + "\n", + "#Configure Event\n", + "reach_sk.terminal = True\n", + "reach_sk.direction = 1\n", + "\n", + "#initial conditions\n", + "s_0 = params['N_0']\n", + "t_span = (0,100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6790f6a3-3019-4921-bf27-17d21cf3af75", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.integrate import solve_ivp\n", + "sol = solve_ip(\n", + " fun = lambda t, s: diff_eq(t, s, params),\n", + " t_span = t_span,\n", + " y0 = [s_0], \n", + " method = 'RK45',\n", + " events = reach_sk\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "265f47db-b9d1-4b8c-bbdd-442bb3ae580d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:16: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:17: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:16: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:17: SyntaxWarning: invalid escape sequence '\\s'\n", + "/tmp/ipykernel_18177/1639341866.py:16: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.set_xlabel('$\\gamma$')\n", + "/tmp/ipykernel_18177/1639341866.py:17: SyntaxWarning: invalid escape sequence '\\s'\n", + " ax1.set_ylabel('$s^\\star$')\n", + "/tmp/ipykernel_18177/1639341866.py:10: RuntimeWarning: invalid value encountered in sqrt\n", + " s_1 = -beta/2/alpha * (1 + np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n", + "/tmp/ipykernel_18177/1639341866.py:11: RuntimeWarning: invalid value encountered in sqrt\n", + " s_2 = -beta/2/alpha * (1 - np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gamma_values = np.linspace(0,800,10000)\n", + "\n", + "#Define parametrs\n", + "alpha = 4e-7\n", + "beta = -0.03\n", + "gamma = 0\n", + "delta = 0\n", + "N_0 = 40000\n", + "\n", + "#Find gamam zeros\n", + "s_1 = -beta/2/alpha * (1 + np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n", + "s_2 = -beta/2/alpha * (1 - np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (10, 6))\n", + "ax1.plot(gamma_values, s_1, 'r', gamma_values, s_2, 'b')\n", + "ax1.set_title('(A)')\n", + "ax1.set_xlabel('$\\gamma$')\n", + "ax1.set_ylabel('$s^\\star$')\n", + "ax1.grid('on')\n", + "\n", + "#find delta zeros\n", + "def s_dot(s, delta):\n", + " return alpha*s**2 + beta*s + gamma + delta/s\n", + "\n", + "from scipy.optimize import root_scalar\n", + "\n", + "def find_root(delta, bracket):\n", + " result = root_scalar(s_dot, args = (delta,), method = 'brentq', bracket=bracket)\n", + " if result.converged:\n", + " return result.root\n", + " else:\n", + " return None\n", + "\n", + "delta_values = np.linspace(0,800,1000)*N_0\n", + "roots = []" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "6391b058-8273-4208-a2f4-c467ffa0b5fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 74998.22213794 366.04271268 -364.26485061]\n", + " [ 74983.98070068 1104.02743475 -1088.00813543]\n", + " [ 74969.72843243 1521.68159847 -1491.4100309 ]\n", + " ...\n", + " [ 51430.15568009 51430.15568009 -27860.31136019]\n", + " [ 51436.305844 51436.305844 -27872.61168801]\n", + " [ 51442.45232458 51442.45232458 -27884.90464915]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_18177/1840589270.py:24: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " roots[i] = np.roots([alpha, beta, gamma, delta])\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import root_scalar\n", + "\n", + "# Parameters\n", + "alpha = 4e-7\n", + "beta = -0.03\n", + "gamma = 0\n", + "N_0 = 40000\n", + "\n", + "# Define s_dot function\n", + "def s_dot(s, delta):\n", + " return alpha * s**2 + beta * s + gamma + delta / s\n", + "\n", + "# Delta values to evaluate\n", + "delta_values = np.linspace(0.1, 800, 1000) * N_0\n", + "roots_positive = []\n", + "roots_negative = []\n", + "\n", + "# Find roots for each delta\n", + "roots = np.zeros([1000,3])\n", + "for i, delta in enumerate(delta_values):\n", + " roots[i] = np.roots([alpha, beta, gamma, delta])\n", + "\n", + "print(roots)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "0c80e43c-d9f6-419c-8eac-803b425a5ab9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:11: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:12: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:20: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:21: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:11: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:12: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:20: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:21: SyntaxWarning: invalid escape sequence '\\s'\n", + "/tmp/ipykernel_18177/2299603038.py:11: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.set_xlabel('$\\gamma$')\n", + "/tmp/ipykernel_18177/2299603038.py:12: SyntaxWarning: invalid escape sequence '\\s'\n", + " ax1.set_ylabel('$s^\\star$')\n", + "/tmp/ipykernel_18177/2299603038.py:20: SyntaxWarning: invalid escape sequence '\\d'\n", + " ax2.set_xlabel('$\\delta / N_0$')\n", + "/tmp/ipykernel_18177/2299603038.py:21: SyntaxWarning: invalid escape sequence '\\s'\n", + " ax2.set_ylabel('$s^\\star$')\n", + "/tmp/ipykernel_18177/2299603038.py:6: RuntimeWarning: invalid value encountered in sqrt\n", + " s_1 = -beta / (2 * alpha) * (1 + np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n", + "/tmp/ipykernel_18177/2299603038.py:7: RuntimeWarning: invalid value encountered in sqrt\n", + " s_2 = -beta / (2 * alpha) * (1 - np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot results\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Gamma values and roots\n", + "gamma_values = np.linspace(0, 800, 10000)\n", + "s_1 = -beta / (2 * alpha) * (1 + np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n", + "s_2 = -beta / (2 * alpha) * (1 - np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n", + "ax1.plot(gamma_values, s_1, 'r', label='Unstable Mode')\n", + "ax1.plot(gamma_values, s_2, 'b', label='Stable Mode')\n", + "ax1.set_title('(A)')\n", + "ax1.set_xlabel('$\\gamma$')\n", + "ax1.set_ylabel('$s^\\star$')\n", + "ax1.legend()\n", + "ax1.grid('on')\n", + "\n", + "# Delta vs Roots\n", + "ax2.plot(delta_values / N_0, roots[:,0], 'r', label='Unstable Mode')\n", + "ax2.plot(delta_values / N_0, roots[:,1], 'b', label='Stable mode')\n", + "ax2.set_title('(B)')\n", + "ax2.set_xlabel('$\\delta / N_0$')\n", + "ax2.set_ylabel('$s^\\star$')\n", + "ax2.legend()\n", + "ax2.grid('on')\n", + "Sedona Scha\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "4e8800fc-0016-4fea-891f-eaa789e7e751", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.622701743303522e-07 0.024743415176937383\n" + ] + } + ], + "source": [ + "N_total = 68301\n", + "N_average = N_total/65*10 #Fudged. the paper is missing factor of 10\n", + "#Define parametrs\n", + "alpha = 40/N_average**2\n", + "beta = 260/N_average\n", + "print(alpha, beta)\n", + "gamma = 0\n", + "delta = 0\n", + "N_0 = 40000\n", + "\n", + "# Define s_dot function\n", + "def s_dot(t, s, beta, gamma, delta):\n", + " return alpha * s**2 + beta * s + gamma + delta / s\n", + "\n", + "def reach_sk(t, s):\n", + " s_k = 1/alpha\n", + " return s_k-s[0]\n", + "\n", + "reach_sk.terminal = True" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "id": "69282f35-5f99-40fa-a29d-b65c0c98ab82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:27: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:54: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:27: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:54: SyntaxWarning: invalid escape sequence '\\d'\n", + "/tmp/ipykernel_18177/1561618771.py:27: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\gamma$ = {name}')\n", + "/tmp/ipykernel_18177/1561618771.py:54: SyntaxWarning: invalid escape sequence '\\d'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\delta / N_0$ = {name}')\n", + "/tmp/ipykernel_18177/1561618771.py:27: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\gamma$ = {name}')\n", + "/tmp/ipykernel_18177/1561618771.py:54: SyntaxWarning: invalid escape sequence '\\d'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\delta / N_0$ = {name}')\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[182], line 41\u001b[0m\n\u001b[1;32m 39\u001b[0m t_betas \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, beta \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(beta_values):\n\u001b[0;32m---> 41\u001b[0m sol \u001b[38;5;241m=\u001b[39m \u001b[43msolve_ivp\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 42\u001b[0m \u001b[43m \u001b[49m\u001b[43mfun\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43ms_dot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbeta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdelta\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 43\u001b[0m \u001b[43m \u001b[49m\u001b[43mt_span\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mt_span\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43my0\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mN_0\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mRK45\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43mevents\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mreach_sk\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 48\u001b[0m t_betas\u001b[38;5;241m.\u001b[39mappend(sol\u001b[38;5;241m.\u001b[39mt[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 49\u001b[0m \u001b[38;5;66;03m#t_betas.append(sol[-1,0])\u001b[39;00m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/ivp.py:655\u001b[0m, in \u001b[0;36msolve_ivp\u001b[0;34m(fun, t_span, y0, method, t_eval, dense_output, events, vectorized, args, **options)\u001b[0m\n\u001b[1;32m 653\u001b[0m status \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 654\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m status \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 655\u001b[0m message \u001b[38;5;241m=\u001b[39m \u001b[43msolver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 657\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m solver\u001b[38;5;241m.\u001b[39mstatus \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfinished\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m 658\u001b[0m status \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/base.py:197\u001b[0m, in \u001b[0;36mOdeSolver.step\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 196\u001b[0m t \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mt\n\u001b[0;32m--> 197\u001b[0m success, message \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_step_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m success:\n\u001b[1;32m 200\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstatus \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfailed\u001b[39m\u001b[38;5;124m'\u001b[39m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/rk.py:144\u001b[0m, in \u001b[0;36mRungeKutta._step_impl\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 141\u001b[0m h \u001b[38;5;241m=\u001b[39m t_new \u001b[38;5;241m-\u001b[39m t\n\u001b[1;32m 142\u001b[0m h_abs \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mabs(h)\n\u001b[0;32m--> 144\u001b[0m y_new, f_new \u001b[38;5;241m=\u001b[39m \u001b[43mrk_step\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 145\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mK\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 146\u001b[0m scale \u001b[38;5;241m=\u001b[39m atol \u001b[38;5;241m+\u001b[39m np\u001b[38;5;241m.\u001b[39mmaximum(np\u001b[38;5;241m.\u001b[39mabs(y), np\u001b[38;5;241m.\u001b[39mabs(y_new)) \u001b[38;5;241m*\u001b[39m rtol\n\u001b[1;32m 147\u001b[0m error_norm \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_estimate_error_norm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mK, h, scale)\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/rk.py:64\u001b[0m, in \u001b[0;36mrk_step\u001b[0;34m(fun, t, y, f, h, A, B, C, K)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m s, (a, c) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[38;5;28mzip\u001b[39m(A[\u001b[38;5;241m1\u001b[39m:], C[\u001b[38;5;241m1\u001b[39m:]), start\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m 63\u001b[0m dy \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mdot(K[:s]\u001b[38;5;241m.\u001b[39mT, a[:s]) \u001b[38;5;241m*\u001b[39m h\n\u001b[0;32m---> 64\u001b[0m K[s] \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m y_new \u001b[38;5;241m=\u001b[39m y \u001b[38;5;241m+\u001b[39m h \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mdot(K[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mT, B)\n\u001b[1;32m 67\u001b[0m f_new \u001b[38;5;241m=\u001b[39m fun(t \u001b[38;5;241m+\u001b[39m h, y_new)\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/base.py:154\u001b[0m, in \u001b[0;36mOdeSolver.__init__..fun\u001b[0;34m(t, y)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfun\u001b[39m(t, y):\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnfev \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m--> 154\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfun_single\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/base.py:23\u001b[0m, in \u001b[0;36mcheck_arguments..fun_wrapped\u001b[0;34m(t, y)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfun_wrapped\u001b[39m(t, y):\n\u001b[0;32m---> 23\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43masarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.integrate import solve_ivp\n", + "t_span = (0,400)\n", + "\n", + "beta_values = np.linspace(-1500, 0, 1)/N_0\n", + "delta_values = [0, 100, 500, 1000]*N_0\n", + "gamma_values = [0, 100, 500, 1000]\n", + "\n", + "max_ts = {}\n", + "\n", + "#First graph\n", + "for i, gamma in enumerate(gamma_values):\n", + " t_betas = []\n", + " for i, beta in enumerate(beta_values):\n", + " sol = solve_ivp(\n", + " fun = lambda t, s: s_dot(t, s, beta, gamma, delta),\n", + " t_span = t_span,\n", + " y0 = [N_0], \n", + " method = 'RK45',\n", + " events = reach_sk\n", + " )\n", + " t_betas.append(sol.t[-1])\n", + " #t_betas.append(sol[-1,0])\n", + " max_ts[f'{gamma}'] = t_betas \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1,2, figsize = (10,6))\n", + "for name in max_ts:\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\gamma$ = {name}')\n", + "\n", + "ax1.set_xlabel(\"\\beta N_0\")\n", + "ax1.set_ylabel(\"t_k (yrs)\")\n", + "ax1.set_title(\"(a)\")\n", + "ax1.legend()\n", + "\n", + "max_ts = {}\n", + "\n", + "#First graph\n", + "gamma = 0\n", + "for i, delta in enumerate(delta_values):\n", + " t_betas = []\n", + " for i, beta in enumerate(beta_values):\n", + " sol = solve_ivp(\n", + " fun = lambda t, s: s_dot(t, s, beta, gamma, delta),\n", + " t_span = t_span,\n", + " y0 = [N_0], \n", + " method = 'RK45',\n", + " events = reach_sk\n", + " )\n", + " t_betas.append(sol.t[-1])\n", + " #t_betas.append(sol[-1,0])\n", + " max_ts[f'{gamma}'] = t_betas \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1,2, figsize = (10,6))\n", + "for name in max_ts:\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\delta / N_0$ = {name}')\n", + "\n", + "ax2.set_xlabel(\"\\beta N_0\")\n", + "ax2.set_ylabel(\"t_k (yrs)\")\n", + "ax2.set_title(\"(b)\")\n", + "ax2.legend()" + ] + } + ], + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ME_2016/final_project/.ipynb_checkpoints/main-checkpoint.py b/ME_2016/final_project/.ipynb_checkpoints/main-checkpoint.py new file mode 100644 index 0000000..2061976 --- /dev/null +++ b/ME_2016/final_project/.ipynb_checkpoints/main-checkpoint.py @@ -0,0 +1,42 @@ +import numpy as np +import maptlotlib.pyplot as plt + +def main(): + N_total = 68301 + N_average = N_total/65 + #Define parametrs + params = { + 'alpha':40/N_average**2, + 'beta':260/N_average, + 'gamma':1, + 'delta':1, + 'N_0':40000 + } + + #Configure Event + reach_sk.terminal = True + reach_sk.direction = 1 + + #initial conditions + s_0 = params.N_0 + t_span = (0,100) + + + from scipy.integrate import solve_ivp + sol = solve_ip( + fun = lambda t, s: diff_eq(t, s, params), + t_span = t_span, + y0 = [s_0], + method = 'RK45', + events = reach_sk + ) + +def diff_eq(t, s, params): + s_dot = params.alpha*s**2 + params.beta*s**2 + params.gamma + params.delta/s + return s + +def reach_sk(t, s, params): + s_k = 1/params.alpha + return s-s_k + + diff --git a/ME_2016/final_project/final_project.ipynb b/ME_2016/final_project/final_project.ipynb new file mode 100644 index 0000000..28847f0 --- /dev/null +++ b/ME_2016/final_project/final_project.ipynb @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "e8c2ea85-5a97-4b92-9b54-26ef084d8929", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "96f46ebc-ffb4-48d4-9c57-a3ba23d0949d", + "metadata": {}, + "outputs": [], + "source": [ + "def diff_eq(t, s, params):\n", + " s_dot = params.alpha*s**2 + params.beta*s + params.gamma + params.delta/s\n", + " return s\n", + "\n", + "def reach_sk(t, s, params):\n", + " s_k = 1/params.alpha\n", + " return s-s_k" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8930e691-06ed-4224-a030-65e140aa03e5", + "metadata": {}, + "outputs": [], + "source": [ + "N_total = 68301\n", + "N_average = N_total/65\n", + "#Define parametrs\n", + "alpha = 40/N_average**2\n", + "beta = 260/N_average\n", + "gamma = 1\n", + "delta = 1\n", + "N_0 = 40000\n", + "\n", + "\n", + "#Configure Event\n", + "reach_sk.terminal = True\n", + "reach_sk.direction = 1\n", + "\n", + "#initial conditions\n", + "s_0 = params['N_0']\n", + "t_span = (0,100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6790f6a3-3019-4921-bf27-17d21cf3af75", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.integrate import solve_ivp\n", + "sol = solve_ip(\n", + " fun = lambda t, s: diff_eq(t, s, params),\n", + " t_span = t_span,\n", + " y0 = [s_0], \n", + " method = 'RK45',\n", + " events = reach_sk\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "265f47db-b9d1-4b8c-bbdd-442bb3ae580d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:16: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:17: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:16: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:17: SyntaxWarning: invalid escape sequence '\\s'\n", + "/tmp/ipykernel_18177/1639341866.py:16: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.set_xlabel('$\\gamma$')\n", + "/tmp/ipykernel_18177/1639341866.py:17: SyntaxWarning: invalid escape sequence '\\s'\n", + " ax1.set_ylabel('$s^\\star$')\n", + "/tmp/ipykernel_18177/1639341866.py:10: RuntimeWarning: invalid value encountered in sqrt\n", + " s_1 = -beta/2/alpha * (1 + np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n", + "/tmp/ipykernel_18177/1639341866.py:11: RuntimeWarning: invalid value encountered in sqrt\n", + " s_2 = -beta/2/alpha * (1 - np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gamma_values = np.linspace(0,800,10000)\n", + "\n", + "#Define parametrs\n", + "alpha = 4e-7\n", + "beta = -0.03\n", + "gamma = 0\n", + "delta = 0\n", + "N_0 = 40000\n", + "\n", + "#Find gamam zeros\n", + "s_1 = -beta/2/alpha * (1 + np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n", + "s_2 = -beta/2/alpha * (1 - np.sqrt(1 - 4*gamma_values*alpha/beta**2))\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (10, 6))\n", + "ax1.plot(gamma_values, s_1, 'r', gamma_values, s_2, 'b')\n", + "ax1.set_title('(A)')\n", + "ax1.set_xlabel('$\\gamma$')\n", + "ax1.set_ylabel('$s^\\star$')\n", + "ax1.grid('on')\n", + "\n", + "#find delta zeros\n", + "def s_dot(s, delta):\n", + " return alpha*s**2 + beta*s + gamma + delta/s\n", + "\n", + "from scipy.optimize import root_scalar\n", + "\n", + "def find_root(delta, bracket):\n", + " result = root_scalar(s_dot, args = (delta,), method = 'brentq', bracket=bracket)\n", + " if result.converged:\n", + " return result.root\n", + " else:\n", + " return None\n", + "\n", + "delta_values = np.linspace(0,800,1000)*N_0\n", + "roots = []" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "6391b058-8273-4208-a2f4-c467ffa0b5fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 74998.22213794 366.04271268 -364.26485061]\n", + " [ 74983.98070068 1104.02743475 -1088.00813543]\n", + " [ 74969.72843243 1521.68159847 -1491.4100309 ]\n", + " ...\n", + " [ 51430.15568009 51430.15568009 -27860.31136019]\n", + " [ 51436.305844 51436.305844 -27872.61168801]\n", + " [ 51442.45232458 51442.45232458 -27884.90464915]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_18177/1840589270.py:24: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " roots[i] = np.roots([alpha, beta, gamma, delta])\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import root_scalar\n", + "\n", + "# Parameters\n", + "alpha = 4e-7\n", + "beta = -0.03\n", + "gamma = 0\n", + "N_0 = 40000\n", + "\n", + "# Define s_dot function\n", + "def s_dot(s, delta):\n", + " return alpha * s**2 + beta * s + gamma + delta / s\n", + "\n", + "# Delta values to evaluate\n", + "delta_values = np.linspace(0.1, 800, 1000) * N_0\n", + "roots_positive = []\n", + "roots_negative = []\n", + "\n", + "# Find roots for each delta\n", + "roots = np.zeros([1000,3])\n", + "for i, delta in enumerate(delta_values):\n", + " roots[i] = np.roots([alpha, beta, gamma, delta])\n", + "\n", + "print(roots)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "0c80e43c-d9f6-419c-8eac-803b425a5ab9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:11: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:12: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:20: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:21: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:11: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:12: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:20: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:21: SyntaxWarning: invalid escape sequence '\\s'\n", + "/tmp/ipykernel_18177/2299603038.py:11: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.set_xlabel('$\\gamma$')\n", + "/tmp/ipykernel_18177/2299603038.py:12: SyntaxWarning: invalid escape sequence '\\s'\n", + " ax1.set_ylabel('$s^\\star$')\n", + "/tmp/ipykernel_18177/2299603038.py:20: SyntaxWarning: invalid escape sequence '\\d'\n", + " ax2.set_xlabel('$\\delta / N_0$')\n", + "/tmp/ipykernel_18177/2299603038.py:21: SyntaxWarning: invalid escape sequence '\\s'\n", + " ax2.set_ylabel('$s^\\star$')\n", + "/tmp/ipykernel_18177/2299603038.py:6: RuntimeWarning: invalid value encountered in sqrt\n", + " s_1 = -beta / (2 * alpha) * (1 + np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n", + "/tmp/ipykernel_18177/2299603038.py:7: RuntimeWarning: invalid value encountered in sqrt\n", + " s_2 = -beta / (2 * alpha) * (1 - np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot results\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Gamma values and roots\n", + "gamma_values = np.linspace(0, 800, 10000)\n", + "s_1 = -beta / (2 * alpha) * (1 + np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n", + "s_2 = -beta / (2 * alpha) * (1 - np.sqrt(1 - 4 * gamma_values * alpha / beta**2))\n", + "ax1.plot(gamma_values, s_1, 'r', label='Unstable Mode')\n", + "ax1.plot(gamma_values, s_2, 'b', label='Stable Mode')\n", + "ax1.set_title('(A)')\n", + "ax1.set_xlabel('$\\gamma$')\n", + "ax1.set_ylabel('$s^\\star$')\n", + "ax1.legend()\n", + "ax1.grid('on')\n", + "\n", + "# Delta vs Roots\n", + "ax2.plot(delta_values / N_0, roots[:,0], 'r', label='Unstable Mode')\n", + "ax2.plot(delta_values / N_0, roots[:,1], 'b', label='Stable mode')\n", + "ax2.set_title('(B)')\n", + "ax2.set_xlabel('$\\delta / N_0$')\n", + "ax2.set_ylabel('$s^\\star$')\n", + "ax2.legend()\n", + "ax2.grid('on')\n", + "Sedona Scha\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "4e8800fc-0016-4fea-891f-eaa789e7e751", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.622701743303522e-07 0.024743415176937383\n" + ] + } + ], + "source": [ + "N_total = 68301\n", + "N_average = N_total/65*10 #Fudged. the paper is missing factor of 10\n", + "#Define parametrs\n", + "alpha = 40/N_average**2\n", + "beta = 260/N_average\n", + "print(alpha, beta)\n", + "gamma = 0\n", + "delta = 0\n", + "N_0 = 40000\n", + "\n", + "# Define s_dot function\n", + "def s_dot(t, s, beta, gamma, delta):\n", + " return alpha * s**2 + beta * s + gamma + delta / s\n", + "\n", + "def reach_sk(t, s):\n", + " s_k = 1/alpha\n", + " return s_k-s[0]\n", + "\n", + "reach_sk.terminal = True" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "id": "69282f35-5f99-40fa-a29d-b65c0c98ab82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:27: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:54: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:27: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:54: SyntaxWarning: invalid escape sequence '\\d'\n", + "/tmp/ipykernel_18177/1561618771.py:27: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\gamma$ = {name}')\n", + "/tmp/ipykernel_18177/1561618771.py:54: SyntaxWarning: invalid escape sequence '\\d'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\delta / N_0$ = {name}')\n", + "/tmp/ipykernel_18177/1561618771.py:27: SyntaxWarning: invalid escape sequence '\\g'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\gamma$ = {name}')\n", + "/tmp/ipykernel_18177/1561618771.py:54: SyntaxWarning: invalid escape sequence '\\d'\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\delta / N_0$ = {name}')\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[182], line 41\u001b[0m\n\u001b[1;32m 39\u001b[0m t_betas \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, beta \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(beta_values):\n\u001b[0;32m---> 41\u001b[0m sol \u001b[38;5;241m=\u001b[39m \u001b[43msolve_ivp\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 42\u001b[0m \u001b[43m \u001b[49m\u001b[43mfun\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43ms_dot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbeta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdelta\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 43\u001b[0m \u001b[43m \u001b[49m\u001b[43mt_span\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mt_span\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43my0\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mN_0\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mRK45\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43mevents\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mreach_sk\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 48\u001b[0m t_betas\u001b[38;5;241m.\u001b[39mappend(sol\u001b[38;5;241m.\u001b[39mt[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 49\u001b[0m \u001b[38;5;66;03m#t_betas.append(sol[-1,0])\u001b[39;00m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/ivp.py:655\u001b[0m, in \u001b[0;36msolve_ivp\u001b[0;34m(fun, t_span, y0, method, t_eval, dense_output, events, vectorized, args, **options)\u001b[0m\n\u001b[1;32m 653\u001b[0m status \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 654\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m status \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 655\u001b[0m message \u001b[38;5;241m=\u001b[39m \u001b[43msolver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 657\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m solver\u001b[38;5;241m.\u001b[39mstatus \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfinished\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m 658\u001b[0m status \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/base.py:197\u001b[0m, in \u001b[0;36mOdeSolver.step\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 196\u001b[0m t \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mt\n\u001b[0;32m--> 197\u001b[0m success, message \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_step_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m success:\n\u001b[1;32m 200\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstatus \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfailed\u001b[39m\u001b[38;5;124m'\u001b[39m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/rk.py:144\u001b[0m, in \u001b[0;36mRungeKutta._step_impl\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 141\u001b[0m h \u001b[38;5;241m=\u001b[39m t_new \u001b[38;5;241m-\u001b[39m t\n\u001b[1;32m 142\u001b[0m h_abs \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mabs(h)\n\u001b[0;32m--> 144\u001b[0m y_new, f_new \u001b[38;5;241m=\u001b[39m \u001b[43mrk_step\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 145\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mK\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 146\u001b[0m scale \u001b[38;5;241m=\u001b[39m atol \u001b[38;5;241m+\u001b[39m np\u001b[38;5;241m.\u001b[39mmaximum(np\u001b[38;5;241m.\u001b[39mabs(y), np\u001b[38;5;241m.\u001b[39mabs(y_new)) \u001b[38;5;241m*\u001b[39m rtol\n\u001b[1;32m 147\u001b[0m error_norm \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_estimate_error_norm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mK, h, scale)\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/rk.py:64\u001b[0m, in \u001b[0;36mrk_step\u001b[0;34m(fun, t, y, f, h, A, B, C, K)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m s, (a, c) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[38;5;28mzip\u001b[39m(A[\u001b[38;5;241m1\u001b[39m:], C[\u001b[38;5;241m1\u001b[39m:]), start\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m 63\u001b[0m dy \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mdot(K[:s]\u001b[38;5;241m.\u001b[39mT, a[:s]) \u001b[38;5;241m*\u001b[39m h\n\u001b[0;32m---> 64\u001b[0m K[s] \u001b[38;5;241m=\u001b[39m \u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m y_new \u001b[38;5;241m=\u001b[39m y \u001b[38;5;241m+\u001b[39m h \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mdot(K[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mT, B)\n\u001b[1;32m 67\u001b[0m f_new \u001b[38;5;241m=\u001b[39m fun(t \u001b[38;5;241m+\u001b[39m h, y_new)\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/base.py:154\u001b[0m, in \u001b[0;36mOdeSolver.__init__..fun\u001b[0;34m(t, y)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfun\u001b[39m(t, y):\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnfev \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m--> 154\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfun_single\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Projects/class_work/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/base.py:23\u001b[0m, in \u001b[0;36mcheck_arguments..fun_wrapped\u001b[0;34m(t, y)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfun_wrapped\u001b[39m(t, y):\n\u001b[0;32m---> 23\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43masarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.integrate import solve_ivp\n", + "t_span = (0,400)\n", + "\n", + "beta_values = np.linspace(-1500, 0, 1)/N_0\n", + "delta_values = [0, 100, 500, 1000]*N_0\n", + "gamma_values = [0, 100, 500, 1000]\n", + "\n", + "max_ts = {}\n", + "\n", + "#First graph\n", + "for i, gamma in enumerate(gamma_values):\n", + " t_betas = []\n", + " for i, beta in enumerate(beta_values):\n", + " sol = solve_ivp(\n", + " fun = lambda t, s: s_dot(t, s, beta, gamma, delta),\n", + " t_span = t_span,\n", + " y0 = [N_0], \n", + " method = 'RK45',\n", + " events = reach_sk\n", + " )\n", + " t_betas.append(sol.t[-1])\n", + " #t_betas.append(sol[-1,0])\n", + " max_ts[f'{gamma}'] = t_betas \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1,2, figsize = (10,6))\n", + "for name in max_ts:\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\gamma$ = {name}')\n", + "\n", + "ax1.set_xlabel(\"\\beta N_0\")\n", + "ax1.set_ylabel(\"t_k (yrs)\")\n", + "ax1.set_title(\"(a)\")\n", + "ax1.legend()\n", + "\n", + "max_ts = {}\n", + "\n", + "#First graph\n", + "gamma = 0\n", + "for i, delta in enumerate(delta_values):\n", + " t_betas = []\n", + " for i, beta in enumerate(beta_values):\n", + " sol = solve_ivp(\n", + " fun = lambda t, s: s_dot(t, s, beta, gamma, delta),\n", + " t_span = t_span,\n", + " y0 = [N_0], \n", + " method = 'RK45',\n", + " events = reach_sk\n", + " )\n", + " t_betas.append(sol.t[-1])\n", + " #t_betas.append(sol[-1,0])\n", + " max_ts[f'{gamma}'] = t_betas \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1,2, figsize = (10,6))\n", + "for name in max_ts:\n", + " ax1.plot(beta_values*N_0,max_ts[name], label =f'$\\delta / N_0$ = {name}')\n", + "\n", + "ax2.set_xlabel(\"\\beta N_0\")\n", + "ax2.set_ylabel(\"t_k (yrs)\")\n", + "ax2.set_title(\"(b)\")\n", + "ax2.legend()" + ] + } + ], + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ME_2016/final_project/main.py b/ME_2016/final_project/main.py new file mode 100644 index 0000000..2061976 --- /dev/null +++ b/ME_2016/final_project/main.py @@ -0,0 +1,42 @@ +import numpy as np +import maptlotlib.pyplot as plt + +def main(): + N_total = 68301 + N_average = N_total/65 + #Define parametrs + params = { + 'alpha':40/N_average**2, + 'beta':260/N_average, + 'gamma':1, + 'delta':1, + 'N_0':40000 + } + + #Configure Event + reach_sk.terminal = True + reach_sk.direction = 1 + + #initial conditions + s_0 = params.N_0 + t_span = (0,100) + + + from scipy.integrate import solve_ivp + sol = solve_ip( + fun = lambda t, s: diff_eq(t, s, params), + t_span = t_span, + y0 = [s_0], + method = 'RK45', + events = reach_sk + ) + +def diff_eq(t, s, params): + s_dot = params.alpha*s**2 + params.beta*s**2 + params.gamma + params.delta/s + return s + +def reach_sk(t, s, params): + s_k = 1/params.alpha + return s-s_k + + diff --git a/ME_2016/mini_project_2.zip b/ME_2016/mini_project_2.zip new file mode 100644 index 0000000..97b71b3 Binary files /dev/null and b/ME_2016/mini_project_2.zip differ