Leiterschleife.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bewegte Leiterschleife im Magnetfeld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Bibliotheken importieren\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import Box, HBox, VBox, Layout, Image\n",
    "from ipycanvas import MultiCanvas, Canvas, hold_canvas\n",
    "from math import pi, sin, cos, atan, sqrt\n",
    "\n",
    "# Farben definieren\n",
    "colors = {\n",
    "    \"black\" : \"#000000\",\n",
    "    \"lgrey\" : \"#f0f0f0\",\n",
    "    \"dgrey\" : \"#c0c0c0\",\n",
    "    \"U\"     : \"#3333cc\",\n",
    "    \"I\"     : \"#e8082c\",\n",
    "    \"B\"     : \"#00d000\"\n",
    "}\n",
    "\n",
    "# LaTeX-Symbole in Canvas vorzeichnen\n",
    "img_b = Canvas(width=9, height=12)\n",
    "img_b.draw_image(Image.from_file(\"img/dia_b.png\"), 0, 0)\n",
    "img_B = Canvas(width=13, height=17)\n",
    "img_B.draw_image(Image.from_file(\"img/dia_B.png\"), 0, 0)\n",
    "img_l = Canvas(width=5, height=12)\n",
    "img_l.draw_image(Image.from_file(\"img/dia_l.png\"), 0, 0)\n",
    "img_u_ind = Canvas(width=28, height=12)\n",
    "img_u_ind.draw_image(Image.from_file(\"img/dia_u_ind.png\"), 0, 0)\n",
    "img_x = Canvas(width=11, height=9)\n",
    "img_x.draw_image(Image.from_file(\"img/dia_x.png\"), 0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "class Diagramm():\n",
    "    \n",
    "    def __init__(self, lx, ly, layers=None, xlabel=None, ylabel=None):\n",
    "        self.canvas = MultiCanvas(len(layers), width=lx, height=ly)\n",
    "        self.c = {}\n",
    "        for li in range(len(layers)):\n",
    "            self.c[layers[li]] = self.canvas[li]\n",
    "        \n",
    "    def draw_arrow(self, layer, xy, angle, length, color=\"#000000\", line_width=2, tip_width=10):\n",
    "        sin_a = sin((angle + 90) * pi / 180)\n",
    "        cos_a = cos((angle + 90) * pi / 180)\n",
    "        with hold_canvas(layer):\n",
    "            layer.line_width = line_width\n",
    "            layer.stroke_style = color\n",
    "            layer.fill_style   = color\n",
    "            layer.begin_path()\n",
    "            layer.move_to(xy[0], xy[1])\n",
    "            if length < 15:\n",
    "                tip_length = 15 + (length - 15)\n",
    "                width = tip_width / 2 * length / 15\n",
    "            else:\n",
    "                tip_length = 15\n",
    "                width = tip_width / 2\n",
    "            line_end = (xy[0] + (length - tip_length) * sin_a,\n",
    "                        xy[1] + (length - tip_length) * cos_a)\n",
    "            layer.line_to(line_end[0], line_end[1])\n",
    "            layer.stroke()\n",
    "            layer.close_path()\n",
    "            # Pfeilspitze\n",
    "            layer.move_to(xy[0] + length * sin_a,\n",
    "                          xy[1] + length * cos_a)\n",
    "            layer.line_to(line_end[0] + width * sin((angle + 180) * pi / 180),\n",
    "                          line_end[1] + width * cos((angle + 180) * pi / 180)\n",
    "                         )\n",
    "            layer.line_to(line_end[0] - width * sin((angle + 180) * pi / 180),\n",
    "                          line_end[1] - width * cos((angle + 180) * pi / 180)\n",
    "                         )\n",
    "            layer.fill()\n",
    "    \n",
    "    def draw_axes(self, layer, xrange, yrange, xlabel=None, ylabel=None, angle=(0,90), margin=(25, 25)):\n",
    "        self.origin = (margin[0] - xrange[0],\n",
    "                  margin[1] + yrange[1]\n",
    "                 )\n",
    "        # x-Achse\n",
    "        self.draw_arrow(layer,\n",
    "                        xy = (self.origin[0] + xrange[0],\n",
    "                              self.origin[1]),\n",
    "                        angle = angle[0],\n",
    "                        length = xrange[1] - xrange[0],\n",
    "                        line_width = 1,\n",
    "                        tip_width = 8\n",
    "                       )\n",
    "        layer.draw_image(xlabel[0],\n",
    "                     self.origin[0] + xrange[1] + xlabel[1][0] + 5,\n",
    "                     self.origin[1] + xlabel[1][1]\n",
    "                    )\n",
    "        # y-Achse\n",
    "        self.draw_arrow(layer,\n",
    "                        xy = (self.origin[0],\n",
    "                              self.origin[1] - yrange[0]),\n",
    "                        angle = angle[1],\n",
    "                        length = yrange[1] - yrange[0],\n",
    "                        line_width = 1,\n",
    "                        tip_width = 8\n",
    "                       )\n",
    "        layer.draw_image(ylabel[0],\n",
    "                     self.origin[0] + ylabel[1][0],\n",
    "                     self.origin[1] - yrange[1] + ylabel[1][1] - 20\n",
    "                    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$u_{ind} = - \\frac{\\mathrm{d} \\Phi}{\\mathrm{d} t} = - \\frac{\\mathrm{d}A}{\\mathrm{d}t} \\cdot B = -v \\cdot b \\cdot B$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2913fd73416a4f0a99f0273e656d8e6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Box(layout=Layout(width='90px')), IntSlider(value=0, description='$\\\\color{#00c000}{\\\\vec{B_{1}…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "612cc995824b44a097cc246497813c1c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "MultiCanvas(height=460, width=750)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f5de6017ad6a4bce8cbd69938992e629",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(IntSlider(value=40, description='Länge $l$', min=10, readout=False), IntSlider(v…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a5203ff7cb8488a81fb3ab8e0be1c80",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Play(value=0, description='Press play', interval=20, max=565)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Leiterschleife(Diagramm):\n",
    "    \n",
    "    \n",
    "    \n",
    "    def __init__(self):\n",
    "        layers = [\n",
    "            \"bg\",\n",
    "            \"lb\",\n",
    "            \"Bb1\",\n",
    "            \"Bb2\",\n",
    "            \"Bb3\",\n",
    "            \"Bb4\",\n",
    "            \"Bb5\",\n",
    "            \"Bb6\",\n",
    "            \"Bb7\",\n",
    "            \"Bb8\",\n",
    "            \"Bf1\",\n",
    "            \"Bf2\",\n",
    "            \"Bf3\",\n",
    "            \"Bf4\",\n",
    "            \"Bf5\",\n",
    "            \"Bf6\",\n",
    "            \"Bf7\",\n",
    "            \"Bf8\",\n",
    "            \"lf\",\n",
    "            \"ll\",\n",
    "            \"laux1\",\n",
    "            \"laux2\",\n",
    "            \"u_ind_pre\",\n",
    "            \"u_ind\",\n",
    "            \"u_cursor\"\n",
    "        ]\n",
    "        \n",
    "        self.sliders = []\n",
    "        for s in range(3):\n",
    "            self.sliders.append(widgets.IntSlider(\n",
    "                value=0,\n",
    "                min=-5,\n",
    "                max=5,\n",
    "                step=1,\n",
    "                orientation='vertical',\n",
    "                description=r\"$\\color{#00c000}{\\vec{B_{%s}} }$\" % (s + 1),\n",
    "                readout=False,\n",
    "                layout=Layout(width=\"176px\", height=\"165px\"),\n",
    "                continuous_update=True,\n",
    "            ))\n",
    "            self.sliders[s].observe(self.update_fields, \"value\")\n",
    "            \n",
    "        self.l_slider = widgets.IntSlider(min = 10,\n",
    "                                          max = 100,\n",
    "                                          value = 40,\n",
    "                                          readout = False,\n",
    "                                          description = r\"Länge $l$\")\n",
    "        self.l_slider.observe(self.draw_loop, 'value')\n",
    "        self.b_slider = widgets.IntSlider(min = 10,\n",
    "                                          max = 50,\n",
    "                                          value = 30,\n",
    "                                          readout = False,\n",
    "                                          description = r\"Breite $b$\")\n",
    "        self.b_slider.observe(self.draw_loop, 'value')\n",
    "        self.v_slider = widgets.IntSlider(min = 1,\n",
    "                                          max = 3,\n",
    "                                          value = 3,\n",
    "                                          readout = False,\n",
    "                                          description = r\"$v$\")\n",
    "        self.v_slider.observe(self.update_v, 'value')\n",
    "            \n",
    "        # x-Slider und Play-Button\n",
    "        self.x_slider = widgets.IntSlider(max = 565,\n",
    "                                          description = r\"$x$\")\n",
    "        self.x_slider.observe(self.move_loop, 'value')\n",
    "        self.play = widgets.Play(\n",
    "            value = 0,\n",
    "            min = 0,\n",
    "            max = 565,\n",
    "            step = 1,\n",
    "            interval = 20,\n",
    "            description = \"Press play\",\n",
    "            disabled = False,\n",
    "            _repeat = True\n",
    "        )\n",
    "        widgets.jslink((self.play, 'value'), (self.x_slider, 'value'))\n",
    "        \n",
    "        super().__init__(lx = 750,\n",
    "                         ly = 460,\n",
    "                         layers = layers\n",
    "                        )\n",
    "\n",
    "        self.lb = Canvas()\n",
    "        self.lf = Canvas()\n",
    "        self.draw_background()\n",
    "        self.last_cursor = self.origin\n",
    "        self.draw_u()\n",
    "        self.draw_loop()\n",
    "        self.draw_fields()\n",
    "        \n",
    "        self.sliders[1].value = -5\n",
    "        \n",
    "        self.formula = widgets.Label(value=r\"$u_{ind} = - \\frac{d \\Phi}{d t} = \\frac{dA}{dt} \\cdot B = -v \\cdot b \\cdot B$\")\n",
    "        \n",
    "        display(HBox([Box(layout=Layout(width=\"90px\"))] + self.sliders))\n",
    "        display(self.canvas)\n",
    "        \n",
    "        display(HBox([VBox([self.l_slider,\n",
    "                            self.b_slider,\n",
    "                            self.v_slider,\n",
    "                            self.x_slider]),\n",
    "                      ]))\n",
    "        display(self.play)\n",
    "        \n",
    "    \n",
    "    \n",
    "    def draw_background(self):\n",
    "        \n",
    "        # Achsen\n",
    "        self.draw_axes(layer  = self.c[\"bg\"],\n",
    "                       xrange = (0, 570),\n",
    "                       xlabel = [img_x, (0, 0)],\n",
    "                       yrange = (-125, 125),\n",
    "                       ylabel = [img_u_ind, (-30, 0)],\n",
    "                       margin = (150, 185),\n",
    "                      )\n",
    "        \n",
    "        # Strichpunktlinie\n",
    "        ll = self.c[\"ll\"]\n",
    "        ll.line_width = 1\n",
    "        ll.set_line_dash([10, 5, 1, 5])\n",
    "        ll.stroke_style = colors[\"dgrey\"]\n",
    "        ll.begin_path()\n",
    "        ll.move_to(0, 80)\n",
    "        ll.line_to(700, 80)\n",
    "        ll.stroke()\n",
    "        \n",
    "        # Feldgrenzen\n",
    "        bg = self.c[\"ll\"]        \n",
    "        for i in range(9):\n",
    "            bg.line_width = 1\n",
    "            bg.set_line_dash([1, 3])\n",
    "            bg.stroke_style = colors[\"B\"]\n",
    "            bg.begin_path()\n",
    "            bg.move_to(150 + 60 * i, 80)\n",
    "            y_to = 185 if i == 0 else 310\n",
    "            bg.line_to(150 + 60 * i, y_to)\n",
    "            bg.stroke()            \n",
    "    \n",
    "    \n",
    "    \n",
    "    def draw_loop(self, *args, **kwarg):\n",
    "\n",
    "        xy = (125, 80)\n",
    "        l = self.l_slider.value\n",
    "        b = self.b_slider.value\n",
    "        \n",
    "        with hold_canvas(self.lb):\n",
    "            self.lb.line_width = 2\n",
    "            self.lb.stroke_style = colors[\"black\"]\n",
    "            self.lb.fill_style   = colors[\"lgrey\"]\n",
    "            \n",
    "            self.lb.move_to(xy[0], xy[1])\n",
    "            self.lb.begin_path()\n",
    "            self.lb.line_to(xy[0], xy[1])\n",
    "            line_end = (xy[0] + b * 0.25,\n",
    "                        xy[1] - b * 0.43301270189221935)\n",
    "            self.lb.line_to(line_end[0], line_end[1])\n",
    "            self.lb.line_to(line_end[0] - l, line_end[1])\n",
    "            self.lb.line_to(xy[0] - l, xy[1])\n",
    "            self.lb.clear()\n",
    "            self.lb.stroke()\n",
    "            self.lb.fill()\n",
    "            \n",
    "        with hold_canvas(self.lf):\n",
    "            self.lf.line_width = 2\n",
    "            self.lf.stroke_style = colors[\"black\"]\n",
    "            self.lf.fill_style   = colors[\"lgrey\"]\n",
    "            \n",
    "            self.lf.move_to(xy[0], xy[1])\n",
    "            self.lf.begin_path()\n",
    "            self.lf.line_to(xy[0], xy[1])\n",
    "            line_end = (xy[0] - b * 0.25,\n",
    "                        xy[1] + b * 0.43301270189221935)\n",
    "            self.lf.line_to(line_end[0], line_end[1])\n",
    "            self.lf.line_to(line_end[0] - l, line_end[1])\n",
    "            self.lf.line_to(xy[0] - l, xy[1])\n",
    "            self.lf.clear()\n",
    "            self.lf.stroke()\n",
    "            self.lf.fill()\n",
    "        \n",
    "        self.move_loop()\n",
    "        self.draw_u()\n",
    "    \n",
    "    \n",
    "    \n",
    "    def move_loop(self, *args, **kwarg):\n",
    "        \n",
    "        lb    = self.c[\"lb\"]\n",
    "        lf    = self.c[\"lf\"]\n",
    "        laux1 = self.c[\"laux1\"]\n",
    "        laux2 = self.c[\"laux2\"]\n",
    "        u     = self.c[\"u_ind\"]\n",
    "        uc    = self.c[\"u_cursor\"]\n",
    "                \n",
    "        x = self.x_slider.value - 25\n",
    "        l = self.l_slider.value\n",
    "        \n",
    "        with hold_canvas(lb):\n",
    "            lb.clear()\n",
    "            lb.draw_image(self.lb, x + 25, 0)\n",
    "            \n",
    "        with hold_canvas(lf):\n",
    "            lf.clear()\n",
    "            lf.draw_image(self.lf, x + 25, 0)\n",
    "\n",
    "        if x > 0:\n",
    "            \n",
    "            # Oszilloskop-Spur\n",
    "            with hold_canvas(u):\n",
    "                u.stroke_style = colors[\"U\"]\n",
    "                u.line_width   = 2\n",
    "                u.begin_path()\n",
    "                u.move_to(self.last_cursor[0], self.last_cursor[1])\n",
    "                \n",
    "                u_new = self.u(x)\n",
    "                \n",
    "                if u_new != self.last_cursor[1]:\n",
    "                    u.line_to(self.origin[0] + x, self.last_cursor[1])\n",
    "                    \n",
    "                self.last_cursor = (self.origin[0] + x, self.origin[1] - u_new)\n",
    "                \n",
    "                u.line_to(self.last_cursor[0], self.last_cursor[1])\n",
    "                u.stroke()\n",
    "            \n",
    "            # Cursor\n",
    "            with hold_canvas(uc):\n",
    "                uc.fill_style  = colors[\"U\"]\n",
    "                uc.clear()\n",
    "                uc.fill_arc(self.last_cursor[0], self.last_cursor[1], 3, 0, 2 * pi)\n",
    "                \n",
    "            # Hilfslinien\n",
    "            with hold_canvas(laux1):\n",
    "                laux1.line_width = 1\n",
    "                laux1.set_line_dash([1, 3])\n",
    "                laux1.stroke_style = colors[\"U\"]\n",
    "                laux1.begin_path()\n",
    "                laux1.move_to(x + 150, 80)\n",
    "                laux1.line_to(x + 150, self.origin[1] - u_new)\n",
    "                laux1.clear()\n",
    "                laux1.stroke()            \n",
    "        \n",
    "        else:\n",
    "            self.last_cursor = self.origin\n",
    "            u.clear()\n",
    "            uc.clear()\n",
    "            laux1.clear()\n",
    "            laux2.clear()\n",
    "            \n",
    "        if x > l:\n",
    "            with hold_canvas(laux2):\n",
    "                laux2.line_width = 1\n",
    "                laux2.set_line_dash([1, 3])\n",
    "                laux2.stroke_style = colors[\"U\"]\n",
    "                laux2.begin_path()\n",
    "                laux2.move_to(x + 150 - l, 80)\n",
    "                laux2.line_to(x + 150 - l, self.origin[1])\n",
    "                laux2.clear()\n",
    "                laux2.stroke()\n",
    "    \n",
    "    \n",
    "    \n",
    "    def draw_fields(self):\n",
    "        \n",
    "        xy = (150, 80)\n",
    "        \n",
    "        self.fields_bg = {}\n",
    "        self.fields_fg = {}\n",
    "\n",
    "        l = 60\n",
    "        \n",
    "        dx_list = [        [30],\n",
    "                         [20, 40],\n",
    "                       [15, 30, 45],\n",
    "                     [12, 24, 36, 48],\n",
    "                   [10, 20, 30, 40, 50]\n",
    "                  ]\n",
    "        \n",
    "        for i in range(5):\n",
    "            \n",
    "            bg = Canvas()\n",
    "            bg.line_width = 2\n",
    "            bg.stroke_style = colors[\"B\"]\n",
    "            bg.begin_path()\n",
    "            bgm = Canvas()\n",
    "                \n",
    "            fg  = Canvas()            \n",
    "            fgm = Canvas()\n",
    "            \n",
    "            for dx in dx_list[i]:\n",
    "                \n",
    "                with hold_canvas(bg):\n",
    "                    bg.move_to(xy[0] + dx, xy[1])\n",
    "                    bg.line_to(xy[0] + dx, xy[1] - l)\n",
    "                    bg.stroke()\n",
    "                \n",
    "                bgm.draw_image(bg, 0, l)                    \n",
    "                \n",
    "                self.fields_bg[ i + 1] = bgm\n",
    "                self.fields_fg[-i - 1] = bg\n",
    "                \n",
    "                with hold_canvas(fg):\n",
    "                    self.draw_arrow(fg,\n",
    "                                    xy = (xy[0] + dx, xy[1]),\n",
    "                                    angle = 270,\n",
    "                                    length = l,\n",
    "                                    color = colors[\"B\"],\n",
    "                                    tip_width = 6\n",
    "                                   )                       \n",
    "                    self.draw_arrow(fgm,\n",
    "                                    xy = (xy[0] + dx, xy[1]),\n",
    "                                    angle = 90,\n",
    "                                    length = l,\n",
    "                                    color = colors[\"B\"],\n",
    "                                    tip_width = 6\n",
    "                                   )               \n",
    "\n",
    "                self.fields_fg[ i + 1] = fgm\n",
    "                self.fields_bg[-i - 1] = fg\n",
    "    \n",
    "    \n",
    "    \n",
    "    def update_fields(self, change):\n",
    "        \n",
    "        segment = int(change[\"owner\"].description[-6])\n",
    "        delta_x = (segment - 1) * 180\n",
    "        val = self.sliders[segment - 1].value\n",
    "        \n",
    "        Bf = self.c[\"Bf\" + str(segment)]\n",
    "        Bb = self.c[\"Bb\" + str(segment)]\n",
    "        \n",
    "        Bf.clear()        \n",
    "        Bb.clear()\n",
    "        \n",
    "        if val != 0:\n",
    "            \n",
    "            with hold_canvas(Bb):\n",
    "                Bb.draw_image(self.fields_bg[val], delta_x)\n",
    "                \n",
    "            with hold_canvas(Bf):\n",
    "                Bf.draw_image(self.fields_fg[val], delta_x)\n",
    "        \n",
    "        self.draw_u()\n",
    "        \n",
    "    \n",
    "    \n",
    "    def draw_u(self, *args, **kwarg):\n",
    "        \n",
    "        self.u_array = 125 * [0]\n",
    "        for s in range(3):\n",
    "            self.u_array += 60 * [self.sliders[s].value * 10] + 120 * [0]\n",
    "        self.u_array += 175 * [0]\n",
    "        \n",
    "        u = self.c[\"u_ind_pre\"]\n",
    "        u.set_line_dash([3, 3])\n",
    "        u.line_width = 1\n",
    "        u.stroke_style = colors[\"U\"]\n",
    "        \n",
    "        u_old = 0\n",
    "\n",
    "        with hold_canvas(u):\n",
    "            u.begin_path()\n",
    "            u.move_to(self.origin[0], self.origin[1])\n",
    "\n",
    "            for x in range(540):\n",
    "\n",
    "                u_new = self.u(x)\n",
    "\n",
    "                # Unstetigkeit berücksichtigen\n",
    "                if u_new != u_old:\n",
    "                    u.line_to(self.origin[0] + x, self.origin[1] - u_old)\n",
    "\n",
    "                u.line_to(self.origin[0] + x, self.origin[1] - u_new)\n",
    "                u_old = u_new\n",
    "                u.clear()\n",
    "                u.stroke()\n",
    "    \n",
    "    \n",
    "    \n",
    "    def update_v(self, *args, **kwarg):\n",
    "        self.play.interval = 60 / self.v_slider.value\n",
    "        self.draw_u()\n",
    "                \n",
    "                \n",
    "    def u(self, x):\n",
    "        return 0.66666666666666 * self.v_slider.value * self.b_slider.value / self.b_slider.max * (self.u_array[x + 125] - self.u_array[x + 125 - self.l_slider.value])\n",
    "\n",
    "        \n",
    "\n",
    "\n",
    "LS = Leiterschleife()"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}