From 2290c638402b0dcf9e488d00062a6039c97cf5d2 Mon Sep 17 00:00:00 2001 From: Lukas Alber <36759141+luksen99@users.noreply.github.com> Date: Thu, 13 Jun 2019 14:54:42 +0200 Subject: [PATCH] Add files via upload --- Examples/BCN.ipynb | 338 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 338 insertions(+) create mode 100644 Examples/BCN.ipynb diff --git a/Examples/BCN.ipynb b/Examples/BCN.ipynb new file mode 100644 index 0000000..1c9d2f3 --- /dev/null +++ b/Examples/BCN.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modifying initial and boundary conditions\n", + "\n", + "In this file we demonstrate how to change \n", + "* Initial conditions\n", + "* Boundary conditions\n", + "* To make the simulation run, import all the packages needed: [TTMObject](https://github.com/udcm-su/heat-diffusion-1D/blob/master/Code/TTMObject.py),[Numpy](https://pypi.org/project/numpy/); [Matplotlib](https://pypi.org/project/matplotlib/) [B-splines](https://github.com/johntfoster/bspline); [Progressbar](https://pypi.org/project/tqdm/)\n", + "\n", + "### Initial and boundary conditions\n", + "\n", + "Two porperties every well posed pde requires are initial and boundary conditions. \n", + "Let us consider a coupled heat diffusion equation\n", + "\\begin{equation}\n", + "C_E\\partial_t T_E = k_E\\partial^2_x T_E + G(T_L-T_E)\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "C_L\\partial_t T_L = k_L\\partial^2_x T_L + G(T_E-T_L)\n", + "\\end{equation}\n", + "Initial conditions are of the form\n", + "\\begin{align}\n", + " T_E(x,t=0) &= f_E(x) \\\\ \\nonumber\n", + " T_L(x,t=0) &= f_L(x)\n", + "\\end{align}\n", + "Boundary conditions can be of two different types, either \\textit{Dirichlet} or \\textit{Neumann} type. \n", + "That is fixing either the value of or the flux on the left/ right end of the material under consideration. \n", + "\n", + "Dirichlet boundary conditions are of the form\n", + "\\begin{align}\n", + " T_E(x_0,t) &= d_E(t) \\qquad\\qquad &T_E(x=L,t) &= \\tilde{d}_E(t) \\\\ \\nonumber\n", + " T_L(x,t=0) &= d_L(t) \\qquad\\qquad &T_L(x=L,t) &= \\tilde{d}_L(t)\n", + "\\end{align}\n", + "Neumann boundary conditions are of the form\n", + "\\begin{align}\n", + " \\partial_x T_E(x_0,t) &= n_E(t) \\qquad\\qquad &\\partial_x T_E(x=L,t) &= \\tilde{n}_E(t) \\\\ \\nonumber\n", + " \\partial_x T_L(x,t=0) &= n_L(t) \\qquad\\qquad &\\partial_x T_L(x=L,t) &= \\tilde{n}_L(t)\n", + "\\end{align}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from TMMObject import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# We define all the material parameters for a 2TM simulation\n", + "L = 1e-5 # Length of the Material\n", + "Ce = 2e+4 # Specific Heat Electrons\n", + "Cl = 2.5e6 # Specific Heat Lattice\n", + "ke = 3.2e+1 # Conductivity Electrons\n", + "kl = 2.75 # Conductivity Lattica\n", + "G = 3e+16 # Exchange constant" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# If no specific source is indicated the fluence will be 0\n", + "s = source()\n", + "sim = simulation(2,s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to modify the initial and the boundary conditions of the equation use the command\n", + "\n", + "`.changeInit(system,function)` where\n", + "* `system` is a string or a number: \"electron\" or \"Electron\" or 0, \"lattice\" or \"Lattice\" or 1 and \"spin\" or \"Spin\" or 2\n", + "* `side` is a string: \"left\" $x = 0$ or \"right\" $x = L$\n", + "* function is a function $f_E(x)$, $f_L(x)$ or a number.\n", + "\n", + "`.changeBC_Type(system,side,type)` where\n", + "* `system` is a string or a number: \"electron\" or \"Electron\" or 0, \"lattice\" or \"Lattice\" or 1 and \"spin\" or \"Spin\" or 2\n", + "* `side` is a string: \"left\" $x = 0$ or \"right\" $x = L$\n", + "* `type` is a string: \"dirichlet\" or \"neumann\"\n", + "\n", + "`.changeBC_Value(system,side,function)` where\n", + "* `system` is a string or a number: \"electron\" or \"Electron\" or 0, \"lattice\" or \"Lattice\" or 1 and \"spin\" or \"Spin\" or 2\n", + "* `side` is a string: \"left\" $x = 0$ or \"right\" $x = L$\n", + "* `function` is a function (see top). \n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------------------------\n", + "The maunually chosen time step of 1.50e-13 is very small and will eventually cause a long simulation time.\n", + "We suggest a timestep of 1.24e-12 s\n", + "-----------------------------------------------------------\n", + "-----------------------------------------------------------\n", + "No source is applied.\n", + "source.fluence = 0\n", + "-----------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████| 13333/13333 [00:03<00:00, 4373.94it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------------------------\n", + "Heat diffusion in a coupled electron-lattice system has been simulated\n", + "Eleapsed time in E.E.- loop: 3.048281669616699\n", + "-----------------------------------------------------------\n" + ] + } + ], + "source": [ + "# Change initial and boundary conditions \n", + "sim.changeInit(\"electron\",lambda x: 600 + 300*np.cos(2*np.pi*x/L))\n", + "sim.changeInit(\"lattice\",300)\n", + "# Define Boundary Conditions\n", + "sim.changeBC_Type(0,\"left\",\"neumann\")\n", + "sim.changeBC_Type(\"Electron\",\"right\",1)\n", + "sim.changeBC_Type(\"lattice\",\"left\",1)\n", + "sim.changeBC_Type(1,\"right\",\"neumann\")\n", + "# Set a value on boundaries\n", + "sim.changeBC_Value(\"electron\",\"left\",0)\n", + "sim.changeBC_Value(\"Electron\",\"right\",0)\n", + "sim.changeBC_Value(1,\"left\",0)\n", + "sim.changeBC_Value(\"lattice\",\"right\",0)\n", + "# Modify the timestep to see fast dynamics\n", + "sim.final_time = 2e-9\n", + "sim.time_step = 1.5e-13\n", + "sim.addLayer(L, [ke, kl], [Ce, Cl], 1, [G])\n", + "# Run the simulation\n", + "[Te, Tl, x, t] = sim.run() " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "times of the first plot:\t[0.0e+00 1.5e-13 3.0e-13 4.5e-13]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot with the fast time dynamic\n", + "print(\"times of the first plot:\\t\" + str(t[0:4]))\n", + "plt.figure()\n", + "plt.title(\"Fast relaxation dynamics of the first time steps\")\n", + "plt.xlabel(\"Surface (m)\"); plt.ylabel(\"Temperature (K)\")\n", + "plt.plot(x,Te[0,:],\"r\",label = \"$T_e$\")\n", + "plt.plot(x,Tl[0,:],\"k--\",label = \"$T_l$\")\n", + "for i in range(1,4): \n", + " plt.plot(x,Te[i,:],\"r\")\n", + " plt.plot(x,Tl[i,:],\"k--\")\n", + "plt.legend()\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the \"neumann\" boundary conditions have been correctly applied, since the value of the temperature changes but the flux stays constant at 0. \n", + "\n", + "Now let us change the boundary conditions to \"dirichlet type\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------------------------\n", + "The maunually chosen time step of 1.50e-13 is very small and will eventually cause a long simulation time.\n", + "We suggest a timestep of 1.24e-12 s\n", + "-----------------------------------------------------------\n", + "-----------------------------------------------------------\n", + "No source is applied.\n", + "source.fluence = 0\n", + "-----------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████| 13333/13333 [00:02<00:00, 4564.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------------------------\n", + "Heat diffusion in a coupled electron-lattice system has been simulated\n", + "Eleapsed time in E.E.- loop: 2.921229839324951\n", + "-----------------------------------------------------------\n" + ] + } + ], + "source": [ + "sim = simulation(2,s)\n", + "\n", + "sim.changeInit(\"electron\",lambda x: 300 + np.sin(2*np.pi*x/L))\n", + "sim.changeInit(\"Lattice\",300)\n", + "# Define Boundary Conditions\n", + "sim.changeBC_Type(0,\"left\",\"dirichlet\")\n", + "sim.changeBC_Type(\"Electron\",\"right\",0)\n", + "sim.changeBC_Type(\"lattice\",\"left\",0)\n", + "sim.changeBC_Type(1,\"right\",\"dirichlet\")\n", + "# Set a value on boundaries\n", + "sim.changeBC_Value(\"electron\",\"left\",300)\n", + "sim.changeBC_Value(\"Electron\",\"right\",300)\n", + "sim.changeBC_Value(1,\"left\",300)\n", + "sim.changeBC_Value(\"lattice\",\"right\",300)\n", + "# Modify the timestep to see fast dynamics\n", + "sim.final_time = 2e-9\n", + "sim.time_step = 1.5e-13\n", + "sim.addLayer(L, [ke, kl], [Ce, Cl], 1, [G])\n", + "# Run the simulation\n", + "[Te, Tl, x, t] = sim.run() " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "times of the first plot:\t[0.0e+00 1.5e-13 3.0e-13 4.5e-13]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot with the fast time dynamic\n", + "print(\"times of the first plot:\\t\" + str(t[0:4]))\n", + "plt.figure()\n", + "plt.title(\"Fast relaxation dynamics of the first time steps\")\n", + "plt.xlabel(\"Surface (m)\"); plt.ylabel(\"Temperature (K)\")\n", + "plt.plot(x,Te[0,:],\"r\",label = \"$T_e$\")\n", + "plt.plot(x,Tl[0,:],\"k--\",label = \"$T_l$\")\n", + "for i in range(1,4): \n", + " plt.plot(x,Te[i,:],\"r\")\n", + " plt.plot(x,Tl[i,:],\"k--\")\n", + "plt.legend()\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now \"dirichlet\" boundary conditions are applied correctly and the value on the left and on the right end of the material are fixed. " + ] + } + ], + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}