From 25c52e6b29fdf169ac85a5ea1c96f337dcf73197 Mon Sep 17 00:00:00 2001 From: philippun Date: Wed, 28 Jun 2023 16:53:38 +0200 Subject: [PATCH] fixed confusion about variable naming with x, y, i, j, m, n --- proto/FTCS.ipynb | 200 +++++++++++++++++++++++++++++++++++++---------- 1 file changed, 160 insertions(+), 40 deletions(-) diff --git a/proto/FTCS.ipynb b/proto/FTCS.ipynb index 6fbc25c..f2f9d9f 100644 --- a/proto/FTCS.ipynb +++ b/proto/FTCS.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 87, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 88, "metadata": {}, "outputs": [], "source": [ @@ -36,8 +36,8 @@ "delta_x = domain_size['x'] / grid_size['x']\n", "delta_y = domain_size['y'] / grid_size['y'] \n", "\n", - "alpha_x = np.ones((grid_size['x']+2,grid_size['y']+2))\n", - "alpha_y = np.ones((grid_size['x']+2,grid_size['y']+2))\n", + "alpha_x = np.ones((grid_size['x'],grid_size['y']))\n", + "alpha_y = np.ones((grid_size['x'],grid_size['y']))\n", "\n", "# time dimension\n", "max_stable_time_step_x = delta_x**2 / (2 * np.max(alpha_x))\n", @@ -51,12 +51,12 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 102, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -67,8 +67,8 @@ ], "source": [ "# initialize environment with start values\n", - "C_t = np.zeros((grid_size['x']+2,grid_size['y']+2))\n", - "C_t[18,10] = 2000\n", + "C_t = np.zeros((grid_size['x'],grid_size['y']))\n", + "C_t[0,0] = 2000\n", "\n", "\n", "plt.imshow(C_t, vmin=0, vmax=2000)\n", @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 90, "metadata": {}, "outputs": [], "source": [ @@ -91,68 +91,132 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 99, "metadata": {}, "outputs": [], "source": [ "# simulate one time step\n", "def simulate(C_t): \n", - " C_t1 = np.zeros((grid_size['x']+2,grid_size['y']+2))\n", + " C_t1 = np.zeros((grid_size['x'],grid_size['y']))\n", "\n", " # inner cells\n", - " for i in range(1, grid_size['x']-1):\n", - " for j in range(1, grid_size['y']-1):\n", + " for i in range(1, grid_size['y']-1): #rows\n", + " for j in range(1, grid_size['x']-1): #columns\n", " C_t1[i,j] = C_t[i,j] \\\n", - " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i+1,j], alpha_x[i,j]) * C_t[i+1,j]\n", - " - (alpha_interblock(alpha_x[i+1,j], alpha_x[i,j]) + alpha_interblock(alpha_x[i-1,j], alpha_x[i,j])) * C_t[i,j] \n", - " + alpha_interblock(alpha_x[i-1,j], alpha_x[i,j]) * C_t[i-1,j]) \\\n", - " + time_step/delta_y**2 * (alpha_interblock(alpha_y[i,j+1], alpha_y[i,j]) * C_t[i,j+1]\n", - " - (alpha_interblock(alpha_y[i,j+1], alpha_y[i,j]) + alpha_interblock(alpha_y[i,j-1], alpha_y[i,j])) * C_t[i,j] \n", - " + alpha_interblock(alpha_y[i,j-1], alpha_y[i,j]) * C_t[i,j-1])\n", + " + time_step/delta_y**2 * (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) * C_t[i+1,j]\n", + " - (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) + alpha_interblock(alpha_y[i-1,j], alpha_y[i,j])) * C_t[i,j] \n", + " + alpha_interblock(alpha_y[i-1,j], alpha_y[i,j]) * C_t[i-1,j]) \\\n", + " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) * C_t[i,j+1]\n", + " - (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) + alpha_interblock(alpha_x[i,j-1], alpha_x[i,j])) * C_t[i,j] \n", + " + alpha_interblock(alpha_x[i,j-1], alpha_x[i,j]) * C_t[i,j-1])\n", " \n", " # boundary conditions\n", - " # left\n", + " # left without corners / looping over rows\n", " for i in range(1, grid_size['y']-1):\n", + " j = 0\n", " C_t1[i,0] = C_t[i,0] \\\n", - " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,1], alpha_x[i,0]) * C_t[i,1] \n", - " - (alpha_interblock(alpha_x[i,1], alpha_x[i,0]) + 2 * alpha_x[i,0]) * C_t[i,0]\n", - " + 2 * alpha_x[i,0] * bc_left)\n", + " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) * C_t[i,j+1] \n", + " - (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) + 2 * alpha_x[i,j]) * C_t[i,j]\n", + " + 2 * alpha_x[i,j] * bc_left) \\\n", + " + time_step/delta_y**2 * (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) * C_t[i+1,j]\n", + " - (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) + alpha_interblock(alpha_y[i-1,j], alpha_y[i,j])) * C_t[i,j] \n", + " + alpha_interblock(alpha_y[i-1,j], alpha_y[i,j]) * C_t[i-1,j]) \n", "\n", - " # right\n", - " n = grid_size['x'] # maximum index in x-direction (columns)\n", + " # right without corners / looping over rows\n", + " n = grid_size['x']-1 # maximum index in x-direction (columns)\n", " for i in range(1, grid_size['y']-1):\n", + " j = n\n", " C_t1[i,n] = C_t[i,n] \\\n", - " + time_step/delta_x**2 * (2 * alpha_x[i,n] * bc_right \n", + " + time_step/delta_x**2 * (2 * alpha_x[i,n] * bc_right \n", " - (alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) + 2 * alpha_x[i,n]) * C_t[i,n]\n", - " + alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * C_t[i,n-1])\n", + " + alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * C_t[i,n-1]) \\\n", + " + time_step/delta_y**2 * (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) * C_t[i+1,j]\n", + " - (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) + alpha_interblock(alpha_y[i-1,j], alpha_y[i,j])) * C_t[i,j] \n", + " + alpha_interblock(alpha_y[i-1,j], alpha_y[i,j]) * C_t[i-1,j])\n", "\n", - " # top\n", + " # top without corners / looping over columns\n", " for j in range(1, grid_size['x']-1):\n", + " i = 0\n", " C_t1[0,j] = C_t[0,j] \\\n", - " + time_step/delta_y**2 * (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) * C_t[1,j] \n", + " + time_step/delta_y**2 * (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) * C_t[1,j] \n", + " - (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) + 2 * alpha_y[0,j]) * C_t[0,j]\n", + " + 2 * alpha_y[0,j] * bc_top) \\\n", + " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) * C_t[i,j+1]\n", + " - (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) + alpha_interblock(alpha_x[i,j-1], alpha_x[i,j])) * C_t[i,j] \n", + " + alpha_interblock(alpha_x[i,j-1], alpha_x[i,j]) * C_t[i,j-1])\n", + "\n", + " # bottom without corners / looping over columns\n", + " m = grid_size['y']-1 # maximum index in y-direction (rows)\n", + " for j in range(1, grid_size['x']-1):\n", + " i = m\n", + " C_t1[m,j] = C_t[m,j] \\\n", + " + time_step/delta_y**2 * (2 * alpha_y[m,j] * bc_bottom \n", + " - (alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) + 2 * alpha_y[m,j]) * C_t[m,j]\n", + " + alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) * C_t[m-1,j]) \\\n", + " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) * C_t[i,j+1]\n", + " - (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) + alpha_interblock(alpha_x[i,j-1], alpha_x[i,j])) * C_t[i,j] \n", + " + alpha_interblock(alpha_x[i,j-1], alpha_x[i,j]) * C_t[i,j-1])\n", + "\n", + " # corner top left\n", + " i = 0\n", + " j = i\n", + " C_t1[i,j] = C_t[i,j] \\\n", + " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) * C_t[i,j+1] \n", + " - (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) + 2 * alpha_x[i,j]) * C_t[i,j]\n", + " + 2 * alpha_x[i,j] * bc_left) \\\n", + " + time_step/delta_y**2 * (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) * C_t[1,j] \n", + " - (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) + 2 * alpha_y[0,j]) * C_t[0,j]\n", + " + 2 * alpha_y[0,j] * bc_top)\n", + " \n", + "\n", + " # corner top right\n", + " i = 0\n", + " j = grid_size['x']-1\n", + " n = j\n", + " C_t1[i,j] = C_t[i,j] \\\n", + " + time_step/delta_x**2 * (2 * alpha_x[i,n] * bc_right \n", + " - (alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) + 2 * alpha_x[i,n]) * C_t[i,n]\n", + " + alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * C_t[i,n-1]) \\\n", + " + time_step/delta_y**2 * (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) * C_t[1,j] \n", " - (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) + 2 * alpha_y[0,j]) * C_t[0,j]\n", " + 2 * alpha_y[0,j] * bc_top)\n", "\n", - " # bottom\n", - " m = grid_size['y'] # maximum index in y-direction (rows)\n", - " for j in range(1, grid_size['x']-1):\n", - " C_t1[m,j] = C_t[m,j] \\\n", - " + time_step/delta_y**2 * (2 * alpha_y[m,j] * bc_bottom \n", + " # corner bottom left\n", + " i = grid_size['y']-1\n", + " m = i\n", + " j = 0\n", + " C_t1[i,j] = C_t[i,j] \\\n", + " + time_step/delta_x**2 * (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) * C_t[i,j+1] \n", + " - (alpha_interblock(alpha_x[i,j+1], alpha_x[i,j]) + 2 * alpha_x[i,j]) * C_t[i,j]\n", + " + 2 * alpha_x[i,j] * bc_left) \\\n", + " + time_step/delta_y**2 * (2 * alpha_y[m,j] * bc_bottom \n", " - (alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) + 2 * alpha_y[m,j]) * C_t[m,j]\n", " + alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) * C_t[m-1,j])\n", "\n", + " # corner bottom right\n", + " i = grid_size['y']-1\n", + " j = grid_size['x']-1\n", + " m = i \n", + " n = j\n", + " C_t1[i,j] = C_t[i,j] \\\n", + " + time_step/delta_x**2 * (2 * alpha_x[i,n] * bc_right \n", + " - (alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) + 2 * alpha_x[i,n]) * C_t[i,n]\n", + " + alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * C_t[i,n-1]) \\\n", + " + time_step/delta_y**2 * (2 * alpha_y[m,j] * bc_bottom \n", + " - (alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) + 2 * alpha_y[m,j]) * C_t[m,j]\n", + " + alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) * C_t[m-1,j])\n", "\n", " return C_t1" ] }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 103, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -186,13 +250,13 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 105, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2855e9596fdf4770b7021cfff78c612d", + "model_id": "2f9cde999c5849f9b782f7e68bf424c9", "version_major": 2, "version_minor": 0 }, @@ -209,7 +273,7 @@ "" ] }, - "execution_count": 86, + "execution_count": 105, "metadata": {}, "output_type": "execute_result" } @@ -218,11 +282,67 @@ "def update(w = 1):\n", " fig = plt.figure(figsize = (10,7))\n", " y = records[w]\n", - " plt.imshow(y)\n", + " plt.imshow(y, vmin=0, vmax=0.1)\n", " \n", "interact(update, w = IntSlider(min=0, max = 999, step = 1, value = 0))" ] }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[800. 200. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [200. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "print(records[0])" + ] + }, { "cell_type": "code", "execution_count": null,