mirror of
https://git.gfz-potsdam.de/naaice/tug.git
synced 2025-12-13 09:28:23 +01:00
498 lines
80 KiB
Plaintext
498 lines
80 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# imports\n",
|
|
"import numpy as np\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"\n",
|
|
"%matplotlib notebook\n",
|
|
"%matplotlib inline\n",
|
|
"from ipywidgets import interact, IntSlider"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# set up environment\n",
|
|
"dim = 2\n",
|
|
"grid_size = {'x': 20, 'y': 20} # to start out\n",
|
|
"domain_size = {'x': 20, 'y': 20} # to start out\n",
|
|
"\n",
|
|
"# boundary_condition\n",
|
|
"# constant boundary condition\n",
|
|
"bc_left = 0\n",
|
|
"bc_right = 0\n",
|
|
"bc_top = 0\n",
|
|
"bc_bottom = 0\n",
|
|
"\n",
|
|
"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'],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",
|
|
"max_stable_time_step_y = delta_y**2 / (2 * np.max(alpha_y))\n",
|
|
"max_stable_time_step = max_stable_time_step_x if max_stable_time_step_x <= max_stable_time_step_y else max_stable_time_step_y\n",
|
|
"\n",
|
|
"time_step = 0.1\n",
|
|
"if time_step > max_stable_time_step:\n",
|
|
" print('Warning: Time step more than maximum stable time step!')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 15,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"# initialize environment with start values\n",
|
|
"C_t = np.zeros((grid_size['x'],grid_size['y']))\n",
|
|
"C_t[0,0] = 2000\n",
|
|
"# C_t[19,19] = 2000\n",
|
|
"\n",
|
|
"\n",
|
|
"plt.imshow(C_t, vmin=0, vmax=2000)\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# calculate mean between two cells\n",
|
|
"def alpha_interblock(alpha1, alpha2, harmonic=True):\n",
|
|
" if not harmonic:\n",
|
|
" return 0.5 * (alpha1 + alpha2)\n",
|
|
" else:\n",
|
|
" return 2 / ((1/alpha1) + (1/alpha2))\n"
|
|
]
|
|
},
|
|
{
|
|
"attachments": {},
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Implementation for constant boundary conditions"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# simulate one time step\n",
|
|
"def simulate_constant_boundary(C_t): \n",
|
|
" C_t1 = np.zeros((grid_size['x'],grid_size['y']))\n",
|
|
"\n",
|
|
" # inner cells\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_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]) \n",
|
|
" + 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]) \n",
|
|
" + 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 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,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]) \n",
|
|
" + 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 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",
|
|
" - (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[i+1,j], alpha_y[i,j]) * C_t[i+1,j]\n",
|
|
" - (alpha_interblock(alpha_y[i+1,j], alpha_y[i,j]) \n",
|
|
" + 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 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",
|
|
" - (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]) \n",
|
|
" + 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]) \n",
|
|
" + 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",
|
|
" # 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"
|
|
]
|
|
},
|
|
{
|
|
"attachments": {},
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Implementation for closed boundary conditions"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 17,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# simulate one time step\n",
|
|
"def simulate_closed_boundary(C_t): \n",
|
|
" C_t1 = np.zeros((grid_size['x'],grid_size['y']))\n",
|
|
"\n",
|
|
" # inner cells\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_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 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,j+1], alpha_x[i,j]) * (C_t[i,j+1] - C_t[i,j]))\\\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 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 * ( \n",
|
|
" - (alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * (C_t[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 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] - C_t[0,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",
|
|
" # 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 * ( \n",
|
|
" - (alpha_interblock(alpha_y[m,j], alpha_y[m-1,j]) * (C_t[m,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] - C_t[i,j]))\\\n",
|
|
" + time_step/delta_y**2 * (alpha_interblock(alpha_y[1,j], alpha_y[0,j]) * (C_t[1,j]-C_t[0,j]))\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 * (- (alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * (C_t[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] - C_t[0,j])) \n",
|
|
" \n",
|
|
"\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] - C_t[i,j])) \\\n",
|
|
" + time_step/delta_y**2 * (- (alpha_interblock(alpha_y[m,j], alpha_y[m-1,j] * (C_t[m,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 * (- alpha_interblock(alpha_x[i,n-1], alpha_x[i,n]) * (C_t[i,n] - C_t[i,n-1]))\\\n",
|
|
" + time_step/delta_y**2 * (- alpha_interblock(alpha_y[m,j], alpha_y[m-1,j] * (C_t[m,j] - C_t[m-1,j])))\n",
|
|
"\n",
|
|
" return C_t1"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 18,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"/var/folders/8m/wj5j2vnd3c776jn9kyzj818r0000gn/T/ipykernel_58661/2955654588.py:6: RuntimeWarning: divide by zero encountered in scalar divide\n",
|
|
" return 2 / ((1/alpha1) + (1/alpha2))\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 2 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"records = []\n",
|
|
"\n",
|
|
"for i in range(100):\n",
|
|
" C_t = simulate_closed_boundary(C_t)\n",
|
|
" records.append(C_t)\n",
|
|
"\n",
|
|
"# with np.printoptions(precision=2,floatmode='fixed',linewidth=200):\n",
|
|
"# print(C_t)\n",
|
|
"\n",
|
|
"plt.imshow(C_t, vmin=0, vmax=2000)\n",
|
|
"plt.colorbar()\n",
|
|
"plt.show()\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 19,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 640x480 with 2 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"plt.imshow(C_t)\n",
|
|
"plt.colorbar()\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"attachments": {},
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Widget"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 127,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"application/vnd.jupyter.widget-view+json": {
|
|
"model_id": "77835379be7343d0aff52d275a86be97",
|
|
"version_major": 2,
|
|
"version_minor": 0
|
|
},
|
|
"text/plain": [
|
|
"interactive(children=(IntSlider(value=0, description='w', max=999), Output()), _dom_classes=('widget-interact'…"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<function __main__.update(w=1)>"
|
|
]
|
|
},
|
|
"execution_count": 127,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"def update(w = 1):\n",
|
|
" fig = plt.figure(figsize = (10,7))\n",
|
|
" y = records[w]\n",
|
|
" plt.imshow(y, vmin=0, vmax=50)\n",
|
|
" \n",
|
|
"interact(update, w = IntSlider(min=0, max = 999, step = 1, value = 0))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 35,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 432x288 with 1 Axes>"
|
|
]
|
|
},
|
|
"metadata": {
|
|
"needs_background": "light"
|
|
},
|
|
"output_type": "display_data"
|
|
}
|
|
],
|
|
"source": [
|
|
"import matplotlib.animation as animation\n",
|
|
"\n",
|
|
"\n",
|
|
"frames = []\n",
|
|
"fig = plt.figure()\n",
|
|
"for i in records:\n",
|
|
" frames.append([plt.imshow(i, vmin=0, vmax=10, animated=True)])\n",
|
|
"\n",
|
|
"ani = animation.ArtistAnimation(fig, frames, interval=50, blit=True, repeat_delay=1000)\n",
|
|
"\n",
|
|
"ani.save(\"/Users/hannessigner/Desktop/test.gif\")"
|
|
]
|
|
}
|
|
],
|
|
"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.11.4"
|
|
},
|
|
"orig_nbformat": 4
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|