diff --git a/Index.ipynb b/Index.ipynb index 0fcc8740fe21b0fc48c730e4aeac9f3452b87c22..153f387b52a9ef0a8207db8bcc91b929f57a3a9f 100644 --- a/Index.ipynb +++ b/Index.ipynb @@ -11,21 +11,22 @@ "The following notebooks are currently available: \n", "\n", "Lecture Examples:\n", - "- [Lecture 2 - Modified Nodal Analysis - without DPsim](./lectures/02_NA_MNA/VS_CS_R4_hard-coded.ipynb)\n", - "- [Lecture 2 - Modified Nodal Analysis - with DPsim](./lectures/02_NA_MNA/VS_CS_R4.ipynb)\n", - "- [Lecture 3 - Resistive Companion](./lectures/03_ResistiveCompanion/VS_R2L3.ipynb)\n", - "- [Lecture 4 - Nonlinear Resistive Companion](./lectures/04_NLResistiveCompanion/NL_RC.ipynb)\n", - "- [Lecture 5 - State Space Equations](./lectures/05_StateSpace/StateEq_ASMG.ipynb)\n", - "- [Lecture 8 - Dynamic Phasors](./lectures/08_DecoupledELMESim/VS_RL1.ipynb)\n", - "- [Lecture 9 - Diakoptics](./lectures/09_Diakoptics/Diakoptics.ipynb)\n", - "- [Lecture 9 - LIM](./lectures/09_LIM/LIM.ipynb)\n", - "- [Lecture 11 - Uncertain System Analysis](./lectures/11_UncertainSystemAnalysis/UncertainSystemAnalysis.ipynb)\n", + "- [Lecture 2 - Modified Nodal Analysis - without DPsim](./lectures/02_NA_MNA/Lecture_SimExample_MNA_withoutDPsim.ipynb)\n", + "- [Lecture 2 - Modified Nodal Analysis - with DPsim](./lectures/02_NA_MNA/Lecture_SimExample_MNA_DPsim.ipynb)\n", + "- [Lecture 3 - Resistive Companion](./lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion.ipynb)\n", + "- [Lecture 3 - Resistive Companion - automated](./lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion_automated.ipynb)\n", + "- [Lecture 4 - Nonlinear Resistive Companion](./lectures/04_NLResistiveCompanion/Lecture_SimExample_NLResistiveCompanion.ipynb)\n", + "- [Lecture 5 - State Space Equations](./lectures/05_StateSpace/Lecture_SimExample_StateSpace.ipynb)\n", + "- [Lecture 8 - Dynamic Phasors](./lectures/08_DecoupledELMESim/Lecture_SimExample_DecoupledELMESim.ipynb)\n", + "- [Lecture 9 - Diakoptics](./lectures/09_Diakoptics/Lecture_SimExample_Diakoptics.ipynb)\n", + "- [Lecture 9 - LIM](./lectures/09_LIM/Lecture_SimExample_LIM.ipynb)\n", + "- [Lecture 11 - Uncertain System Analysis](./lectures/11_UncertainSystemAnalysis/Lecture_SimExample_UncertainSystemAnalysis.ipynb)\n", "\n", "Exercise Examples:\n", - "- [Exercice 3 - ResistiveCompanion -Task 1](./exercises/03_ResistiveCompanion/CS_R1L1.ipynb)\n", - "- [Exercise 6 - Diakoptics - Extra Task](./exercises/06_Diakoptics_ExtraTask/Diakoptics_ExtraTask.ipynb)\n", - "- [Exercise 7 - LIM - Extra Task](./exercises/07_LIM_ExtraTask/LIM_Exercise_ExtraTask.ipynb)\n", - "- [Exercise 8 - Numerical Integration](./exercises/08_NumInt/NumInt_example.ipynb)\n", + "- [Exercice 3 - ResistiveCompanion -Task 1](./exercises/03_ResistiveCompanion/Exercise_SimExample_ResistiveCompanion_Task1.ipynb)\n", + "- [Exercise 6 - Diakoptics - Extra Task](./exercises/06_Diakoptics_ExtraTask/Exercise_SimExample_Diakoptics_ExtraTask.ipynb)\n", + "- [Exercise 7 - LIM - Extra Task](./exercises/07_LIM_ExtraTask/Exercise_SimExample_LIM_Exercise_ExtraTask.ipynb)\n", + "- [Exercise 8 - Numerical Integration](./exercises/08_NumInt/Exercise_SimExample_NumInt_example.ipynb)\n", "\n", "\n", "## Helping Material\n", diff --git a/exercises/03_ResistiveCompanion/CS_R1L1.ipynb b/exercises/03_ResistiveCompanion/CS_R1L1.ipynb deleted file mode 100644 index 1148b377ea5e19a715f4044d29841ed6baf90c05..0000000000000000000000000000000000000000 --- a/exercises/03_ResistiveCompanion/CS_R1L1.ipynb +++ /dev/null @@ -1,322 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MSP Simulation Example - Resistive Companion -" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sample Circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "<img src=\"Circuit_Exercise_Task1.png\" width=\"400\" align=\"left\">" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$R_1$ $=0.2 \\Omega$ <br>\n", - "$L_1$ $=1mH$ <br>\n", - "$I_1$$=10A$ <br> \n", - "$i_L(0)=0 $ <br>" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Circuit and Simulation Setup" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import ipywidgets as widget\n", - "import matplotlib.pyplot as plt\n", - "np.set_printoptions(sign=' ')\n", - "\n", - "# Circuit parameters\n", - "R1 = 0.2\n", - "L1 = 1e-3\n", - "I_src= 10\n", - "\n", - "G1 = 1/R1\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## DC equivalent of Inductor" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Equation of the inductor:\n", - "\n", - "$v_L(t) =L\\cdot\\frac{di_L}{dt}$\n", - "\n", - "### Integration: \n", - "\n", - "$i_L(t+\\Delta{t}) =i_L(t) + \\frac{1}{L} \\int_{t}^{t+\\Delta{t}} \\ v_L(\\tau) d\\tau$\n", - "\n", - "### Discretization: \n", - "\n", - "$i_L(k+1)= i_L(k) + \\frac{1}{L} \\int_{t_k}^{t_k+\\Delta{t}} \\ v_L(\\tau) d\\tau$\n", - "\n", - "### Application of trapezoidal rule: \n", - "\n", - "$i_L(k)= i_L(k) + \\frac{1}{L} \\frac{v_L(k)+v_L(k+1)}{2} \\Delta{t} $\n", - "\n", - "$i_L(k+1)=\\frac{\\Delta{t}}{2L} v_L(k+1) + (i_L(k) + \\frac{\\Delta{t}}{2L} v_L(k)) $\n", - "\n", - "The inductor in the calculation step (k + 1) can be substituted with an inductance $G_L = \\frac{\\Delta{t}}{2L}$ in parallel with a current source $A_L(k) = i_L(k) + \\frac{\\Delta{t}}{2L} v_L(k) $ \n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "<img src=\"Circuit_Exercise_Task1_DCequivalents.png\" width=\"400\" align=\"left\">" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run Simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5b3a37899f86449d97fc18b29df746aa", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value='Simulation start is pending...')" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6a93d5c93eee4a169836314b569e1d9b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "FloatProgress(value=0.0, max=0.0002)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Perform simulation with dpsim\n", - "import dpsim\n", - "\n", - "#Assign slider values to simulation parameters\n", - "model_name = 'CS_R1L1'\n", - "time_step = 1e-4\n", - "#Set final time to calculate first two simulation steps\n", - "final_time = 2e-4\n", - "\n", - "\n", - "# Nodes\n", - "gnd = dpsim.emt.Node.GND()\n", - "n1 = dpsim.emt.Node('n1')\n", - "\n", - "# Components\n", - "r1 = dpsim.emt.ph1.Resistor('r1')\n", - "r1.R = 0.2\n", - "l1 = dpsim.emt.ph1.Inductor('l1')\n", - "l1.L = 1e-3\n", - "cs = dpsim.emt.ph1.CurrentSource('cs')\n", - "cs.I_ref = complex(10,0)\n", - "cs.f_src = 0\n", - "\n", - "cs.connect([gnd, n1])\n", - "r1.connect([n1, gnd])\n", - "l1.connect([n1, gnd])\n", - "\n", - "\n", - "system = dpsim.SystemTopology(0, [gnd, n1], [cs, r1, l1])\n", - "\n", - "logger = dpsim.Logger(model_name)\n", - "logger.log_attribute(n1, 'v');\n", - "logger.log_attribute(r1, 'i_intf');\n", - "logger.log_attribute(l1, 'i_intf');\n", - "\n", - "sim = dpsim.Simulation(model_name, system, timestep=time_step, duration=final_time, pbar=True, sim_type=1, solver_type=0, log_level=4)\n", - "sim.add_logger(logger)\n", - "\n", - "sim.start()" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [], - "source": [ - "from villas.dataprocessing.readtools import *\n", - "from villas.dataprocessing.timeseries import *\n", - "import re\n", - "\n", - "work_dir = 'logs/'\n", - "log_path = work_dir + model_name + '_MNA.log'\n", - "log_lines, log_sections = read_dpsim_log(log_path)\n", - "\n", - "for line_pos in log_sections['sysmat_stamp']:\n", - " print(log_lines[line_pos])\n", - " \n", - "for line_pos in log_sections['sourcevec_stamp']:\n", - " print(log_lines[line_pos])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read and show solution log" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "l1.i_intf: [-0.09901 -0.295069]\n", - "n1.v: [ 1.980198 1.940986]\n", - "r1.i_intf: [-9.90099 -9.704931]\n" - ] - } - ], - "source": [ - "from villas.dataprocessing.readtools import *\n", - "from villas.dataprocessing.timeseries import *\n", - "import re\n", - "\n", - "work_dir = 'logs/'\n", - "model_name = 'CS_R1L1'\n", - "log_path = work_dir + model_name + '.csv'\n", - "ts_dpsim_emt = read_timeseries_dpsim(log_path, print_status=False)\n", - "\n", - "for key, val in ts_dpsim_emt.items():\n", - " print(key + ': ' + str(val.values))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot results" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "#Extract plot data\n", - "plot_data=ts_dpsim_emt[\"n1.v\"]\n", - "y_values= np.asarray(plot_data.values)\n", - "\n", - "#Add initial value\n", - "y_values= np.insert(y_values, 0, I_src*R1)\n", - "t = np.arange(npoint+1)*time_step\n", - "\n", - "plt.figure(figsize=(8,6))\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Voltage [V]')\n", - "plt.axis([0, 4*time_step, 1.9, 2.05])\n", - "plt.scatter(t,y_values, label='$e_{1}$(t)')\n", - "\n", - "#show corresponding values on the plot\n", - "for i in np.arange(npoint+1):\n", - " plt.annotate(' ' + str(np.round(y_values[i], 2)), (t[i], y_values[i]))\n", - "\n", - "plt.legend(loc='upper right')\n", - "plt.show()" - ] - }, - { - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/exercises/03_ResistiveCompanion/Exercise_SimExample_ResistiveCompanion_Task1.ipynb b/exercises/03_ResistiveCompanion/Exercise_SimExample_ResistiveCompanion_Task1.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3ac22ff25340b082f4722feb19ae166ca06b0db2 --- /dev/null +++ b/exercises/03_ResistiveCompanion/Exercise_SimExample_ResistiveCompanion_Task1.ipynb @@ -0,0 +1,323 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MSP Simulation Example - Resistive Companion -" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample Circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<img src=\"Circuit_Exercise_Task1.png\" width=\"400\" align=\"left\">" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$R_1$ $=0.2 \\Omega$ <br>\n", + "$L_1$ $=1mH$ <br>\n", + "$I_1$$=10A$ <br> \n", + "$i_L(0)=0 $ <br>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Circuit and Simulation Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import ipywidgets as widget\n", + "import matplotlib.pyplot as plt\n", + "np.set_printoptions(sign=' ')\n", + "\n", + "# Circuit parameters\n", + "R1 = 0.2\n", + "L1 = 1e-3\n", + "I_src= 10\n", + "\n", + "G1 = 1/R1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DC equivalent of Inductor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Equation of the inductor:\n", + "\n", + "$v_L(t) =L\\cdot\\frac{di_L}{dt}$\n", + "\n", + "### Integration: \n", + "\n", + "$i_L(t+\\Delta{t}) =i_L(t) + \\frac{1}{L} \\int_{t}^{t+\\Delta{t}} \\ v_L(\\tau) d\\tau$\n", + "\n", + "### Discretization: \n", + "\n", + "$i_L(k+1)= i_L(k) + \\frac{1}{L} \\int_{t_k}^{t_k+\\Delta{t}} \\ v_L(\\tau) d\\tau$\n", + "\n", + "### Application of trapezoidal rule: \n", + "\n", + "$i_L(k)= i_L(k) + \\frac{1}{L} \\frac{v_L(k)+v_L(k+1)}{2} \\Delta{t} $\n", + "\n", + "$i_L(k+1)=\\frac{\\Delta{t}}{2L} v_L(k+1) + (i_L(k) + \\frac{\\Delta{t}}{2L} v_L(k)) $\n", + "\n", + "The inductor in the calculation step (k + 1) can be substituted with an inductance $G_L = \\frac{\\Delta{t}}{2L}$ in parallel with a current source $A_L(k) = i_L(k) + \\frac{\\Delta{t}}{2L} v_L(k) $ \n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<img src=\"Circuit_Exercise_Task1_DCequivalents.png\" width=\"400\" align=\"left\">" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b1174390d53c43ba84574ecbde14157f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value='Simulation start is pending...')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d7851ddde8b445a1bfef2bf7cf7b9f78", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, max=0.0002)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Perform simulation with dpsim\n", + "import dpsim\n", + "\n", + "#Assign slider values to simulation parameters\n", + "model_name = 'CS_R1L1'\n", + "time_step = 1e-4\n", + "#Set final time to calculate first two simulation steps\n", + "final_time = 2e-4\n", + "#Number of simulation steps\n", + "npoint = int(np.round(final_time/time_step))\n", + "\n", + "# Nodes\n", + "gnd = dpsim.emt.Node.GND()\n", + "n1 = dpsim.emt.Node('n1')\n", + "\n", + "# Components\n", + "r1 = dpsim.emt.ph1.Resistor('r1')\n", + "r1.R = 0.2\n", + "l1 = dpsim.emt.ph1.Inductor('l1')\n", + "l1.L = 1e-3\n", + "cs = dpsim.emt.ph1.CurrentSource('cs')\n", + "cs.I_ref = complex(10,0)\n", + "cs.f_src = 0\n", + "\n", + "cs.connect([gnd, n1])\n", + "r1.connect([n1, gnd])\n", + "l1.connect([n1, gnd])\n", + "\n", + "\n", + "system = dpsim.SystemTopology(0, [gnd, n1], [cs, r1, l1])\n", + "\n", + "logger = dpsim.Logger(model_name)\n", + "logger.log_attribute(n1, 'v');\n", + "logger.log_attribute(r1, 'i_intf');\n", + "logger.log_attribute(l1, 'i_intf');\n", + "\n", + "sim = dpsim.Simulation(model_name, system, timestep=time_step, duration=final_time, pbar=True, sim_type=1, solver_type=0, log_level=4)\n", + "sim.add_logger(logger)\n", + "\n", + "sim.start()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from villas.dataprocessing.readtools import *\n", + "from villas.dataprocessing.timeseries import *\n", + "import re\n", + "\n", + "work_dir = 'logs/'\n", + "log_path = work_dir + model_name + '_MNA.log'\n", + "log_lines, log_sections = read_dpsim_log(log_path)\n", + "\n", + "for line_pos in log_sections['sysmat_stamp']:\n", + " print(log_lines[line_pos])\n", + " \n", + "for line_pos in log_sections['sourcevec_stamp']:\n", + " print(log_lines[line_pos])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read and show solution log" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "l1.i_intf: [-0.09901 -0.295069]\n", + "n1.v: [ 1.980198 1.940986]\n", + "r1.i_intf: [-9.90099 -9.704931]\n" + ] + } + ], + "source": [ + "from villas.dataprocessing.readtools import *\n", + "from villas.dataprocessing.timeseries import *\n", + "import re\n", + "\n", + "work_dir = 'logs/'\n", + "model_name = 'CS_R1L1'\n", + "log_path = work_dir + model_name + '.csv'\n", + "ts_dpsim_emt = read_timeseries_dpsim(log_path, print_status=False)\n", + "\n", + "for key, val in ts_dpsim_emt.items():\n", + " print(key + ': ' + str(val.values))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "#Extract plot data\n", + "plot_data=ts_dpsim_emt[\"n1.v\"]\n", + "y_values= np.asarray(plot_data.values)\n", + "\n", + "#Add initial value\n", + "y_values= np.insert(y_values, 0, I_src*R1)\n", + "t = np.arange(npoint+1)*time_step\n", + "\n", + "plt.figure(figsize=(8,6))\n", + "plt.xlabel('Time [ms]')\n", + "plt.ylabel('Voltage [V]')\n", + "plt.axis([0, 4*time_step, 1.9, 2.05])\n", + "plt.scatter(t,y_values, label='$e_{1}$(t)')\n", + "\n", + "#show corresponding values on the plot\n", + "for i in np.arange(npoint+1):\n", + " plt.annotate(' ' + str(np.round(y_values[i], 2)), (t[i], y_values[i]))\n", + "\n", + "plt.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/exercises/06_Diakoptics_ExtraTask/Diakoptics_ExtraTask.ipynb b/exercises/06_Diakoptics_ExtraTask/Exercise_SimExample_Diakoptics_ExtraTask.ipynb similarity index 97% rename from exercises/06_Diakoptics_ExtraTask/Diakoptics_ExtraTask.ipynb rename to exercises/06_Diakoptics_ExtraTask/Exercise_SimExample_Diakoptics_ExtraTask.ipynb index 2a3db5a0716b38eb578eee45027194fe8d5bee36..4a43677a6aa0072e6ad304b8e9d1d5c1d538e7c7 100644 --- a/exercises/06_Diakoptics_ExtraTask/Diakoptics_ExtraTask.ipynb +++ b/exercises/06_Diakoptics_ExtraTask/Exercise_SimExample_Diakoptics_ExtraTask.ipynb @@ -28,9 +28,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$z_1$: $1 \\Omega$, $z_2$: $1 \\Omega$, $z_3$: $1 \\Omega$, $z_4$: $1 \\Omega$, $z_5$: $1 \\Omega$, $z_7$: $1 \\Omega$, $z_8$: $1 \\Omega$ \n", - "$z_6$: $2 \\Omega$ \n", - "$E_1$: $15 V$, $E_2$: $3 V$, $E_3$: $-5 V$, $E_4$: $5 V$" + "$z_1$=$1 \\Omega$, $z_2$=$1 \\Omega$, $z_3$=$1 \\Omega$, $z_4$=$1 \\Omega$, $z_5$=$1 \\Omega$, $z_7$=$1 \\Omega$, $z_8$=$1 \\Omega$ \n", + "$z_6$=$2 \\Omega$ \n", + "$E_1$=$15 V$, $E_2$=$3 V$, $E_3$=$-5 V$, $E_4$=$5 V$" ] }, { @@ -529,9 +529,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/exercises/07_LIM_ExtraTask/LIM_Exercise_ExtraTask.ipynb b/exercises/07_LIM_ExtraTask/Exercise_SimExample_LIM_Exercise_ExtraTask.ipynb similarity index 99% rename from exercises/07_LIM_ExtraTask/LIM_Exercise_ExtraTask.ipynb rename to exercises/07_LIM_ExtraTask/Exercise_SimExample_LIM_Exercise_ExtraTask.ipynb index 861c6242e978051efe1e5849f11d05ebcd158c1d..dae31f3bbf4cb8eeef1018e7c968bf80efdf1968 100644 --- a/exercises/07_LIM_ExtraTask/LIM_Exercise_ExtraTask.ipynb +++ b/exercises/07_LIM_ExtraTask/Exercise_SimExample_LIM_Exercise_ExtraTask.ipynb @@ -336,9 +336,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/exercises/08_NumInt/NumInt_example.ipynb b/exercises/08_NumInt/Exercise_SimExample_NumInt_example.ipynb similarity index 99% rename from exercises/08_NumInt/NumInt_example.ipynb rename to exercises/08_NumInt/Exercise_SimExample_NumInt_example.ipynb index 94b374b4a9f69b01675bc7c4755aafa8312a38a3..1f9fe277d4ef30a28ce52c4e3289640b3ac6fabd 100644 --- a/exercises/08_NumInt/NumInt_example.ipynb +++ b/exercises/08_NumInt/Exercise_SimExample_NumInt_example.ipynb @@ -26,9 +26,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$L$: $1 mH$ \n", - "$E$: $2 V$ \n", - "$R$: $1.0 \\Omega$ " + "$L$=$1 mH$ \n", + "$E$=$2 V$ \n", + "$R$=$1.0 \\Omega$ " ] }, { @@ -203,9 +203,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/lectures/02_NA_MNA/Lecture_SimExample_MNA.png b/lectures/02_NA_MNA/Lecture_SimExample_MNA.png new file mode 100644 index 0000000000000000000000000000000000000000..88ae3b95a00fc96e6510e4545de8c1523b19dddc Binary files /dev/null and b/lectures/02_NA_MNA/Lecture_SimExample_MNA.png differ diff --git a/lectures/02_NA_MNA/Lecture_SimExample_MNA.svg b/lectures/02_NA_MNA/Lecture_SimExample_MNA.svg new file mode 100644 index 0000000000000000000000000000000000000000..f46e87ab4fa62663106f9e8a97efc4122a44aca3 --- /dev/null +++ b/lectures/02_NA_MNA/Lecture_SimExample_MNA.svg @@ -0,0 +1,1072 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<!-- Created with Inkscape (http://www.inkscape.org/) --> + +<svg + xmlns:osb="http://www.openswatchbook.org/uri/2009/osb" + xmlns:dc="http://purl.org/dc/elements/1.1/" + xmlns:cc="http://creativecommons.org/ns#" + xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:svg="http://www.w3.org/2000/svg" + xmlns="http://www.w3.org/2000/svg" + xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" + xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" + width="203.54483mm" + height="82.177002mm" + viewBox="0 0 203.54483 82.177002" + version="1.1" + id="svg4757" + sodipodi:docname="VS_CS_R4_HC.svg" + inkscape:version="0.92.2 (5c3e80d, 2017-08-06)"> + <defs + id="defs4751"> + <linearGradient + osb:paint="solid" + id="linearGradient5333"> + <stop + id="stop5335" + offset="0" + style="stop-color:#c50000;stop-opacity:1;" /> + </linearGradient> + <linearGradient + osb:paint="solid" + id="linearGradient5327"> + <stop + id="stop5329" + offset="0" + style="stop-color:#d70000;stop-opacity:1;" /> + </linearGradient> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="marker6768" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill:#ff0000;fill-opacity:0.94117647;fill-rule:evenodd;stroke:#ff0000;stroke-width:1.00000003pt;stroke-opacity:0.94117647" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path6770" /> + </marker> + <marker + inkscape:stockid="Arrow1Mend" + orient="auto" + refY="0" + refX="0" + id="marker6542" + style="overflow:visible" + inkscape:isstock="true"> + <path + id="path6544" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + transform="matrix(-0.4,0,0,-0.4,-4,0)" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="marker7065" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path7067" /> + </marker> + <marker + inkscape:stockid="Arrow1Mstart" + orient="auto" + refY="0" + refX="0" + id="marker6833" + style="overflow:visible" + inkscape:isstock="true"> + <path + inkscape:connector-curvature="0" + id="path6835" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + transform="matrix(0.4,0,0,0.4,4,0)" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="marker5585" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Lend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.8,0,0,-0.8,-10,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path5587" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="TriangleOutL" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="TriangleOutL"> + <path + inkscape:connector-curvature="0" + transform="scale(0.8)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 5.77,0 -2.88,5 V -5 Z" + id="path5355" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow2Lend" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow2Lend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-1.1,0,0,-1.1,-1.1,0)" + d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1" + id="path5234" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow1Send" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Send"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.2,0,0,-0.2,-1.2,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path5228" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow1Lend" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Lend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.8,0,0,-0.8,-10,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path5216" /> + </marker> + <pattern + id="EMFhbasepattern" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <pattern + id="EMFhbasepattern-7" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <pattern + id="EMFhbasepattern-9" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <pattern + id="EMFhbasepattern-94" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <marker + style="overflow:visible" + id="Arrow1Mend" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-7" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-6" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-78" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-3" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-4" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-9" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-5" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-60" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow2Send" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow2Send"> + <path + transform="matrix(-0.3,0,0,-0.3,0.69,0)" + d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z" + style="fill:#ff0000;fill-opacity:1;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1" + id="path945" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow2Send-5" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow2Send"> + <path + transform="matrix(-0.3,0,0,-0.3,0.69,0)" + d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z" + style="fill:#ff0000;fill-opacity:1;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1" + id="path945-1" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow2Send-5-1" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow2Send"> + <path + transform="matrix(-0.3,0,0,-0.3,0.69,0)" + d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z" + style="fill:#ff0000;fill-opacity:1;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1" + id="path945-1-3" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow2Send-53" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow2Send"> + <path + transform="matrix(-0.3,0,0,-0.3,0.69,0)" + d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z" + style="fill:#ff0000;fill-opacity:1;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1" + id="path945-11" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="marker6768-6" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill:#ff0000;fill-opacity:0.94117647;fill-rule:evenodd;stroke:#ff0000;stroke-width:1.00000003pt;stroke-opacity:0.94117647" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path6770-2" /> + </marker> + <marker + inkscape:stockid="Arrow1Mend" + orient="auto" + refY="0" + refX="0" + id="marker6542-5" + style="overflow:visible" + inkscape:isstock="true"> + <path + id="path6544-2" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + transform="matrix(-0.4,0,0,-0.4,-4,0)" + inkscape:connector-curvature="0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="marker7065-1" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path7067-8" /> + </marker> + <marker + inkscape:stockid="Arrow1Mstart" + orient="auto" + refY="0" + refX="0" + id="marker6833-5" + style="overflow:visible" + inkscape:isstock="true"> + <path + inkscape:connector-curvature="0" + id="path6835-1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + transform="matrix(0.4,0,0,0.4,4,0)" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="marker5585-3" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Lend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.8,0,0,-0.8,-10,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path5587-0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="TriangleOutL-9" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="TriangleOutL"> + <path + inkscape:connector-curvature="0" + transform="scale(0.8)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 5.77,0 -2.88,5 V -5 Z" + id="path5355-1" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow2Lend-9" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow2Lend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-1.1,0,0,-1.1,-1.1,0)" + d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1" + id="path5234-4" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow1Send-1" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Send"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.2,0,0,-0.2,-1.2,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path5228-0" /> + </marker> + <marker + inkscape:isstock="true" + style="overflow:visible" + id="Arrow1Lend-2" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Lend"> + <path + inkscape:connector-curvature="0" + transform="matrix(-0.8,0,0,-0.8,-10,0)" + style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path5216-5" /> + </marker> + <pattern + id="EMFhbasepattern-4" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <pattern + id="EMFhbasepattern-7-9" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <pattern + id="EMFhbasepattern-9-6" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <pattern + id="EMFhbasepattern-94-6" + patternUnits="userSpaceOnUse" + width="6" + height="6" + x="0" + y="0" /> + <marker + style="overflow:visible" + id="Arrow1Mend-3" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-2" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-7-0" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-6-3" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-78-6" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-3-7" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-4-7" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-9-3" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-5-6" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-60-9" + inkscape:connector-curvature="0" /> + </marker> + <marker + style="overflow:visible" + id="Arrow1Mend-3-5" + refX="0" + refY="0" + orient="auto" + inkscape:stockid="Arrow1Mend"> + <path + transform="matrix(-0.4,0,0,-0.4,-4,0)" + style="fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt" + d="M 0,0 5,-5 -12.5,0 5,5 Z" + id="path3774-2-1" + inkscape:connector-curvature="0" /> + </marker> + </defs> + <sodipodi:namedview + id="base" + pagecolor="#ffffff" + bordercolor="#666666" + borderopacity="1.0" + inkscape:pageopacity="0.0" + inkscape:pageshadow="2" + inkscape:zoom="0.98994949" + inkscape:cx="353.87006" + inkscape:cy="312.12699" + inkscape:document-units="mm" + inkscape:current-layer="layer1" + showgrid="false" + inkscape:snap-bbox="true" + inkscape:snap-global="false" + inkscape:window-width="1920" + inkscape:window-height="1017" + inkscape:window-x="-8" + inkscape:window-y="-8" + inkscape:window-maximized="1" + fit-margin-top="0" + fit-margin-left="0" + fit-margin-right="0" + fit-margin-bottom="0" /> + <metadata + id="metadata4754"> + <rdf:RDF> + <cc:Work + rdf:about=""> + <dc:format>image/svg+xml</dc:format> + <dc:type + rdf:resource="http://purl.org/dc/dcmitype/StillImage" /> + <dc:title></dc:title> + </cc:Work> + </rdf:RDF> + </metadata> + <g + inkscape:label="Ebene 1" + inkscape:groupmode="layer" + id="layer1" + transform="translate(-3.777849,-112.91426)"> + <g + transform="matrix(0.28222223,0,0,0.28222223,-400.12371,-69.13873)" + id="layer1-1" + inkscape:label="Layer 1"> + <g + transform="matrix(0.49999985,0,0,0.49999985,2.0346299,669.66961)" + id="g5866"> + <g + style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;letter-spacing:normal;word-spacing:normal;text-anchor:start;fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10.43299961;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" + id="g5868" + transform="matrix(1.0629921,0,0,-1.0629921,-186.02362,789.27165)" + xml:space="preserve" + stroke-miterlimit="10.433" + font-style="normal" + font-variant="normal" + font-weight="normal" + font-stretch="normal" + font-size-adjust="none" + letter-spacing="normal" + word-spacing="normal" /> </g> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text4374-40-4-2" + y="817.16931" + x="1426.1472" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:40px;line-height:125%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;writing-mode:lr-tb;text-anchor:start;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="817.16931" + x="1426.1472" + id="tspan4376-5-4-5" + sodipodi:role="line">V<tspan + id="tspan5481-7" + style="font-size:26.00036621px;baseline-shift:sub;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">0</tspan></tspan></text> + <a + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + transform="translate(1199.5396,73.616925)" + id="a5155-5-6"> + <circle + transform="translate(42.461945,154.40287)" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:round;stroke-miterlimit:4;stroke-dasharray:none" + id="path4153-2-2" + r="25.279066" + cy="554.54272" + cx="251.77907" /> + </a> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4159-3-9" + d="m 1485.8523,775.30093 h 17" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1494.3523,766.80093 v 17" + id="path4161-2-0" + inkscape:connector-curvature="0" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1485.8523,798.59382 h 17" + id="path4163-4-9" + inkscape:connector-curvature="0" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4177-0" + d="m 2102.7636,886.27557 -607.343,-0.86769" + style="fill:none;stroke:#000000;stroke-width:2.75646257;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <path + style="fill:none;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1799.4765,917.17068 v -30.6417" + id="path4179-5" + inkscape:connector-curvature="0" /> + <path + inkscape:connector-curvature="0" + id="path4181-7" + d="m 1771.0081,919.84174 h 56.25" + style="fill:none;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> + <path + style="fill:none;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1780.3831,927.34174 h 37.5" + id="path4183-0" + inkscape:connector-curvature="0" /> + <path + inkscape:connector-curvature="0" + id="path4185-0" + d="m 1789.7581,934.84173 h 18.75" + style="fill:none;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6" + d="M 1495.3081,885.08897 V 808.66199" + style="fill:none;stroke:#000000;stroke-width:2.95393491;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-4" + d="M 1698.2242,885.46082 V 806.41576" + style="fill:none;stroke:#000000;stroke-width:3.00410342;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-42" + d="m 2102.6986,885.31917 v -76.8677" + style="fill:none;stroke:#000000;stroke-width:2.96243954;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <circle + style="fill:#ff0000;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:square;stroke-miterlimit:4;stroke-dasharray:none" + id="circle5450-3-1-5" + cx="1799.3885" + cy="885.80603" + r="1.40625" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-9" + d="m 1494.5676,756.43092 0.5339,-61.3048" + style="fill:none;stroke:#000000;stroke-width:2.6771667;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:3.01448607;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1495.8666,695.03848 h 75.335" + id="path4151-1" + inkscape:connector-curvature="0" + sodipodi:nodetypes="cc" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-42-1" + d="m 1698.0833,694.69187 v 63.06075" + style="fill:none;stroke:#000000;stroke-width:2.68322468;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <g + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + transform="matrix(-0.99731855,0,0,-1.040594,1709.4468,807.80113)" + id="g6491-2-6-2"> + <path + inkscape:connector-curvature="0" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="M 11.420521,2.1149114 20.673259,6.0274974 2.1149114,13.746924 20.673259,21.46635 2.1149114,29.185777 20.673259,36.905204 2.1149114,44.62463 11.420521,48.484343" + id="path6493-1-2-0" /> + </g> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text4374-4-4-9-9" + y="792.48547" + x="1718.9456" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:40px;line-height:125%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;writing-mode:lr-tb;text-anchor:start;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="792.48547" + x="1718.9456" + id="tspan4376-0-8-0-2" + sodipodi:role="line">R<tspan + id="tspan5137-5-8" + style="font-size:26.00036621px;baseline-shift:sub;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">2</tspan></tspan></text> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text4374-4-4-4" + y="671.8587" + x="1578.9551" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:40px;line-height:125%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;writing-mode:lr-tb;text-anchor:start;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="671.8587" + x="1578.9551" + id="tspan4376-0-8-57" + sodipodi:role="line">R<tspan + id="tspan5137-8" + style="font-size:26.00036621px;baseline-shift:sub;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">1</tspan></tspan></text> + <g + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + transform="rotate(90,444.38064,1128.0064)" + id="g6491-2-5"> + <path + inkscape:connector-curvature="0" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 11.420521,-45.651296 9.252738,3.912586 -18.5583476,7.719427 18.5583476,7.719426 -18.5583476,7.719427 18.5583476,7.719427 -18.5583476,7.7194257 9.3056096,3.85971297" + id="path6493-1-7" /> + </g> + <text + id="text4154-2-4-73" + y="678.01044" + x="1481.6689" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.25px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.93749994" + xml:space="preserve"><tspan + style="font-size:37.5px;line-height:1.25;fill:#ff0000;fill-opacity:1;stroke-width:0.93749994" + y="678.01044" + x="1481.6689" + id="tspan4156-3-2-74" + sodipodi:role="line">e<tspan + id="tspan4510-3" + style="font-size:24.37534332px;baseline-shift:sub;fill:#ff0000;fill-opacity:1;stroke-width:0.93749994">1</tspan></tspan></text> + <circle + style="fill:#ff0000;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:square;stroke-miterlimit:4;stroke-dasharray:none" + id="circle5450-3-2" + cx="1495.209" + cy="695.29388" + r="1.40625" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:3.05892587;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1618.5475,695.03848 h 78.5655" + id="path4151-1-1" + inkscape:connector-curvature="0" /> + <text + id="text4154-2-4-7-9" + y="678.01044" + x="1684.0254" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.25px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.93749994" + xml:space="preserve"><tspan + style="font-size:37.5px;line-height:1.25;fill:#ff0000;fill-opacity:1;stroke-width:0.93749994" + y="678.01044" + x="1684.0254" + id="tspan4156-3-2-7-3" + sodipodi:role="line">e<tspan + id="tspan4510-9-2" + style="font-size:24.37534332px;baseline-shift:sub;fill:#ff0000;fill-opacity:1;stroke-width:0.93749994">2</tspan></tspan></text> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text3229-1-4-9-7-1-6" + y="855.71674" + x="1529.911" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.25px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-size:37.5px;line-height:1.25;fill:#ff0000;fill-opacity:1;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="855.71674" + x="1529.911" + id="tspan3231-7-0-4-1-4-8" + sodipodi:role="line">i<tspan + id="tspan4332-5" + style="font-size:24.375px;baseline-shift:sub;fill:#ff0000;fill-opacity:1;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">10</tspan></tspan></text> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path908-7" + d="m 1513.6748,828.03287 c 0,31.87286 0,31.87286 0,31.87286" + style="fill:none;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Send-53)" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:3.01448607;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1699.1904,695.2492 h 75.335" + id="path4151-1-9" + inkscape:connector-curvature="0" + sodipodi:nodetypes="cc" /> + <g + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + transform="rotate(90,545.9372,1229.7737)" + id="g6491-2-5-8"> + <path + inkscape:connector-curvature="0" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 11.420521,-45.651296 9.252738,3.912586 -18.5583476,7.719427 18.5583476,7.719426 -18.5583476,7.719427 18.5583476,7.719427 -18.5583476,7.7194257 9.3056096,3.85971297" + id="path6493-1-7-6" /> + </g> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:3.05892587;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1821.8713,695.2492 h 78.5655" + id="path4151-1-1-6" + inkscape:connector-curvature="0" /> + <text + id="text4154-2-4-7-9-2" + y="677.72479" + x="1886.1439" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.25px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.93749994" + xml:space="preserve"><tspan + style="font-size:37.5px;line-height:1.25;fill:#ff0000;fill-opacity:1;stroke-width:0.93749994" + y="677.72479" + x="1886.1439" + id="tspan4156-3-2-7-3-2" + sodipodi:role="line">e<tspan + id="tspan4510-9-2-0" + style="font-size:24.37534332px;baseline-shift:sub;fill:#ff0000;fill-opacity:1;stroke-width:0.93749994">3</tspan></tspan></text> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text4374-4-4-4-3" + y="671.55402" + x="1781.5505" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:40px;line-height:125%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;writing-mode:lr-tb;text-anchor:start;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="671.55402" + x="1781.5505" + id="tspan4376-0-8-57-4" + sodipodi:role="line">R<tspan + id="tspan5137-8-3" + style="font-size:26.00036621px;baseline-shift:sub;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">3</tspan></tspan></text> + <circle + style="fill:#ff0000;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:square;stroke-miterlimit:4;stroke-dasharray:none" + id="circle5450-3-7-3" + cx="1698.1267" + cy="695.29388" + r="1.40625" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-4-3" + d="M 1900.7288,885.5245 V 806.47945" + style="fill:none;stroke:#000000;stroke-width:3.00410342;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-42-1-6" + d="m 1900.5879,694.75556 v 63.06075" + style="fill:none;stroke:#000000;stroke-width:2.68322468;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <g + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + transform="matrix(-0.99731857,0,0,-1.040594,1911.9514,807.80113)" + id="g6491-2-6-2-1"> + <path + inkscape:connector-curvature="0" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="M 11.420521,2.1149114 20.673259,6.0274974 2.1149114,13.746924 20.673259,21.46635 2.1149114,29.185777 20.673259,36.905204 2.1149114,44.62463 11.420521,48.484343" + id="path6493-1-2-0-3" /> + </g> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text4374-4-4-9-9-3" + y="792.54919" + x="1921.4502" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:40px;line-height:125%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;writing-mode:lr-tb;text-anchor:start;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="792.54919" + x="1921.4502" + id="tspan4376-0-8-0-2-2" + sodipodi:role="line">R<tspan + id="tspan5137-5-8-7" + style="font-size:26.00036621px;baseline-shift:sub;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">4</tspan></tspan></text> + <a + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + transform="translate(1808.4576,73.616925)" + id="a5155-0"> + <circle + transform="translate(42.461945,154.40287)" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:round;stroke-miterlimit:4;stroke-dasharray:none" + id="path4153-3-1" + cx="251.77907" + cy="554.54272" + r="25.279066" /> + </a> + <text + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + id="text4374-40-1" + y="817.474" + x="2128.155" + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;line-height:0%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + xml:space="preserve"><tspan + style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:40px;line-height:125%;font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman, Italic';text-align:start;writing-mode:lr-tb;text-anchor:start;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none" + y="817.474" + x="2128.155" + id="tspan4376-5-7" + sodipodi:role="line">I<tspan + id="tspan5265-4" + style="font-size:26.00036621px;baseline-shift:sub;stroke-width:2.8125;stroke-miterlimit:4;stroke-dasharray:none">1</tspan></tspan></text> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path3759-6-1-1-2-3" + d="M 2102.6986,799.64417 V 771.95078" + style="fill:none;stroke:#000000;stroke-width:2.8125;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend-3-5)" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + inkscape:connector-curvature="0" + id="path4157-5-6-42-1-6-7" + d="m 2102.6986,695.08353 v 60.9358" + style="fill:none;stroke:#000000;stroke-width:2.63762927;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + sodipodi:nodetypes="cc" /> + <g + id="g7160"> + <g + id="g7139"> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:3.01448607;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1900.741,695.33301 h 75.335" + id="path4151-1-9-1" + inkscape:connector-curvature="0" + sodipodi:nodetypes="cc" /> + <path + inkscape:export-ydpi="1200" + inkscape:export-xdpi="1200" + style="fill:none;stroke:#000000;stroke-width:3.01448607;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + d="m 1974.4031,695.34662 h 75.335" + id="path4151-1-9-1-1" + inkscape:connector-curvature="0" + sodipodi:nodetypes="cc" /> + </g> + <path + inkscape:connector-curvature="0" + id="path4151-1-1-6-2" + d="m 2023.296,695.29238 h 79.021" + style="fill:none;stroke:#000000;stroke-width:3.06778073;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" + inkscape:export-xdpi="1200" + inkscape:export-ydpi="1200" /> + </g> + <circle + style="fill:#ff0000;stroke:#ff0000;stroke-width:2.8125;stroke-linecap:square;stroke-miterlimit:4;stroke-dasharray:none" + id="circle5450-3-7-3-0" + cx="1900.5228" + cy="695.29388" + r="1.40625" /> + </g> + </g> +</svg> diff --git a/lectures/02_NA_MNA/VS_CS_R4.ipynb b/lectures/02_NA_MNA/Lecture_SimExample_MNA_DPsim.ipynb similarity index 97% rename from lectures/02_NA_MNA/VS_CS_R4.ipynb rename to lectures/02_NA_MNA/Lecture_SimExample_MNA_DPsim.ipynb index c0e752bdffb1b9d7a40ba6b2f59fdc2e72f6740f..ea9f40d8d369979841069df9d754ee6aa6c7f78a 100644 --- a/lectures/02_NA_MNA/VS_CS_R4.ipynb +++ b/lectures/02_NA_MNA/Lecture_SimExample_MNA_DPsim.ipynb @@ -18,15 +18,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "<img src=\"VS_CS_R4.png\" width=\"500\" align=\"left\">" + "<img src=\"Lecture_SimExample_MNA.png\" width=\"500\" align=\"left\">" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "$R_1$: $1 \\Omega$, $R_2$: $1 \\Omega$, $R_3$: $10 \\Omega$, $R_4$: $5 \\Omega$ \n", - "$I_1$: $1 A$, $V_{in}$: $1 V$" + "$R_1$=$1 \\Omega$, $R_2$=$1 \\Omega$, $R_3$=$10 \\Omega$, $R_4$=$5 \\Omega$ \n", + "$I_1$=$1 A$, $V_{in}$=$1 V$" ] }, { diff --git a/lectures/02_NA_MNA/VS_CS_R4_hard-coded.ipynb b/lectures/02_NA_MNA/Lecture_SimExample_MNA_withoutDPsim.ipynb similarity index 96% rename from lectures/02_NA_MNA/VS_CS_R4_hard-coded.ipynb rename to lectures/02_NA_MNA/Lecture_SimExample_MNA_withoutDPsim.ipynb index 00f1c473469f95efacfa7ae9cc97c10be12180f8..da3ac26f397199f4ab28a63f158166b14a11ebb0 100644 --- a/lectures/02_NA_MNA/VS_CS_R4_hard-coded.ipynb +++ b/lectures/02_NA_MNA/Lecture_SimExample_MNA_withoutDPsim.ipynb @@ -18,15 +18,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "<img src=\"VS_CS_R4_HC.png\" width=\"500\" align=\"left\">" + "<img src=\"Lecture_SimExample_MNA.png\" width=\"500\" align=\"left\">" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "$R_1$: $1 \\Omega$, $R_2$: $1 \\Omega$, $R_3$: $10 \\Omega$, $R_4$: $5 \\Omega$ \n", - "$I_1$: $1 A$, $V_{0}$: $10 V$" + "$R_1$=$1 \\Omega$, $R_2$=$1 \\Omega$, $R_3$=$10 \\Omega$, $R_4$=$5 \\Omega$ \n", + "$I_1$=$1 A$, $V_{0}$=$10 V$" ] }, { diff --git a/lectures/03_ResistiveCompanion/VS_R2L3.ipynb b/lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion.ipynb similarity index 99% rename from lectures/03_ResistiveCompanion/VS_R2L3.ipynb rename to lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion.ipynb index cb9194bf6cb1812dc1f3ea72d1a84dedf9ed6f50..ba58796f590294810f550f8d85724f06216f601b 100644 --- a/lectures/03_ResistiveCompanion/VS_R2L3.ipynb +++ b/lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion.ipynb @@ -25,9 +25,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$R_1$: $1 \\Omega$, $R_2$: $2 \\Omega$ \n", - "$L_1$: $20 mH$, $L_2$: $100 mH$, $L_3$: $50 mH$ \n", - "$V_{in}(t)$: $10 V sin(\\omega t)$" + "$R_1$=$1 \\Omega$, $R_2$=$2 \\Omega$ \n", + "$L_1$=$20 mH$, $L_2$=$100 mH$, $L_3$=$50 mH$ \n", + "$V_{in}(t)$=$10 Vsin(\\omega t)$" ] }, { @@ -341,9 +341,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/lectures/03_ResistiveCompanion/VS_R2L3_automated.ipynb b/lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion_automated.ipynb similarity index 96% rename from lectures/03_ResistiveCompanion/VS_R2L3_automated.ipynb rename to lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion_automated.ipynb index feab639358e2f756e88428199ab784e690251dbf..33e26e1cb2596b62372ccc5b06d340904ba02068 100644 --- a/lectures/03_ResistiveCompanion/VS_R2L3_automated.ipynb +++ b/lectures/03_ResistiveCompanion/Lecture_SimExample_ResistiveCompanion_automated.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# MSP Simulation Example - Resistive Companion" + "# MSP Simulation Example - Resistive Companion - automated" ] }, { @@ -25,9 +25,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$R_1$: $1 \\Omega$, $R_2$: $2 \\Omega$ \n", - "$L_1$: $20 mH$, $L_2$: $100 mH$, $L_3$: $50 mH$ \n", - "$V_{in}(t)$: $10 V sin(\\omega t)$" + "$R_1$=$1 \\Omega$, $R_2$=$2 \\Omega$ \n", + "$L_1$=$20 mH$, $L_2$=$100 mH$, $L_3$=$50 mH$ \n", + "$V_{in}(t)$=$10 V sin(\\omega t)$" ] }, { @@ -39,13 +39,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "152d041133234e8b95ea9d98a6ac48a3", + "model_id": "1ce06daf45f447e197aaaf31c6fa2434", "version_major": 2, "version_minor": 0 }, @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -298,7 +298,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5439c86ab2bf4e1b8805445352e3c37c", + "model_id": "be28341ba95142f8a59b99b6d49c2e33", "version_major": 2, "version_minor": 0 }, @@ -373,5 +373,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/lectures/04_NLResistiveCompanion/Lecture_SimExample_NLResistiveCompanion.ipynb b/lectures/04_NLResistiveCompanion/Lecture_SimExample_NLResistiveCompanion.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c8286e5dda3fc9442937e61b1f1cb87064144254 --- /dev/null +++ b/lectures/04_NLResistiveCompanion/Lecture_SimExample_NLResistiveCompanion.ipynb @@ -0,0 +1,369 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MSP Simulation Example - Nonlinear Resistive Companion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample Circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<img src=\"NL_RC.png\" width=\"500\" align=\"left\">" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$E$=$10 V$, $R_S$=$1 \\Omega$, $C$=$10 uF$ \n", + "$i_R = g(v_R)= \\frac{v_R^2}{R_{NL}} $ \n", + "$R_{NL}$=$1 \\Omega$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulation Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Circuit parameters\n", + "E=10 \n", + "Rs=1\n", + "C=1e-5\n", + "\n", + "# Nonlinear resistor: U^2 = R_NL*I\n", + "R_NL=1\n", + "\n", + "# Total simulation time\n", + "T_total=0.001\n", + "\n", + "# Simulation time step\n", + "Ts = 1e-6\n", + "npoint = int(T_total/Ts)\n", + "\n", + "# Newton-Raphson method\n", + "# Max number of iterations\n", + "ite_max=100\n", + "\n", + "# error tolerance\n", + "tol=1e-4\n", + "\n", + "# Conductance for Rs\n", + "Gs=1/Rs\n", + "\n", + "#Conductance of the non-linear element for j-th iteration of Newton-Raphson method\n", + "#U^2 = R_NL*I\n", + "#I=U^2/R_NL\n", + "#dI/dU=2*U/R_NL\n", + "\n", + "# Node voltage vector\n", + "v1_trap = np.zeros(npoint)\n", + "v2_trap = np.zeros(npoint)\n", + "\n", + "# Current\n", + "i_trap = np.zeros(npoint)\n", + "\n", + "# Number of iterations in each time step\n", + "num_iter = np.zeros(npoint)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set Initial Conditions\n", + "- Precondition: $ u_C(0)=0 $ \n", + "- Analytic solution: $ \\frac{e_1(0)^2}{R_{NL}} = \\frac{E - e_1(0)}{R_s} $ $\\Rightarrow R_s e_1(0)^2 + R_{NL} \\cdot e_1(0) - R_{NL} E = 0 $" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated initial conditions: \n", + "\n", + "e1(0) = 2.778719262151\n", + "e2(0) = 0.0\n", + "iR(0) = 7.721280737848999\n" + ] + } + ], + "source": [ + "v1_trap[0] = (-R_NL + np.sqrt(R_NL^2+4*Rs*E*R_NL))/(2*Rs)\n", + "i_trap[0] = np.square(v1_trap[0])/R_NL\n", + "v2_trap[0] = 0\n", + "\n", + "print(\"Calculated initial conditions: \\n\")\n", + "print(\"e1(0) = \" + str(v1_trap[0]))\n", + "print(\"e2(0) = \" + str(v2_trap[0]))\n", + "print(\"iR(0) = \" + str(i_trap[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical Integration and Newton-Raphson Loop\n", + "- Application of Trapezoidal integration method" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# DC equivalent of capacitor\n", + "Gc=(2*C)/Ts\n", + "\n", + "# Numerical integration loop\n", + "for i in range(1, npoint):\n", + " # Update DC equivalent of capacitor\n", + " Ac=i_trap[i-1]+2*C/Ts*(v2_trap[i-1])\n", + "\n", + " #initial condition to start the Newton-Raphson \n", + " v1_new=v1_trap[i-1]+0.1\n", + " v2_new=v2_trap[i-1]\n", + " #ensures the while condition for start\n", + " v1_old=v1_new+5*tol\n", + " v2_old=v2_new+5*tol\n", + "\n", + " num_iter[i]=1\n", + "\n", + " #Newton-Raphston method loop\n", + " #Save example of set of NR iterations for plotting\n", + " Ts_index = 10 #index of time step in which we save iterations\n", + " if i==Ts_index:\n", + " V_exmp_NR = []\n", + " I_exmp_NR = []\n", + "\n", + " while num_iter[i]<=ite_max and (abs(v1_old-v1_new)>=tol or abs(v2_old-v2_new)>=tol):\n", + " #linearization of the NL element around the operating point (=di/du)\n", + " delta_v=v1_new-v2_new\n", + " G_NL = 2*delta_v/R_NL \n", + " J_NL = np.square(delta_v)/R_NL-G_NL*delta_v\n", + "\n", + " #admittance matrix\n", + " Gn=np.array([[ Gs+G_NL, -G_NL],\n", + " [ -G_NL, G_NL+Gc]])\n", + "\n", + " #source vector\n", + " Jn=np.array([E/Rs-J_NL,\n", + " J_NL+Ac])\n", + "\n", + " new_v=np.linalg.solve(Gn,Jn)\n", + "\n", + " v1_old=v1_new\n", + " v2_old=v2_new\n", + "\n", + " v1_new=new_v[0]\n", + " v2_new=new_v[1]\n", + "\n", + " num_iter[i]=num_iter[i]+1\n", + "\n", + " #Save example of set of NR iterations for plotting\n", + " if i==Ts_index:\n", + " V_exmp_NR.append(v1_new-v2_new)\n", + " I_exmp_NR.append(-Ac+v2_new*Gc)\n", + "\n", + " #operating point found -> assignement in the solution matrix\n", + " v1_trap[i]=v1_new\n", + " v2_trap[i]=v2_new\n", + "\n", + " # post step\n", + " i_trap[i] = -Ac + v2_trap[i]*Gc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulation Results\n", + "### Capacitor Voltage" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAGFCAYAAAA7JBDPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3debhdd13v8ff3nJOTsemQhNqkDR0oQwGh3IhgkaFFBBQqXBFQRECtExfE6wCi4uPVK+J00XsBK9ILMhWhXrheBAStiNTSQgt0AJqGTmnapGkzn2EP3/vHXifdOZxhpzl7r72y3q/n2c9Ze+01fNc6ST75/fZvrRWZiSRJqoaRsguQJEm9M7glSaoQg1uSpAoxuCVJqhCDW5KkCjG4JUmqEINbkqQKMbglSaoQg1vqQUTcFhHPLrsOdUTEjRHxzLLrkMpgcKsWIuJTEfF7c8y/OCLuiYixo9iWIV6yzHxsZl45897fierE4FZdvBd4RUTErPk/CXwgM5sl1DSUjuY/MceDuh2vqs/gVl38H2Ad8P0zMyLiZOCHgfcV7x8TEVdGxJ6iK/aFszcSEX8LbAb+b0QciIhfL+a/MSJujYj9EXFTRLyoa50nRcR1xWd/FxGXR8Tvd32+MSI+FhG7IuLbEfG6+Q5ioRoj4jci4qOzln97RPzFYvspWqy/ERFfAw7OFWYRcUZEXFGsvzsi/udix9617TcVnz0QEZdFxIoe151vn4db2HP9Thb7XfZyvPOc/58t6twbEf8YEQ/rZT1pSWWmL1+1eAF/Dby76/3PAdcX08uArcBvAuPAhcB+4FHF57cBz5493bWtlwAb6fxn+KXAQeC0Ylu3A68v9vFiYBr4/WK9EeDLwO8Uy54NbAN+cI76F6vx4cAh4ITi/SiwA3jKYvspjul64Axg5Rz7HgW+Cvw5sBpYATxtoWPvWvc24IZi26cA/951/POuu8g+j/gdzPr9LHie5jte4B3AOxb48/ObxTl8RLHddwOXlv3n2lf9XqUX4MvXoF7A04A9wIri/b8Dbyimvx+4BxjpWv5DwO8W093BcERozLOv64GLgacD24Ho+uwLXcH1vcAds9Z9E3DZHNtcsMaubb+ymP4B4NZe9lMc02sWOJ6nAruAsR7O8/XAxV3vbwN+vuv982fqWmjdhfa5SHD3cp4WPN459vcwOv+peOSsc3Id8GTgKuDzxX6Wlf1n3dfx/fK7HdVGZn4hIu4DfiQirqHzD+6Li483AndmZrtrlduBTb1sOyJeCfwKcGYxaw2wHlgJbM/M7ufn3tk1/XBgY0Ts6Zo3CvzbHLvppcYPAi+n0/3/48X7XvfTXddsZwC35xxjARY49m7d2769OJbF1p13n4vo9Xe50PHOdhGwHPhS1zCJoBPcdwIXZuZERPwhnf+wfXTOrUhLwOBW3bwPeCXwKODTmXlvMf9u4IyIGOn6B38z8K05tnHEQ+wj4uF0uuEvAq7KzFZEXE/nH/YdwKaIiK7wPgO4tZi+E/h2Zp7bQ+291Ph3wJ9GxOnAi+i0CnvdTy7w2Z3A5ogY6w7SRY692xld05uBu3tYd8599lB7r7/LhY53tlOAv8/Mlyyy3DTQXmQZ6Zg4OE118z7g2cDP0hlpPuNqOt8P/3pELCuuEX4B8OE5tnEvne+IZ6ymEwK7ACLi1cDjis+uAlrAayNiLCIuptPSn/ElYH8xUGplRIxGxOMi4nvm2O+iNWbmLuBK4DI6QX3zQ9jPXL5E5z8hb42I1RGxIiIuWOTYu/1SRJweEacAbwYu72Hd+fY5l+7fydH8Lnv1FeBZEfGkota10bmU8MHmd+c/Is8B/u8x7EdalMGtWsnM24Av0gmNT3TNn6bzj/vzgPvoDFR6ZWZ+Y47N/CHwW8WI5V/NzJuAP6UT0vcCj6fz/fnMdl8M/DSd79dfAfwDMFV83qIzsv2JwLeLfb8bOHGO2nut8YN0/nPywa51e97PXIr1X0BnYNYdwF3ASxc69jlq+gydAXG30vmOf8F159vnPCUe/p0Ar6P33+VhEfGuiHjXPMd/FfB7wMci4gBwE/DcmV6UiFgL/C3wqsxsLLQf6VjFkV+9Seq3iLgaeFdmXlZ2LYMQEbcBP5OZny27ln4oLiX7BPCnmfm5suvR8c8Wt9RnEfGMiPiuoqv8p4DvBj5Vdl1aMi+nM2r/t4trx+frFZCWhIPTpP57FPAROt3z24Afzcwd5ZakpZKZf0unm1waCLvKJUmqELvKJUmqEINbkqQKqcR33OvXr88zzzyz7DIkSRqIL3/5y/dl5oa5PqtEcJ955plce+21ZZchSdJARMTt831mV7kkSRVicEuSVCEGtyRJFWJwS5JUIQa3JEkVYnBLklQhBrckSRVicEuSVCEGtyRJFdK34I6I90TEzoi4oWveKRHxTxFxS/Hz5H7tX5Kk41E/W9z/G3jurHlvBD6XmecCnyveS5KkHvXtXuWZ+fmIOHPW7IuBZxbT7wWuBH6jXzVIOr5lZvETsmteFvMAkjw8zTzzs3tbXcuQneW69zHXcsmDBcy37yPWnVXPfMvNvJ9d++xPjtgeRzrys3nW6WGZo97mEcsvzfEcWfPi2+yubZ7JJTuWDWuW87hNJzIIg37IyKmZuaOYvgc4db4FI+IS4BKAzZs3D6A0DbPMpJ3QbLdptpJmO2m22rTaSaOdtFrZ+aydxeezpltJq915tXPmxRHvW2060+2kVXzenm+ddjGdSWax7ez843t4+Tm382CwtIvl28V78jvnZfF+9vLMXr8rVLrXbxcpcuT63dudvb8Hz3WStNtHnv9k5hi6A3KOIMuufwLnCFVm9jUrsB4Mvx5CVRoizznvVC595ZaB7Ku0p4NlZkbEvH8FM/NS4FKALVu2+Fe1ZI1Wm0PTLSamWxyabnamGzPvW0w0moc/n2q2mW62mW4VP7veTzVbTDfbcy9TTDeKsG21kka7COfW8P4RGAkYiWBkJBiN6LwfCUYiGC1+jgSHp6NY/vBPgK7pmc+ieN+9fBxepjM9EhBEsT5EjDAy0pk33/JQrFesO3v5zjY7+2RmmZi7jpltRHTORWdeHD43D86fvczM5w8e/4LLzZo/82ahZWbq7LmWrvkztX3nMkXND6GWmfnM2taR9c5dS7cjjumI+V3THLnykZ/NPb/7k/mX72Hf89VxLNvsoTaOcvm5/mwsVMNi5+fElcsYlEEH970RcVpm7oiI04CdA95/bWUm+yab7D4wxe6D0+w+MM2eQ9Psn2yyb7LBvolG13Tn58z7iekWzfbRB+ey0WB8dITxsa7X6AjLx0YPv1+zfIzxVUd+vmxshLGRYGxkhLHRKKaD0e73o8Uyow9+tmy0E5RjI92fjXQt0x2kM9N0BW4nxOYK3CjmjRb/aHdPx3z/wkpSHww6uD8B/BTw1uLnxwe8/+NSo9Xmnr2TbN8zwd3Fa/ueSe7eM8F9B6bYfWCa3Qen5m21jgScsGIZa1eOccLyzs/Np6xi7cplrFk+xqrxUVaNj7Ji2SirxjvvVxbzVi6bme7MXzE2yvJlnQAeGTHQJGmp9S24I+JDdAairY+Iu4C30Ansj0TETwO3Az/Wr/0fjw5NN7l5xz627jzArbsOcuvOA9y66wB33H+I2Q3i9WvGOe3ElZy6dgXnnbaWdWuWs37NOOvWjLNu9XJOWT3OKavHOWHFGKvHxwxZSaqIfo4qf/k8H13Ur30eTzKTW3cd4Kpt9/O1O/fwtbv2csvO/YcDenxshLPXr+axm07kBU/YyBknr2LjSSvZeNIKNp60khXLRss9AElSX5Q2OE3fad9kg8/dfC//+s1dfPHW3ezcPwXAutXjfPfpJ/KDj/suHr/pRB516glsOnklo7aSJal2DO6STTZafOqGe/iHr93N5791H9OtNuvXjPPUc9ZzwTnr+L5z1nPGKSsdACVJAgzu0tz1wCHe/x93cPk1d/DAoQYbT1zBTz714Tz/8adx/hkn+Z2zJGlOBveA3bN3kr/851u4/Jo7aWfynPO+i1c+9eE85ex1hrUkaVEG94BMN9v81b/eyv/8l6202snLn7yZX3jmOWw8aWXZpUmSKsTgHoAbtu/lVz5yPd+69wA/9PjT+I3nPprN61aVXZYkqYIM7j67/Jo7+O2P38gpq8Z5z6u2cOGj5709uyRJizK4+6TdTv7b/7uJy/79Np72iPW8/WVPZN2a5WWXJUmqOIO7D1rt5Nf+7qtccd12XnPBWbz5hx7jNdeSpCVhcC+xzOS3P34DV1y3nV99ziP5pWc9wmuwJUlLxuBeYn/5z1v54NV38IvPPIfXXnhu2eVIko4zI2UXcDy58ps7+fPPfosXn7+JX/vBR5VdjiTpOGRwL5F79k7yhsuv51GnnsAfvOjxdo9LkvrC4F4Cmclv/Z8bmGi0eMdPPImV4z6ZS5LUHwb3Evj0jffw2Zvv5Vd+4JGcvWFN2eVIko5jBvcxmmy0+N1P3MR5p63lNRecVXY5kqTjnMF9jN531W3cs2+St7zgPMZGPZ2SpP4yaY7B/skG77zyVr7/3PV879nryi5HklQDBvcxeO8Xb+OBQw1+9Tle+iVJGgyD+yGabrZ571W38/RHbuAJZ5xUdjmSpJowuB+iT359B7v2T/HqC84suxRJUo0Y3A/R+666jbPXr+YZ524ouxRJUo0Y3A/Btl0H+Mode3jp95zBiE/9kiQNkMH9EFzxle2MBLzo/E1llyJJqhmD+yhlJn9/3Xa+/9wNPGztirLLkSTVjMF9lL6+fS/b90zwgidsLLsUSVINGdxH6TM33svoSHDRox9WdimSpBoyuI/SZ266hyefeQonrx4vuxRJUg0Z3Efh9t0H+da9B3jOY08tuxRJUk0Z3Efh87fcB8AzH2U3uSSpHAb3Ufji1vvYeOIKzly3quxSJEk1ZXD3qN1Ortq2m+97xHoivOmKJKkcBnePbtqxjz2HGjztEevLLkWSVGMGd4/+Y9tuAJ56js/dliSVx+Du0XV37OH0k1dyqndLkySVyODu0XV3PMD5m08uuwxJUs0Z3D24Z+8kd++d5PwzTiq7FElSzRncPbjujgcAOH+zwS1JKpfB3YPr7tzD+OgI521cW3YpkqSaM7h7cMP2vTz6tBNYPjZadimSpJozuBeRmdy8Yx+P+S5b25Kk8hnci9i5f4oHDjV4zGknlF2KJEkG92Ju3rEPgEefZotbklQ+g3sRN+/YD2BXuSRpKBjci/jGPfvYeOIKTly1rOxSJEkyuBfzjR377SaXJA0Ng3sBrXby7d0HOfdha8ouRZIkwOBe0N17Jphutjlr/eqyS5EkCTC4F7TtvoMABrckaWgY3AvYtusAAGdvsKtckjQcSgnuiHhDRNwYETdExIciYigfcv3t+w5ywvIx1q8ZL7sUSZKAEoI7IjYBrwO2ZObjgFHgZYOuoxffvu8gZ21YTUSUXYokSUB5XeVjwMqIGANWAXeXVMeCtu066PfbkqShMvDgzsztwJ8AdwA7gL2Z+ZnZy0XEJRFxbURcu2vXrkGXyWSjxd17JwxuSdJQKaOr/GTgYuAsYCOwOiJeMXu5zLw0M7dk5pYNGzYMukzuemCCTHj4ulUD37ckSfMpo6v82cC3M3NXZjaAK4DvK6GOBW3fMwHA6Scb3JKk4VFGcN8BPCUiVkVn1NdFwM0l1LGgux44BMCmk1aWXIkkSQ8q4zvuq4GPAl8Bvl7UcOmg61jM9gcmGBsJTl07lFeqSZJqaqyMnWbmW4C3lLHvXm3fM8FpJ61gdMRLwSRJw8M7p81j+wMTdpNLkoaOwT2Pux6YYNNJDkyTJA0Xg3sO08029+6f5PSTbXFLkoaLwT2He/ZOkgmbDG5J0pAxuOdw157OpWCn+x23JGnIGNxzuHffJACnGdySpCFjcM/h3n1TADzshOUlVyJJ0pEM7jns3DfF6vFRVi8v5TJ3SZLmZXDP4d79k94xTZI0lAzuOezaN8UGu8klSUPI4J6DLW5J0rAyuGfJTHbum3JgmiRpKBncs+yfajLRaPGwtQa3JGn4GNyz7CwuBbOrXJI0jAzuWXYWN19xcJokaRgZ3LPs3G+LW5I0vAzuWWZud+rgNEnSMDK4Z7nvwBTLx0ZY413TJElDyOCeZffBadatHiciyi5FkqTvYHDP8sDBaU5ZM152GZIkzcngnuX+g9OcstrvtyVJw8ngnuX+Q9OcsmpZ2WVIkjQng3uW+w/Y4pYkDS+Du8tko8XB6RanrLbFLUkaTgZ3lwcOTQPY4pYkDS2Du8vuAzPBbYtbkjScDO4utrglScPO4O5y/8GZ4PY6bknScDK4uxjckqRhZ3B3uf/gNCMBJ670O25J0nAyuLvcf3Cak1aNMzrifcolScPJ4O7Sud2p3eSSpOFlcHd54NA0J3u7U0nSEDO4u+ydaPr9tiRpqBncXfZNNFhrcEuShpjB3WXfRIO1KwxuSdLwMrgLrXayf8qucknScDO4C/snGwB2lUuShprBXdg30QS8+YokabgZ3IW9E0WLe8VYyZVIkjQ/g7uwr+gqt8UtSRpmBnfhcIvb4JYkDTGDu7Bvwha3JGn4GdyFfY4qlyRVgMFd2DvRYHQkWD0+WnYpkiTNy+Au7JtosnbFGBE+0lOSNLwM7sLeiYbfb0uShp7BXdg36QNGJEnDz+Au2OKWJFWBwV3wyWCSpCooJbgj4qSI+GhEfCMibo6Ip5ZRR7e9E027yiVJQ6+sG3O/HfhUZv5oRIwDq0qq47D9kw3vUy5JGnoDT6qIOBF4OvAqgMycBqYHXUe3RqvNVLPNmuUGtyRpuJXRVX4WsAu4LCKui4h3R8TqEuo47OBU55Geqw1uSdKQKyO4x4AnAe/MzPOBg8AbZy8UEZdExLURce2uXbv6WtCBIrhtcUuShl0ZwX0XcFdmXl28/yidID9CZl6amVsyc8uGDRv6WtDBqRZgi1uSNPwGHtyZeQ9wZ0Q8qph1EXDToOvoduBwV7n3KZckDbd5m5gR8eIe1p/MzE8+hP3+F+ADxYjybcCrH8I2lsxBu8olSRWxUFL9NfBxYKGnbjwdOOrgzszrgS1Hu16/ODhNklQVCyXVP2bmaxZaOSLev8T1lGK/LW5JUkUs9B33ot3XmfmKJaylNHaVS5KqYqHg3l5cY31RHOcPqbarXJJUFQsF92OAa4DfojMK/O0R8ZTBlDVYB6ZajI+OMD7mM1ckScNt3qTKzN2Z+VeZ+SzgyXRGf/95RNwaEX8wsAoH4OBU00vBJEmV0FMTMzPvBv4GeCewH/iZfhY1aJ3gtptckjT8FgzuiFgRES+JiCuArcCFdG5PunEQxQ3KgammA9MkSZWw0A1YPgg8G/hX4APAj2fm5KAKGySDW5JUFQul1aeAn8vM/YMqpiwHp5qctGq87DIkSVrUQl3l9y8W2hHxw0tcTylscUuSqmKhtPrjiNjOwrc8/e/APyxtSYN3cKrlqHJJUiUsFNz3An+2yPq3LGEtpXFUuSSpKuZNq8x85gDrKE1mcnDarnJJUjXU/lZhE40W7fQ+5ZKkaqh9cB+Y9D7lkqTqMLh9MpgkqUIWDe6IWBURvx0Rf128P/d4uQwM4NB0C4BV444qlyQNv15a3JcBU8BTi/fbgd/vW0UDNtnoBPdKg1uSVAG9BPc5mfk2oAGQmYdY+NruSrHFLUmqkl6CezoiVgIJEBHn0GmBHxcmihb3imUGtyRp+PUyIustdO5bfkZEfAC4AHhVP4sapImixb3S4JYkVcCiwZ2Z/xQRXwGeQqeL/PWZeV/fKxuQmRb3qnFHlUuSht+iaRURTyomdxQ/N0fEicDtmdnsW2UDYotbklQlvTQz3wE8CfganRb344AbgRMj4hcy8zN9rK/vJhxVLkmqkF4Gp90NnJ+ZWzLzPwHnA9uAHwDe1s/iBmFiusXoSLBs9LgZKC9JOo71EtyPzMwbZ95k5k3AozNzW//KGpxD0y1WLRslwuCWJA2/XrrKb4yIdwIfLt6/FLgpIpZTXNtdZRONFivsJpckVUQvLe5XAVuBXy5e24p5DeBZ/SpsUCYbLQemSZIqo5fLwSaAPy1esx1Y8ooG7NB007umSZIqo5fLwc4F/hA4D1gxMz8zz+5jXQMz0Wh71zRJUmX0+pCRdwJNOl3j7wPe38+iBmnCFrckqUJ6Ce6Vmfk5IDLz9sz8XeCH+lvW4Ez4HbckqUJ6GVU+FREjwC0R8Vo6j/Vc09+yBufQtKPKJUnV0UuL+/XAKuB1wH8CXgG8sp9FDdJkcR23JElV0Etwn5mZBzLzrsx8dWb+Z2BzvwsblIlGy9udSpIqo5fgflOP8yrp0LTBLUmqjnm/446I5wHPBzZFxF90fbSWzgjzymu3k6lm28FpkqTKWGhw2t3Al4EXFj9n7Afe0M+iBuXBZ3Eb3JKkapg3uDPzq8BXI+L9x8Nzt+dy+JGetrglSRWxUFf514Espr/j88z87v6VNRgT053g9s5pkqSqWKir/IcHVkVJHuwq7+VydkmSyrdQV/ntM9MRcSrwPcXbL2Xmzn4XNggzLe6V470MrpckqXyLJlZE/BjwJeAlwI8BV0fEj/a7sEE4NBPcy2xxS5KqoZfEejPwPTOt7IjYAHwW+Gg/CxuEyZnBaY4qlyRVRC99xCOzusZ397je0HNUuSSpanppcX8qIj4NfKh4/1Lgk/0raXAe7Co3uCVJ1bBocGfmr0XEi4GnFbMuzcy/729ZgzHTVb7CwWmSpIpY6Dru/wV8MDP/PTOvAK4YXFmDMdVsA7B8zBa3JKkaFmpqfgv4k4i4LSLeFhFPHFRRgzLV7LS4l4/Z4pYkVcO8iZWZb8/MpwLPoDMg7bKI+EZEvCUiHjmwCvtoqjHT4ja4JUnVsGhiZebtmflHmXk+8HLgR4Cb+17ZAEw2WywfG5nzlq6SJA2jXm7AMhYRL4iIDwD/CHwTePGx7jgiRiPiuoj4h2Pd1kM11Wjb2pYkVcpCg9N+gE4L+/l07pz2YeCSzDy4RPt+PZ2W+9ol2t5Rm2q2We6lYJKkClmoufkm4IvAYzLzhZn5waUK7Yg4Hfgh4N1Lsb2HaqroKpckqSoWesjIhX3c7/8Afh04Yb4FIuIS4BKAzZs396WIqWbbR3pKkipl4M3NiPhhYGdmfnmh5TLz0szckplbNmzY0Jdaphq2uCVJ1VJGal0AvDAibqPzvfmFEfH+EurofMdtcEuSKmTgqZWZb8rM0zPzTOBlwD9n5isGXQfMjCq3q1ySVB21bm5ONVssX1brUyBJqpheng7WN5l5JXBlWfu3q1ySVDW1Tq3JRstR5ZKkSql1cNviliRVTa1TqxPctrglSdVR7+D2Om5JUsXUOrU69yqv9SmQJFVMbVOr2WrTbCcr7CqXJFVIbYN7qtkGsMUtSaqU2qbW4eC2xS1JqpAaB3cLwMFpkqRKqW1qTTXsKpckVU9tU2vycIvbrnJJUnXUNrhnWtwrbHFLkiqktqnl4DRJUhXVOLgdnCZJqp7aptbhwWm2uCVJFVLb4D48OM3vuCVJFVLb1HqwxV3bUyBJqqDaptbM4LQVy+wqlyRVR42D28FpkqTqqW1qeTmYJKmKahvck41Oi3vcFrckqUJqm1pTzTbLRoPRkSi7FEmSelbf4G60WWE3uSSpYuob3M2W3eSSpMqpbXJNN9uOKJckVU5tk2u61WaZwS1JqpjaJlej1WZ8tLaHL0mqqNom13SzzTKDW5JUMbVNrulW2lUuSaqc2ibXdLPFclvckqSKqW1yNVrJsjFvviJJqpYaB7eD0yRJ1VPb5HJwmiSpimqbXNOttndOkyRVTm2Ta7ppV7kkqXpqm1yNll3lkqTqqW1yTTftKpckVU9tk6vRSlvckqTKqW1yOThNklRFtUyuzCwGp3kDFklStdQyuJvtBLDFLUmqnFom13SzDeB33JKkyqllcjVaBrckqZpqmVwzLW67yiVJVVPL5JouWtzeOU2SVDW1TK5Gy8FpkqRqqmVyOThNklRVtUyumcFptrglSVVTy+SaOtzi9gYskqRqqWVwNxycJkmqqIEnV0ScERH/EhE3RcSNEfH6QddgV7kkqarGSthnE/ivmfmViDgB+HJE/FNm3jSoAhycJkmqqoEnV2buyMyvFNP7gZuBTYOswRa3JKmqSk2uiDgTOB+4epD7nbLFLUmqqNKSKyLWAB8Dfjkz983x+SURcW1EXLtr164l3ffhG7AY3JKkiikluSJiGZ3Q/kBmXjHXMpl5aWZuycwtGzZsWNL9e69ySVJVlTGqPIC/AW7OzD8b9P6h++lgXsctSaqWMpqcFwA/CVwYEdcXr+cPsgAHp0mSqmrgl4Nl5heAUpu6Dk6TJFVVLZPLO6dJkqqqlsk13WwzNhKMjPgdtySpWmoZ3I1W225ySVIl1TK9ppttB6ZJkiqpluk13Upb3JKkSqplejVabZbb4pYkVVAt02u62fbmK5KkSqplcDdafsctSaqmWqZXp8Vdy0OXJFVcLdNr2svBJEkVVcv0sqtcklRVtUyv6Wbb251KkiqplunVaKUtbklSJdUyvWbuVS5JUtXUMrgb7TbLbHFLkiqolunVbCXLbHFLkiqopsHdZszBaZKkCqplevmQEUlSVdUyvZpt71UuSaqmegZ3KxkbqeWhS5Iqrpbp1WjZ4pYkVVMtg7vZTsYMbklSBdUuuDOTVtuucklSNdUuvRqtBLCrXJJUSTUM7jaAl4NJkiqpdunVLFrc3oBFklRFtUuvRnumxW1XuSSpemoX3Idb3A5OkyRVUO3Sa+Y7bi8HkyRVUe2Cu9l2VLkkqbrqF9wzLW67yiVJFVS79Jr2cjBJUoXVLr2a3oBFklRh9Qvu9szgtNoduiTpOFC79Dp8y9MRW9ySpOqpXXB75zRJUpXVLr0aba/jliRVV+2C+/DgNC8HkyRVUO3S6/DTwcZscUuSqqe2we0NWCRJVVS79PI6bklSldUvuL2OW5JUYbVLL6/jliRVWe2C+/BDRmxxS5IqqHbpNfNYT6/jliRVUe2Ce+bpYOO2uCVJFVS79Dp8y1O/45YkVVANg7vT4h41uCVJFVS74G60k2WjQYTBLUmqntoFd6H7y4oAAAdTSURBVLPV9q5pkqTKql2CNVrpiHJJUmWVEtwR8dyI+GZEbI2INw5y3812m2WOKJckVdTAEywiRoH/BTwPOA94eUScN6j9N5rpfcolSZVVRtPzycDWzNyWmdPAh4GLB7XzRtvvuCVJ1TVWwj43AXd2vb8L+N7ZC0XEJcAlAJs3b16ynT/y1BOWbFuSJA1aGcHdk8y8FLgUYMuWLblU2/35Z5yzVJuSJGngyugz3g6c0fX+9GKeJElaRBnBfQ1wbkScFRHjwMuAT5RQhyRJlTPwrvLMbEbEa4FPA6PAezLzxkHXIUlSFZXyHXdmfhL4ZBn7liSpyrwuSpKkCjG4JUmqEINbkqQKMbglSaoQg1uSpAoxuCVJqhCDW5KkCjG4JUmqEINbkqQKicwle/BW30TELuD2JdzkeuC+JdxeHXkOl4bn8dh5Do+d5/DYLfU5fHhmbpjrg0oE91KLiGszc0vZdVSZ53BpeB6Pnefw2HkOj90gz6Fd5ZIkVYjBLUlShdQ1uC8tu4DjgOdwaXgej53n8Nh5Do/dwM5hLb/jliSpqura4pYkqZIqGdwR8dyI+GZEbI2IN87x+fKIuLz4/OqIOLPrszcV878ZET+42DYj4qxiG1uLbY73+/gGZcDn8QPF/Bsi4j0RsazfxzcIgzyHXZ//RUQc6NcxDdqA/xxGRPxBRHwrIm6OiNf1+/gGYcDn8KKI+EpEXB8RX4iIR/T7+AalT+fxPRGxMyJumLWtUyLinyLiluLnyT0XmpmVegGjwK3A2cA48FXgvFnL/CLwrmL6ZcDlxfR5xfLLgbOK7YwutE3gI8DLiul3Ab9Q9jmo6Hl8PhDF60PHw3kc9Dks1tsC/C1woOzjr+I5BF4NvA8YKd4/rOxzUMFz+C3gMV3b/d9ln4NhPY/FZ08HngTcMGtbbwPeWEy/EfijXmutYov7ycDWzNyWmdPAh4GLZy1zMfDeYvqjwEUREcX8D2fmVGZ+G9habG/ObRbrXFhsg2KbP9LHYxukgZ1HgMz8ZBaALwGn9/n4BmGg5zAiRoE/Bn69z8c1SAM9h8AvAL+XmW2AzNzZx2MblEGfwwTWFtMnAnf36bgGrR/nkcz8PHD/HPvr3tZRZUsVg3sTcGfX+7uKeXMuk5lNYC+wboF155u/DthTbGO+fVXVIM/jYUUX+U8CnzrmIyjfoM/ha4FPZOaOJap/GAz6HJ4DvDQiro2If4yIc5foOMo06HP4M8AnI+IuOn+X37okR1G+fpzHhZza9Xf5HuDUXgutYnCr2t4BfD4z/63sQqokIjYCLwH+suxaKm45MJmdO1z9NfCekuupojcAz8/M04HLgD8ruZ7KK3oie77Eq4rBvR04o+v96cW8OZeJiDE63Tm7F1h3vvm7gZOKbcy3r6oa5Hmk2MZbgA3AryzJEZRvkOfwfOARwNaIuA1YFRFbl+pASjToP4d3AVcU038PfPcxH0H5BnYOI2ID8ITMvLqYfznwfUtzGKXrx3lcyL0RcVqxrdOA3r+2KXtAwEMYQDAGbKMzAGBmAMFjZy3zSxw5gOAjxfRjOXIAwTY6AxLm3Sbwdxw5OO0Xyz4HFT2PPwN8EVhZ9rFX9RzO2u7xMjht0H8O3wq8pph+JnBN2eegSuewmH8f8Mhi/Z8GPlb2ORjW89i13pl85+C0P+bIwWlv67nWsk/WQzzBz6czsvFW4M3FvN8DXlhMr6ATuFvpDIQ6u2vdNxfrfRN43kLbLOafXWxja7HN5WUff0XPY7OYd33x+p2yj79q53DWfo+L4C7hz+FJwP8Dvg5cRaf1WPo5qNg5fFFx/r4KXNm9raq/+nQePwTsABp0enx+upi/DvgccAvwWeCUXuv0zmmSJFVIFb/jliSptgxuSZIqxOCWJKlCDG5JkirE4JYkqUIMbkmSKsTglo4TEbGueNTi9RFxT0Rs73r/xT7s71URsSsi3r3AMiuL/U9HxPqlrkGqo7HFF5FUBZm5G3giQET8Lp2btPxJn3d7eWa+doGaJoAnFrdplbQEbHFLNRARB4qfz4yIf42Ij0fEtoh4a0T8RER8KSK+HhHnFMttiIiPRcQ1xeuCHvbx2GI710fE146TJ29JQ8cWt1Q/TwAeQ+cZwduAd2fmkyPi9cB/AX4ZeDvw55n5hYjYDHy6WGchPw+8PTM/EBHjdO55LWmJGdxS/VyTxXOAI+JW4DPF/K8Dzyqmnw2cFxEz66yNiDWZeWCB7V4FvDkiTgeuyMxblr50SXaVS/Uz1TXd7nrf5sH/zI8AT8nMJxavTYuENpn5QeCFwATwyYi4cInrloTBLWlun6HTbQ5ARDxxsRUi4mxgW2b+BfBxjo9nXUtDx+CWNJfXAVuKQWY30fn+ejE/BtwQEdcDjwPe188CpbrysZ6SHpKIeBWwZaHLwbqWva1Y9r5+1yUd72xxS3qoJoDn9XIDFmAZne/QJR0jW9ySJFWILW5JkirE4JYkqUIMbkmSKsTgliSpQgxuSZIq5P8DOmLgH+esvnMAAAAASUVORK5CYII=\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "plt.plot(np.arange(0,T_total-Ts,Ts),v2_trap)\n", + "plt.title('Voltage over capacitor: $ e_{2} $')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('Voltage [V]')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Capacitor Current" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "plt.plot(np.arange(0,T_total-Ts,Ts),i_trap)\n", + "plt.title('Current through capacitor')\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('Current [A]')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## I-V Characteristic of Nonlinear Resistor" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "v_R_NL = v1_trap - v2_trap\n", + "plt.figure(figsize=(8,6))\n", + "plt.plot(v_R_NL,i_trap)\n", + "plt.xlabel('Voltage [V]')\n", + "plt.ylabel('Current [A]')\n", + "plt.plot(V_exmp_NR,I_exmp_NR, 'x') \n", + "plt.legend(['I-V characteristic of nonlinear resistor','N-R iterations within one sim time step'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Number of Newton-Raphson Iterations" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "plt.plot(np.arange(Ts,T_total-Ts,Ts),num_iter[1:])\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('# Iterations')\n", + "plt.show()" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/lectures/04_NLResistiveCompanion/NL_RC.ipynb b/lectures/04_NLResistiveCompanion/NL_RC.ipynb deleted file mode 100644 index 634dffcc2c9016cbfe859951af70926cf662b7d3..0000000000000000000000000000000000000000 --- a/lectures/04_NLResistiveCompanion/NL_RC.ipynb +++ /dev/null @@ -1,362 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MSP Simulation Example - Nonlinear Resistive Companion" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sample Circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "<img src=\"NL_RC.png\" width=\"500\" align=\"left\">" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$E$: $10 V$, $R_S$: $1 \\Omega$, $C$: $10 uF$ \n", - "$i_R = g(v_R)= \\frac{v_R^2}{R_{NL}} $ \n", - "$R_{NL}$: $1 \\Omega$ " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simulation Setup" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Circuit parameters\n", - "E=10 \n", - "Rs=1\n", - "C=1e-5\n", - "\n", - "# Nonlinear resistor: U^2 = R_NL*I\n", - "R_NL=1\n", - "\n", - "# Total simulation time\n", - "T_total=0.001\n", - "\n", - "# Simulation time step\n", - "Ts = 1e-6\n", - "npoint = int(T_total/Ts)\n", - "\n", - "# Newton-Raphson method\n", - "# Max number of iterations\n", - "ite_max=100\n", - "\n", - "# error tolerance\n", - "tol=1e-4\n", - "\n", - "# Conductance for Rs\n", - "Gs=1/Rs\n", - "\n", - "#Conductance of the non-linear element for j-th iteration of Newton-Raphson method\n", - "#U^2 = R_NL*I\n", - "#I=U^2/R_NL\n", - "#dI/dU=2*U/R_NL\n", - "\n", - "# Node voltage vector\n", - "v1_trap = np.zeros(npoint)\n", - "v2_trap = np.zeros(npoint)\n", - "\n", - "# Current\n", - "i_trap = np.zeros(npoint)\n", - "\n", - "# Number of iterations in each time step\n", - "num_iter = np.zeros(npoint)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set Initial Conditions\n", - "- Precondition: $ u_C(0)=0 $ \n", - "- Analytic solution: $ \\frac{e_1(0)^2}{R_{NL}} = \\frac{E - e_1(0)}{R_s} $ $\\Rightarrow R_s e_1(0)^2 + R_{NL} \\cdot e_1(0) - R_{NL} E = 0 $" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculated initial conditions: \n", - "\n", - "e1(0) = 2.778719262151\n", - "e2(0) = 0.0\n", - "iR(0) = 7.721280737848999\n" - ] - } - ], - "source": [ - "v1_trap[0] = (-R_NL + np.sqrt(R_NL^2+4*Rs*E*R_NL))/(2*Rs)\n", - "i_trap[0] = np.square(v1_trap[0])/R_NL\n", - "v2_trap[0] = 0\n", - "\n", - "print(\"Calculated initial conditions: \\n\")\n", - "print(\"e1(0) = \" + str(v1_trap[0]))\n", - "print(\"e2(0) = \" + str(v2_trap[0]))\n", - "print(\"iR(0) = \" + str(i_trap[0]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Numerical Integration and Newton-Raphson Loop\n", - "- Application of Trapezoidal integration method" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# DC equivalent of capacitor\n", - "Gc=(2*C)/Ts\n", - "\n", - "# Numerical integration loop\n", - "for i in range(1, npoint):\n", - " # Update DC equivalent of capacitor\n", - " Ac=i_trap[i-1]+2*C/Ts*(v2_trap[i-1])\n", - "\n", - " #initial condition to start the Newton-Raphson \n", - " v1_new=v1_trap[i-1]+0.1\n", - " v2_new=v2_trap[i-1]\n", - " #ensures the while condition for start\n", - " v1_old=v1_new+5*tol\n", - " v2_old=v2_new+5*tol\n", - "\n", - " num_iter[i]=1\n", - "\n", - " #Newton-Raphston method loop\n", - " #Save example of set of NR iterations for plotting\n", - " Ts_index = 10 #index of time step in which we save iterations\n", - " if i==Ts_index:\n", - " V_exmp_NR = []\n", - " I_exmp_NR = []\n", - "\n", - " while num_iter[i]<=ite_max and (abs(v1_old-v1_new)>=tol or abs(v2_old-v2_new)>=tol):\n", - " #linearization of the NL element around the operating point (=di/du)\n", - " delta_v=v1_new-v2_new\n", - " G_NL = 2*delta_v/R_NL \n", - " J_NL = np.square(delta_v)/R_NL-G_NL*delta_v\n", - "\n", - " #admittance matrix\n", - " Gn=np.array([[ Gs+G_NL, -G_NL],\n", - " [ -G_NL, G_NL+Gc]])\n", - "\n", - " #source vector\n", - " Jn=np.array([E/Rs-J_NL,\n", - " J_NL+Ac])\n", - "\n", - " new_v=np.linalg.solve(Gn,Jn)\n", - "\n", - " v1_old=v1_new\n", - " v2_old=v2_new\n", - "\n", - " v1_new=new_v[0]\n", - " v2_new=new_v[1]\n", - "\n", - " num_iter[i]=num_iter[i]+1\n", - "\n", - " #Save example of set of NR iterations for plotting\n", - " if i==Ts_index:\n", - " V_exmp_NR.append(v1_new-v2_new)\n", - " I_exmp_NR.append(-Ac+v2_new*Gc)\n", - "\n", - " #operating point found -> assignement in the solution matrix\n", - " v1_trap[i]=v1_new\n", - " v2_trap[i]=v2_new\n", - "\n", - " # post step\n", - " i_trap[i] = -Ac + v2_trap[i]*Gc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simulation Results\n", - "### Capacitor Voltage" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(8,6))\n", - "plt.plot(np.arange(0,T_total-Ts,Ts),v2_trap)\n", - "plt.title('Voltage over capacitor: $ e_{2} $')\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Voltage [V]')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Capacitor Current" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(8,6))\n", - "plt.plot(np.arange(0,T_total-Ts,Ts),i_trap)\n", - "plt.title('Current through capacitor')\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Current [A]')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## I-V Characteristic of Nonlinear Resistor" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "v_R_NL = v1_trap - v2_trap\n", - "plt.figure(figsize=(8,6))\n", - "plt.plot(v_R_NL,i_trap)\n", - "plt.xlabel('Voltage [V]')\n", - "plt.ylabel('Current [A]')\n", - "plt.plot(V_exmp_NR,I_exmp_NR, 'x') \n", - "plt.legend(['I-V characteristic of nonlinear resistor','N-R iterations within one sim time step'])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Number of Newton-Raphson Iterations" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(8,6))\n", - "plt.plot(np.arange(Ts,T_total-Ts,Ts),num_iter[1:])\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('# Iterations')\n", - "plt.show()" - ] - } - ], - "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 -} diff --git a/lectures/05_StateSpace/StateEq_ASMG.ipynb b/lectures/05_StateSpace/Lecture_SimExample_StateSpace.ipynb similarity index 99% rename from lectures/05_StateSpace/StateEq_ASMG.ipynb rename to lectures/05_StateSpace/Lecture_SimExample_StateSpace.ipynb index 90e7bcdaaf4efaa4eb1f31c43201103b8da02852..ce0c314408126cae91d6e4832f841915fdf84afe 100644 --- a/lectures/05_StateSpace/StateEq_ASMG.ipynb +++ b/lectures/05_StateSpace/Lecture_SimExample_StateSpace.ipynb @@ -26,9 +26,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$R_1$: $1 \\Omega$, $R_3$: $1 \\Omega$ \n", - "$L_1$: $20 mH$, $L_2$: $100 mH$, $L_3$: $50 mH$ \n", - "$V_{in}(t)$: $10 V sin(\\omega t)$" + "$R_1$=$1 \\Omega$, $R_3$=$1 \\Omega$ \n", + "$L_1$=$20 mH$, $L_2$=$100 mH$, $L_3$=$50 mH$ \n", + "$V_{in}(t)$=$10 V sin(\\omega t)$" ] }, { @@ -316,9 +316,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/lectures/08_DecoupledELMESim/VS_RL1.ipynb b/lectures/08_DecoupledELMESim/Lecture_SimExample_DecoupledELMESim.ipynb similarity index 99% rename from lectures/08_DecoupledELMESim/VS_RL1.ipynb rename to lectures/08_DecoupledELMESim/Lecture_SimExample_DecoupledELMESim.ipynb index e472aa7a7b688bee22e9334f10058cdfac42c861..aff6129aeaed5600ea8a7406d950dbfa04ba05a6 100644 --- a/lectures/08_DecoupledELMESim/VS_RL1.ipynb +++ b/lectures/08_DecoupledELMESim/Lecture_SimExample_DecoupledELMESim.ipynb @@ -13,7 +13,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$V_0$: $10 V$, $R$: $0.1 \\Omega$, $L$: $1 mH$" + "$V_0$=$10 V$, $R$=$0.1 \\Omega$, $L$=$1 mH$" ] }, { @@ -360,7 +360,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" }, "widgets": { "application/vnd.jupyter.widget-state+json": { @@ -715,5 +715,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/lectures/09_Diakoptics/Diakoptics.ipynb b/lectures/09_Diakoptics/Lecture_SimExample_Diakoptics.ipynb similarity index 96% rename from lectures/09_Diakoptics/Diakoptics.ipynb rename to lectures/09_Diakoptics/Lecture_SimExample_Diakoptics.ipynb index b3f36bdfb5cfe112f30a570798f6452b6ea166b5..2bc2252db678efd5321496623261a07534f4377c 100644 --- a/lectures/09_Diakoptics/Diakoptics.ipynb +++ b/lectures/09_Diakoptics/Lecture_SimExample_Diakoptics.ipynb @@ -28,9 +28,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$z_1$: $1 \\Omega$, $z_2$: $1 \\Omega$, $z_3$: $1 \\Omega$, $z_4$: $1 \\Omega$, $z_5$: $1 \\Omega$, $z_7$: $1 \\Omega$ \n", - "$z_2$: $1 \\Omega$, $z_8$: $1 \\Omega$ \n", - "$E_1$: $20 V$, $E_2$: $3 V$, $E_3$: $5 V$, $E_4$: $-5 V$" + "$z_1$=$1 \\Omega$, $z_2$=$1 \\Omega$, $z_3$=$1 \\Omega$, $z_4$=$1 \\Omega$, $z_5$=$1 \\Omega$, $z_7$=$1 \\Omega$ \n", + "$z_2$=$1 \\Omega$, $z_8$=$1 \\Omega$ \n", + "$E_1$=$20 V$, $E_2$=$3 V$, $E_3$=$5 V$, $E_4$=$-5 V$" ] }, { @@ -280,9 +280,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/lectures/09_LIM/LIM.ipynb b/lectures/09_LIM/LIM.ipynb deleted file mode 100644 index 0cde05c01cd90d562b234e0636817c5e624215c4..0000000000000000000000000000000000000000 --- a/lectures/09_LIM/LIM.ipynb +++ /dev/null @@ -1,282 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MSP Simulation Example\n", - "# System decoupling based on Latency Insertion Method (LIM)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sample Circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "<img src=\"Fig1_LIM.png\" width=\"400\" align=\"left\">" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$R$: $1 \\Omega$ \n", - "$R_1 = R_2 = R_3 = R$ \n", - "$L$: $0.5 mH$ \n", - "$C$: $0.5 mF$ \n", - "$C_1 = C_2 = C_3 = C$ \n", - "$I_3$: $1 A$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Circuit and Simulation Setup" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "np.set_printoptions(sign=' ')\n", - "\n", - "# Circuit parameters:\n", - "R = 1.0\n", - "L = 0.5e-3\n", - "C = 0.5e-3\n", - "I3 = 1.0" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Latency Insertion Method" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Incidence matrix\n", - "M = np.array([ [1, 1, 0],\n", - " [-1, 0, 1],\n", - " [0, -1, -1]])\n", - "\n", - "# Number of branches Nb and number of nodes Nn:\n", - "(Nn, Nb) = np.shape(M)\n", - "\n", - "# Branches\n", - "R_b = np.array([ [R, 0.5*R, R]])\n", - "L_b = np.array([ [0.5*L, L, 0.5*L]])\n", - "\n", - "# Nodes\n", - "R_n = np.array([ [R, R, R]])\n", - "C_n = np.array([ [C, C, C]])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simulation parameters " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total simulation time: 0.008\n", - "\n", - "Simulation time step: 0.0001\n", - "\n", - "Stability condition:\n", - " Ts < sqrt(Lk*Ck)\n", - "0.0001 < 0.00035355339059327376\n" - ] - } - ], - "source": [ - "# Total simulation time\n", - "T_total = 0.008\n", - "# Simulaiton time step \n", - "Ts = 0.1e-3\n", - "# Number of simulation time steps\n", - "npoint = int(np.round(T_total/Ts))\n", - "\n", - "print('Total simulation time: ' + str(T_total))\n", - "print('\\nSimulation time step: ' + str(Ts))\n", - "\n", - "# Stability condition\n", - "print('\\nStability condition:\\n Ts < sqrt(Lk*Ck)')\n", - "# Calculate maximum allowed time step based on circuit parameters \n", - "Ts_max = np.sqrt(np.amin([ [L_b[0,0]*C_n[0,0]], [L_b[0,0]*C_n[0,1]], [L_b[0,1]*C_n[0,0]], [L_b[0,1]*C_n[0,2]], [L_b[0,2]*C_n[0,1]], [L_b[0,2]*C_n[0,2]]])) \n", - "print(str(Ts) + ' < ' + str(Ts_max))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simulation loop " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Current source vectors for all nodes\n", - "H = np.zeros((npoint, Nn))\n", - "H[:,2] = I3*np.ones((npoint))\n", - "# Voltage source vectors for all branches\n", - "E = np.zeros((npoint, Nb))\n", - "\n", - "# Create matrix to store solution of branch currents in every simulation steps\n", - "I = np.zeros((npoint, Nb))\n", - "# Create matrix to store solution of node voltages in every simulation steps\n", - "V = np.zeros((npoint, Nn))\n", - "\n", - "# Initial conditions\n", - "# Branch inductances: current = 0\n", - "I[0,:] = np.zeros((1, Nb))\n", - "\n", - "# Node capacitance: voltage = 0\n", - "# Calculate V(Ts/2) based on a given initial conditions V(0)\n", - "V_0 = np.zeros((1, Nn))\n", - "for j in np.arange(0, Nn): \n", - " V[0,j] = (C_n[0,j]*V_0[0,j]/Ts - np.matmul(M[j,:], np.transpose(I[0,:])) + H[0,j]) / (C_n[0,j]/Ts + 1/R_n[0,j])\n", - " \n", - "# Time loop \n", - "for i in np.arange(1,npoint):\n", - " # Branch loop - calculation of I(i*Ts) based on I((i-1)*Ts) and V((i-1/2)*Ts)\n", - " for j in np.arange(0, Nb):\n", - " I[i,j] = I[i-1,j] + Ts/L_b[0,j] * (np.matmul(np.transpose(M[:,j]), np.transpose(V[i-1,:])) - R_b[0,j] * I[i-1,j] + E[i-1,j])\n", - " \n", - " # Node loop - calculation of V((i+1/2)*Ts) based on I(i*Ts) and V((i-1/2)*Ts)\n", - " for j in np.arange(0, Nn):\n", - " V[i,j] = (C_n[0,j]*V[i-1,j]/Ts - np.matmul(M[j,:], np.transpose(I[i,:])) + H[i,j]) / (C_n[0,j]/Ts + 1/R_n[0,j])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plots" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Time vectors\n", - "# for branch currents\n", - "t_I = np.arange(0, npoint)*Ts\n", - "# for node voltages\n", - "t_V = (np.arange(0, npoint) + 0.5)*Ts" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plots\n", - "plt.figure(figsize=(8,6))\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Current [A]')\n", - "plt.title('Branch currents')\n", - "plt.plot(t_I,I[:,0], t_I, I[:,1], t_I,I[:,2], linewidth=2)\n", - "plt.xlim([0, (npoint-1)*Ts])\n", - "plt.legend(['Current $i_{a}$(t)', 'Current $i_{b}$(t)', 'Current $i_{c}$(t)'], prop={'size': 14})\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plots\n", - "plt.figure(figsize=(8,6))\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Voltage [V]')\n", - "plt.title('Node voltages')\n", - "plt.plot(t_V,V[:,0], t_V, V[:,1], t_V,V[:,2], linewidth=2)\n", - "plt.xlim([0, (npoint-1)*Ts])\n", - "plt.legend(['Voltage $v_{1}$(t)', 'Voltage $v_{2}$(t)', 'Voltage $v_{3}$(t)'], prop={'size': 14})\n", - "plt.show()" - ] - } - ], - "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 -} diff --git a/lectures/09_LIM/Lecture_SimExample_LIM.ipynb b/lectures/09_LIM/Lecture_SimExample_LIM.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..42575852225cac9b535056080d150dc5ce009634 --- /dev/null +++ b/lectures/09_LIM/Lecture_SimExample_LIM.ipynb @@ -0,0 +1,282 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MSP Simulation Example\n", + "# System decoupling based on Latency Insertion Method (LIM)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample Circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<img src=\"Fig1_LIM.png\" width=\"400\" align=\"left\">" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$R$=$1 \\Omega$ \n", + "$R_1 = R_2 = R_3 = R$ \n", + "$L$=$0.5 mH$ \n", + "$C$=$0.5 mF$ \n", + "$C_1 = C_2 = C_3 = C$ \n", + "$I_3$=$1 A$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Circuit and Simulation Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "np.set_printoptions(sign=' ')\n", + "\n", + "# Circuit parameters:\n", + "R = 1.0\n", + "L = 0.5e-3\n", + "C = 0.5e-3\n", + "I3 = 1.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Latency Insertion Method" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Incidence matrix\n", + "M = np.array([ [1, 1, 0],\n", + " [-1, 0, 1],\n", + " [0, -1, -1]])\n", + "\n", + "# Number of branches Nb and number of nodes Nn:\n", + "(Nn, Nb) = np.shape(M)\n", + "\n", + "# Branches\n", + "R_b = np.array([ [R, 0.5*R, R]])\n", + "L_b = np.array([ [0.5*L, L, 0.5*L]])\n", + "\n", + "# Nodes\n", + "R_n = np.array([ [R, R, R]])\n", + "C_n = np.array([ [C, C, C]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulation parameters " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total simulation time: 0.008\n", + "\n", + "Simulation time step: 0.0001\n", + "\n", + "Stability condition:\n", + " Ts < sqrt(Lk*Ck)\n", + "0.0001 < 0.00035355339059327376\n" + ] + } + ], + "source": [ + "# Total simulation time\n", + "T_total = 0.008\n", + "# Simulaiton time step \n", + "Ts = 0.1e-3\n", + "# Number of simulation time steps\n", + "npoint = int(np.round(T_total/Ts))\n", + "\n", + "print('Total simulation time: ' + str(T_total))\n", + "print('\\nSimulation time step: ' + str(Ts))\n", + "\n", + "# Stability condition\n", + "print('\\nStability condition:\\n Ts < sqrt(Lk*Ck)')\n", + "# Calculate maximum allowed time step based on circuit parameters \n", + "Ts_max = np.sqrt(np.amin([ [L_b[0,0]*C_n[0,0]], [L_b[0,0]*C_n[0,1]], [L_b[0,1]*C_n[0,0]], [L_b[0,1]*C_n[0,2]], [L_b[0,2]*C_n[0,1]], [L_b[0,2]*C_n[0,2]]])) \n", + "print(str(Ts) + ' < ' + str(Ts_max))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulation loop " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Current source vectors for all nodes\n", + "H = np.zeros((npoint, Nn))\n", + "H[:,2] = I3*np.ones((npoint))\n", + "# Voltage source vectors for all branches\n", + "E = np.zeros((npoint, Nb))\n", + "\n", + "# Create matrix to store solution of branch currents in every simulation steps\n", + "I = np.zeros((npoint, Nb))\n", + "# Create matrix to store solution of node voltages in every simulation steps\n", + "V = np.zeros((npoint, Nn))\n", + "\n", + "# Initial conditions\n", + "# Branch inductances: current = 0\n", + "I[0,:] = np.zeros((1, Nb))\n", + "\n", + "# Node capacitance: voltage = 0\n", + "# Calculate V(Ts/2) based on a given initial conditions V(0)\n", + "V_0 = np.zeros((1, Nn))\n", + "for j in np.arange(0, Nn): \n", + " V[0,j] = (C_n[0,j]*V_0[0,j]/Ts - np.matmul(M[j,:], np.transpose(I[0,:])) + H[0,j]) / (C_n[0,j]/Ts + 1/R_n[0,j])\n", + " \n", + "# Time loop \n", + "for i in np.arange(1,npoint):\n", + " # Branch loop - calculation of I(i*Ts) based on I((i-1)*Ts) and V((i-1/2)*Ts)\n", + " for j in np.arange(0, Nb):\n", + " I[i,j] = I[i-1,j] + Ts/L_b[0,j] * (np.matmul(np.transpose(M[:,j]), np.transpose(V[i-1,:])) - R_b[0,j] * I[i-1,j] + E[i-1,j])\n", + " \n", + " # Node loop - calculation of V((i+1/2)*Ts) based on I(i*Ts) and V((i-1/2)*Ts)\n", + " for j in np.arange(0, Nn):\n", + " V[i,j] = (C_n[0,j]*V[i-1,j]/Ts - np.matmul(M[j,:], np.transpose(I[i,:])) + H[i,j]) / (C_n[0,j]/Ts + 1/R_n[0,j])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Time vectors\n", + "# for branch currents\n", + "t_I = np.arange(0, npoint)*Ts\n", + "# for node voltages\n", + "t_V = (np.arange(0, npoint) + 0.5)*Ts" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plots\n", + "plt.figure(figsize=(8,6))\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('Current [A]')\n", + "plt.title('Branch currents')\n", + "plt.plot(t_I,I[:,0], t_I, I[:,1], t_I,I[:,2], linewidth=2)\n", + "plt.xlim([0, (npoint-1)*Ts])\n", + "plt.legend(['Current $i_{a}$(t)', 'Current $i_{b}$(t)', 'Current $i_{c}$(t)'], prop={'size': 14})\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plots\n", + "plt.figure(figsize=(8,6))\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('Voltage [V]')\n", + "plt.title('Node voltages')\n", + "plt.plot(t_V,V[:,0], t_V, V[:,1], t_V,V[:,2], linewidth=2)\n", + "plt.xlim([0, (npoint-1)*Ts])\n", + "plt.legend(['Voltage $v_{1}$(t)', 'Voltage $v_{2}$(t)', 'Voltage $v_{3}$(t)'], prop={'size': 14})\n", + "plt.show()" + ] + } + ], + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/lectures/11_UncertainSystemAnalysis/Lecture_SimExample_UncertainSystemAnalysis.ipynb b/lectures/11_UncertainSystemAnalysis/Lecture_SimExample_UncertainSystemAnalysis.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..bd12ceb8cec9a7cc6e33a574bfef40a1514437e5 --- /dev/null +++ b/lectures/11_UncertainSystemAnalysis/Lecture_SimExample_UncertainSystemAnalysis.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MSP Simulation Example\n", + "# Uncertain System Analysis - Classical Polynomial Chaos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample Circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<img src=\"Circuit_RL.png\" width=\"300\" align=\"left\">" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$L$=$5 mH$ \n", + "$E$=$2 V$ \n", + "\n", + "Uncertain parameter in the system is the resistance with the uniform distribution: \n", + "$R$=$R_0 \\pm \\Delta R $ \n", + "$R_0$=$0.4 \\Omega$ \n", + "$\\Delta R$=$0.05 \\Omega$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Deterministic Solution of the Circuit\n", + "\n", + "Euler-Forward integration method: \n", + "$I(k) = (1-T_s*R/L) * I(k-1) + Ts/L*E$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Circuit and Simulation Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total simulation time: 0.08\n", + "\n", + "Simulation time step: 0.0001\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "np.set_printoptions(sign=' ')\n", + "\n", + "# Circuit parameters:\n", + "E = 2.0\n", + "L = 5.0e-3\n", + "R0 = 0.4\n", + "R1 = 0.05\n", + "\n", + "# Total simulation time\n", + "T_total = 0.08\n", + "# Simulaiton time step \n", + "Ts = 0.1e-3\n", + "# Number of simulation time steps\n", + "npoint = int(np.round(T_total/Ts))\n", + "\n", + "print('Total simulation time: ' + str(T_total))\n", + "print('\\nSimulation time step: ' + str(Ts))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Monte Carlo Simulation Method" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random variable: \n", + "[-0.03382022 -0.26064687 0.42104193 -0.01571603 0.14825974 -0.10087445\n", + " -0.33382349 0.62424228 -0.28552594 0.52462936 -0.21219342 0.31666295\n", + " 0.81388097 -0.21956619 -0.68180279 0.62330924 -0.29738313 -0.2292528\n", + " -0.18171685 0.81949358 0.35059198 -0.52295209 -0.79586213 -0.81607624\n", + " 0.18261823 0.35595208 -0.44630581 0.2764103 0.88274987 -0.34479962\n", + " 0.48479937 -0.72174464 0.45394889 0.06062419 0.44847019 0.4983825\n", + " 0.71375993 0.12672999 -0.95282819 0.61948332]\n", + "\n", + " Resistor R: \n", + "[[ 0.39830899 0.38696766 0.4210521 0.3992142 0.40741299 0.39495628\n", + " 0.38330883 0.43121211 0.3857237 0.42623147 0.38939033 0.41583315\n", + " 0.44069405 0.38902169 0.36590986 0.43116546 0.38513084 0.38853736\n", + " 0.39091416 0.44097468 0.4175296 0.3738524 0.36020689 0.35919619\n", + " 0.40913091 0.4177976 0.37768471 0.41382052 0.44413749 0.38276002\n", + " 0.42423997 0.36391277 0.42269744 0.40303121 0.42242351 0.42491912\n", + " 0.435688 0.4063365 0.35235859 0.43097417]]\n" + ] + } + ], + "source": [ + "# Number of samples for Monte Carlo simultion runs \n", + "N = 40\n", + "\n", + "# Generate random variable \n", + "rand_var = np.random.uniform(-1, 1, N)\n", + "print('Random variable: \\n' + str(rand_var))\n", + "\n", + "# R is a random parameter with the uniform distribution R= R0 + R1*rand_var \n", + "R = np.array([ R0 + R1*rand_var ])\n", + "print('\\n Resistor R: \\n' + str(R))\n", + "\n", + "# Solution vector for current I\n", + "# Each row refers to a solution vector obtained in one Monte Carlo simulation run\n", + "I = np.zeros((N, npoint)) \n", + "\n", + "# Monte Carlo simulation loop (for each sample of random parameter R)\n", + "for j in np.arange(0,N-1):\n", + " # Value of random parameter R for this Monte Carlo simulation run\n", + " Rj = R[0, j]\n", + " \n", + " # Time loop\n", + " # Initial condition\n", + " I[j,0]=0;\n", + " for i in np.arange(1,npoint):\n", + " # Euler Forward used for discretization \n", + " I[j,i] = (1-Ts*Rj/L) * I[j,i-1] + Ts/L*E" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plots\n", + "# Time vector\n", + "t = np.arange(0, npoint)*Ts\n", + "\n", + "plt.figure(figsize=(8,6))\n", + "for j in np.arange(0,N-1):\n", + " plt.plot(t,I[j,:], linewidth=1)\n", + "\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('Current [A]')\n", + "plt.title('Monte Carlo simulation results')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classical Polynomial Chaos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Polynomial Chaos (PC) expansion \n", + "\n", + "PC expansion of $R$: \n", + "$R = \\sum_{i=0}^{P}R_i\\Phi_i(\\xi) = R_0\\Phi_0(\\xi) + R_1\\Phi_1(\\xi)$ \n", + "\n", + "PC expansion of $i(t)$: \n", + "$I = \\sum_{i=0}^{P}I_i(t)\\Phi_i(\\xi) = I_0(t)\\Phi_0(\\xi) + I_1(t)\\Phi_1(\\xi)$ \n", + "\n", + "Circuit solution: \n", + "$I(k) = (1-T_s*R/L) * I(k-1) + Ts/L*E = I(k-1) - T_s/L*R*I(k-1) + Ts/L*E$ \n", + "\n", + "Replacing $R$ and $I$ to the solution equation: \n", + "$\\sum_{i=0}^{P}I_i(k)\\Phi_i = \\sum_{i=0}^{P}I_i(k-1)\\Phi_i - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)\\Phi_i\\Phi_j + T_s/L*E$\n", + "\n", + "Applying Galerkin projection on the PC basis and by replcing integrals with inner products: \n", + "$\\sum_{i=0}^{P}I_i(k)<\\Phi_i\\Phi_s> = \\sum_{i=0}^{P}I_i(k-1)<\\Phi_i\\Phi_s> - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\n", + "\\Phi_j\\Phi_s> + T_s/L*E$\n", + "\n", + "Inner product of two orthogonal polynomials can be replaced by the following identity: \n", + "$<\\Phi_i\\Phi_s> = <\\Phi_s^2>\\delta_{is}$ \n", + "where $\\delta_{is}$ is Kronecker delta. \n", + "\n", + "The following can be obtained: \n", + "$\\sum_{i=0}^{P}I_i(k)<\\Phi_s^2>\\delta_{is} = \\sum_{i=0}^{P}I_i(k-1)<\\Phi_s^2>\\delta_{is} - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\\Phi_j\\Phi_s> + T_s/L*E$\n", + "\n", + "Kronecker delta reduces elements in summations in the following: \n", + "$I_s(k)<\\Phi_s^2> = I_s(k-1)<\\Phi_s^2> - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\\Phi_j\\Phi_s> + T_s/L*E$\n", + "\n", + "The PC expansion of the circuit solution is: \n", + "$I_s(k) = I_s(k-1) - T_s/L\\frac{1}{<\\Phi_s^2>}\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\\Phi_j\\Phi_s> + T_s/L*E$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Matching of PDF types and orthogonal polynomials\n", + "\n", + "Uniform distribution of parameter -> Legendre polynomial\n", + "\n", + "Order of PC expansion: \n", + "$P = 1$ \n", + "\n", + "Non-zero inner products for Legendre polynomials: \n", + "$<\\Psi_0\\Psi_0> = 1$ \n", + "$<\\Psi_1\\Psi_1> = 1/3$ \n", + "$<\\Psi_0\\Psi_0\\Psi_0> = 1$ \n", + "$<\\Psi_0\\Psi_1\\Psi_1> = <\\Psi_1\\Psi_0\\Psi_1> = <\\Psi_1\\Psi_1\\Psi_0> = 1/3$\n", + "\n", + "The first order PC expansion of the circuit solution is the following: \n", + "$s=0$ \n", + "$I_0(k) = (1-T_s*R_0/L) * I_0(k-1) - T_s/L/3*R_1*I_1(k-1) + Ts/L*E$ \n", + "\n", + "$s=1$ \n", + "$I_1(k) = -T_s/L*R_1*I_0(k-1) - (1-T_s*R_0/L)*I_1(k-1)$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Calculation of PC coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# P-th order PC expansioin\n", + "P=1\n", + "# Number of coefficients in PC expansioin\n", + "M=P+1\n", + "\n", + "# Solution vector for PC\n", + "# Each row refers to a solution vector obtained for a PC coefficient\n", + "I_pct = np.zeros((M, npoint))\n", + "\n", + "# Matrix for solution equation\n", + "Gh = np.array([ [(1-Ts*R0/L), -Ts*R1/L/3], \n", + " [-Ts*R1/L, (1-Ts*R0/L)]])\n", + " \n", + "# Simulation time loop\n", + "for k in np.arange(1,npoint):\n", + " # Euler Forward used for discretization \n", + " I_pct_k = np.reshape(np.matmul(Gh, I_pct[:,k-1]), (M,1)) + np.array([ [Ts/L*E], [0]])\n", + " I_pct[0,k] = I_pct_k[0,0]\n", + " I_pct[1,k] = I_pct_k[1,0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reconstruction of uncertain variable based on PC coefficients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Legendre polynomial of order $1$: \n", + "$\\Phi(\\xi) = \\Phi_0(\\xi) + \\Phi_1(\\xi) = 1 + \\xi$\n", + "\n", + "$I = \\sum_{i=0}^{P}I_i\\Phi_i(\\xi) = I_0\\Phi_0(\\xi) + I_1\\Phi_1(\\xi) = I_0 + I_1\\xi$ \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Time vector\n", + "t = np.arange(0, npoint)*Ts\n", + "# Solution vector\n", + "i_pct = np.zeros((M, npoint))\n", + "\n", + "# Number of reconstructions\n", + "K = 15\n", + "plt.figure(figsize=(8,6))\n", + "for j in np.arange(0,K-1):\n", + " # Reconstruction of random behaviour of I based on PC expansioin coefficients \n", + " i_pct = I_pct[0,:] + I_pct[1,:]*rand_var[j]\n", + " plt.plot(t,i_pct, linewidth=1)\n", + "\n", + "plt.xlabel('Time [s]')\n", + "plt.ylabel('Current [A]')\n", + "plt.title('Polynomial Chaos simulation results')\n", + "plt.show()" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/lectures/11_UncertainSystemAnalysis/UncertainSystemAnalysis.ipynb b/lectures/11_UncertainSystemAnalysis/UncertainSystemAnalysis.ipynb deleted file mode 100644 index 7f9ec8353f1a4aac8c8a16e381dca67273365458..0000000000000000000000000000000000000000 --- a/lectures/11_UncertainSystemAnalysis/UncertainSystemAnalysis.ipynb +++ /dev/null @@ -1,393 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MSP Simulation Example\n", - "# Uncertain System Analysis - Classical Polynomial Chaos" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sample Circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "<img src=\"Circuit_RL.png\" width=\"300\" align=\"left\">" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$L$: $5 mH$ \n", - "$E$: $2 V$ \n", - "\n", - "Uncertain parameter in the system is the resistance with the uniform distribution: \n", - "$R$: $R_0 \\pm \\Delta R $ \n", - "$R_0$: $0.4 \\Omega$ \n", - "$\\Delta R$: $0.05 \\Omega$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Deterministic Solution of the Circuit\n", - "\n", - "Euler-Forward integration method: \n", - "$I(k) = (1-T_s*R/L) * I(k-1) + Ts/L*E$\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Circuit and Simulation Setup" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total simulation time: 0.08\n", - "\n", - "Simulation time step: 0.0001\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "np.set_printoptions(sign=' ')\n", - "\n", - "# Circuit parameters:\n", - "E = 2.0\n", - "L = 5.0e-3\n", - "R0 = 0.4\n", - "R1 = 0.05\n", - "\n", - "# Total simulation time\n", - "T_total = 0.08\n", - "# Simulaiton time step \n", - "Ts = 0.1e-3\n", - "# Number of simulation time steps\n", - "npoint = int(np.round(T_total/Ts))\n", - "\n", - "print('Total simulation time: ' + str(T_total))\n", - "print('\\nSimulation time step: ' + str(Ts))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Monte Carlo Simulation Method" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Random variable: \n", - "[-8.59029337e-01 -4.60466494e-01 5.91887395e-02 -1.46515604e-01\n", - " -7.15203525e-02 -8.06258266e-01 -3.31665853e-01 6.65056465e-01\n", - " -9.24720924e-01 -9.64876536e-01 9.88020137e-01 1.59075805e-01\n", - " -4.12507969e-01 7.24957527e-01 -8.55870483e-01 8.05672962e-01\n", - " -2.77408910e-01 1.22389746e-01 9.36528164e-01 -2.44663481e-01\n", - " -4.30228245e-01 2.47867440e-01 -1.88870745e-04 6.75921027e-01\n", - " 1.48082059e-01 -1.05219493e-01 -3.15744588e-01 -4.68967536e-01\n", - " 9.69742135e-01 4.99619187e-01 -6.44014720e-01 1.72531036e-01\n", - " -5.20327536e-01 -7.23361683e-01 -3.75604850e-02 -6.59856990e-01\n", - " -7.60130822e-01 4.57536217e-01 4.29482901e-01 2.68400232e-01]\n", - "\n", - " Resistor R: \n", - "[[ 0.35704853 0.37697668 0.40295944 0.39267422 0.39642398 0.35968709\n", - " 0.38341671 0.43325282 0.35376395 0.35175617 0.44940101 0.40795379\n", - " 0.3793746 0.43624788 0.35720648 0.44028365 0.38612955 0.40611949\n", - " 0.44682641 0.38776683 0.37848859 0.41239337 0.39999056 0.43379605\n", - " 0.4074041 0.39473903 0.38421277 0.37655162 0.44848711 0.42498096\n", - " 0.36779926 0.40862655 0.37398362 0.36383192 0.39812198 0.36700715\n", - " 0.36199346 0.42287681 0.42147415 0.41342001]]\n" - ] - } - ], - "source": [ - "# Number of samples for Monte Carlo simultion runs \n", - "N = 40\n", - "\n", - "# Generate random variable \n", - "rand_var = np.random.uniform(-1, 1, N)\n", - "print('Random variable: \\n' + str(rand_var))\n", - "\n", - "# R is a random parameter with the uniform distribution R= R0 + R1*rand_var \n", - "R = np.array([ R0 + R1*rand_var ])\n", - "print('\\n Resistor R: \\n' + str(R))\n", - "\n", - "# Solution vector for current I\n", - "# Each row refers to a solution vector obtained in one Monte Carlo simulation run\n", - "I = np.zeros((N, npoint)) \n", - "\n", - "# Monte Carlo simulation loop (for each sample of random parameter R)\n", - "for j in np.arange(0,N-1):\n", - " # Value of random parameter R for this Monte Carlo simulation run\n", - " Rj = R[0, j]\n", - " \n", - " # Time loop\n", - " # Initial condition\n", - " I[j,0]=0;\n", - " for i in np.arange(1,npoint):\n", - " # Euler Forward used for discretization \n", - " I[j,i] = (1-Ts*Rj/L) * I[j,i-1] + Ts/L*E" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plots" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plots\n", - "# Time vector\n", - "t = np.arange(0, npoint)*Ts\n", - "\n", - "plt.figure(figsize=(8,6))\n", - "for j in np.arange(0,N-1):\n", - " plt.plot(t,I[j,:], linewidth=1)\n", - "\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Current [A]')\n", - "plt.title('Monte Carlo simulation results')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Classical Polynomial Chaos" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Polynomial Chaos (PC) expansion \n", - "\n", - "PC expansion of $R$: \n", - "$R = \\sum_{i=0}^{P}R_i\\Phi_i(\\xi) = R_0\\Phi_0(\\xi) + R_1\\Phi_1(\\xi)$ \n", - "\n", - "PC expansion of $i(t)$: \n", - "$I = \\sum_{i=0}^{P}I_i(t)\\Phi_i(\\xi) = I_0(t)\\Phi_0(\\xi) + I_1(t)\\Phi_1(\\xi)$ \n", - "\n", - "Circuit solution: \n", - "$I(k) = (1-T_s*R/L) * I(k-1) + Ts/L*E = I(k-1) - T_s/L*R*I(k-1) + Ts/L*E$ \n", - "\n", - "Replacing $R$ and $I$ to the solution equation: \n", - "$\\sum_{i=0}^{P}I_i(k)\\Phi_i = \\sum_{i=0}^{P}I_i(k-1)\\Phi_i - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)\\Phi_i\\Phi_j + T_s/L*E$\n", - "\n", - "Applying Galerkin projection on the PC basis and by replcing integrals with inner products: \n", - "$\\sum_{i=0}^{P}I_i(k)<\\Phi_i\\Phi_s> = \\sum_{i=0}^{P}I_i(k-1)<\\Phi_i\\Phi_s> - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\n", - "\\Phi_j\\Phi_s> + T_s/L*E$\n", - "\n", - "Inner product of two orthogonal polynomials can be replaced by the following identity: \n", - "$<\\Phi_i\\Phi_s> = <\\Phi_s^2>\\delta_{is}$ \n", - "where $\\delta_{is}$ is Kronecker delta. \n", - "\n", - "The following can be obtained: \n", - "$\\sum_{i=0}^{P}I_i(k)<\\Phi_s^2>\\delta_{is} = \\sum_{i=0}^{P}I_i(k-1)<\\Phi_s^2>\\delta_{is} - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\\Phi_j\\Phi_s> + T_s/L*E$\n", - "\n", - "Kronecker delta reduces elements in summations in the following: \n", - "$I_s(k)<\\Phi_s^2> = I_s(k-1)<\\Phi_s^2> - T_s/L\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\\Phi_j\\Phi_s> + T_s/L*E$\n", - "\n", - "The PC expansion of the circuit solution is: \n", - "$I_s(k) = I_s(k-1) - T_s/L\\frac{1}{<\\Phi_s^2>}\\sum_{i=0}^{P}\\sum_{j=0}^{P}R_i*I_j(k-1)<\\Phi_i\\Phi_j\\Phi_s> + T_s/L*E$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Matching of PDF types and orthogonal polynomials\n", - "\n", - "Uniform distribution of parameter -> Legendre polynomial\n", - "\n", - "Order of PC expansion: \n", - "$P = 1$ \n", - "\n", - "Non-zero inner products for Legendre polynomials: \n", - "$<\\Psi_0\\Psi_0> = 1$ \n", - "$<\\Psi_1\\Psi_1> = 1/3$ \n", - "$<\\Psi_0\\Psi_0\\Psi_0> = 1$ \n", - "$<\\Psi_0\\Psi_1\\Psi_1> = <\\Psi_1\\Psi_0\\Psi_1> = <\\Psi_1\\Psi_1\\Psi_0> = 1/3$\n", - "\n", - "The first order PC expansion of the circuit solution is the following: \n", - "$s=0$ \n", - "$I_0(k) = (1-T_s*R_0/L) * I_0(k-1) - T_s/L/3*R_1*I_1(k-1) + Ts/L*E$ \n", - "\n", - "$s=1$ \n", - "$I_1(k) = -T_s/L*R_1*I_0(k-1) - (1-T_s*R_0/L)*I_1(k-1)$ " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Calculation of PC coefficients" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# P-th order PC expansioin\n", - "P=1\n", - "# Number of coefficients in PC expansioin\n", - "M=P+1\n", - "\n", - "# Solution vector for PC\n", - "# Each row refers to a solution vector obtained for a PC coefficient\n", - "I_pct = np.zeros((M, npoint))\n", - "\n", - "# Matrix for solution equation\n", - "Gh = np.array([ [(1-Ts*R0/L), -Ts*R1/L/3], \n", - " [-Ts*R1/L, (1-Ts*R0/L)]])\n", - " \n", - "# Simulation time loop\n", - "for k in np.arange(1,npoint):\n", - " # Euler Forward used for discretization \n", - " I_pct_k = np.reshape(np.matmul(Gh, I_pct[:,k-1]), (M,1)) + np.array([ [Ts/L*E], [0]])\n", - " I_pct[0,k] = I_pct_k[0,0]\n", - " I_pct[1,k] = I_pct_k[1,0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reconstruction of uncertain variable based on PC coefficients" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Legendre polynomial of order $1$: \n", - "$\\Phi(\\xi) = \\Phi_0(\\xi) + \\Phi_1(\\xi) = 1 + \\xi$\n", - "\n", - "$I = \\sum_{i=0}^{P}I_i\\Phi_i(\\xi) = I_0\\Phi_0(\\xi) + I_1\\Phi_1(\\xi) = I_0 + I_1\\xi$ \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plots" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 576x432 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Time vector\n", - "t = np.arange(0, npoint)*Ts\n", - "# Solution vector\n", - "i_pct = np.zeros((M, npoint))\n", - "\n", - "# Number of reconstructions\n", - "K = 15\n", - "plt.figure(figsize=(8,6))\n", - "for j in np.arange(0,K-1):\n", - " # Reconstruction of random behaviour of I based on PC expansioin coefficients \n", - " i_pct = I_pct[0,:] + I_pct[1,:]*rand_var[j]\n", - " plt.plot(t,i_pct, linewidth=1)\n", - "\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Current [A]')\n", - "plt.title('Polynomial Chaos simulation results')\n", - "plt.show()" - ] - }, - { - "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.7.0" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}