diff --git a/Physics.ipynb b/Physics.ipynb new file mode 100644 index 0000000..ab4ee25 --- /dev/null +++ b/Physics.ipynb @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + " Teaching and Learning differently with Jupyter Notebooks - HEG, December 12, 2019
\n", + " C. Hardebolle, CC BY-NC-SA 4.0 Int.

\n", + " How to use this notebook?
\n", + " This notebook is made of text cells and code cells. The code cells have to be executed to see the result of the program. To execute a cell, simply select it and click on the \"play\" button (►) in the tool bar just above the notebook, or type shift + enter. It is important to execute the code cells in their order of appearance in the notebook.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning goals\n", + "\n", + "After using this notebook, you should be able to:\n", + "* Analyze how the tension force is affected by the position of the cable in a suspended object problem\n", + "* Illustrate what effects can high tension have on a cable\n", + "* Use Python to make arithmetic calculations\n", + "\n", + "
\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Activity 1: Experimenting with the virtual lab\n", + "\n", + "The \"Suspended object\" virtual lab below allows you to **experiment with different counterweights** to see how it affects the position of the object suspended on the cable. \n", + "The **4 questions in the quiz below the virtual lab** are designed to guide you in your experimentation by making you observe what happens at specific moments.\n", + "\n", + "**Execute the code cell below** (click on it then click on the \"play\" button in the tool bar above) to launch the virtual lab, then **answer the 4 questions in the quiz below**.\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "634183dbe1ec4c0c8fdc548f741ab960", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Ba…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from lib.suspendedobjects import *\n", + "SuspendedObjectsLab();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*If you wonder how the virtual lab works, you can have a look at the code in [this python file](lib/suspendedobjects.py).*\n", + "\n", + "---\n", + "\n", + "# Activity 2: Looking more closely at the tension in the cable\n", + "\n", + "In the mini-lecture, we have seen that, in this situation, the value of the tension in the cable (represented by the plain red arrows in the virtual lab above) is defined by:\n", + "\n", + "$\n", + "\\begin{align}\n", + "\\lvert\\vec{T}\\rvert = \\frac{\\frac{1}{2}.m.g}{sin(\\alpha)}\n", + "\\end{align}\n", + "$, where $m$ is the mass of the suspended object, $\\alpha$ the angle that the cable makes with the horizon and $g$ the gravity of earth.\n", + "\n", + "In the following we are going to use Python to **compute the tension in the cable** for **different values of the angle $\\alpha$**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the constants of our physics problem\n", + "\n", + "In the above equation we have two constants:\n", + "- $g$ the gravity of earth, which is 9.81 m/s²\n", + "- $m$ the mass of the suspended object, which is 3 kg in the case of the jeans\n", + "\n", + "**Execute the code cell below** so that these two constants get defined in Python." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gravity: 9.81 , jeans_mass: 3\n" + ] + } + ], + "source": [ + "# Let's define the value of gravity\n", + "gravity = 9.81\n", + "\n", + "# And the mass of the jeans\n", + "jeans_mass = 3\n", + "\n", + "# Display the value of the constants to check they are well defined\n", + "print(\"gravity:\", gravity, \", jeans_mass:\", jeans_mass)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating a function to compute the tension in the cable\n", + "\n", + "Now let's define a Python function that represents the equation of the tension and in which we are going to vary $\\alpha$. \n", + "The function takes one input parameters, `alpha`, which is the angle that the cable makes with the horizon. \n", + "It returns the value of the tension in the cable as computed with the equation: \n", + "$\n", + "\\begin{align}\n", + "\\lvert\\vec{T}\\rvert = \\frac{\\frac{1}{2}.m.g}{sin(\\alpha)}\n", + "\\end{align}\n", + "$\n", + "\n", + "**Execute the code cell below** so that this function gets defined in Python." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mtension_norm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "\u001b[0;31mSource:\u001b[0m \n", + "\u001b[0;32mdef\u001b[0m \u001b[0mtension_norm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m.5\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mjeans_mass\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mgravity\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFile:\u001b[0m ~/git_Other/LEARNHoD/\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's define the function\n", + "def tension_norm(alpha):\n", + " return (.5 * jeans_mass * gravity) / np.sin(alpha)\n", + "\n", + "# And display it to check it is well defined\n", + "tension_norm??" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing tension in the cable using our function\n", + "\n", + "Now let's use this Python function to compute the norm of the tension in the cable for an angle of 1.5$^\\circ = \\frac{\\pi}{120}$.\n", + "\n", + "**Execute the code cell below** to see the result, expressed in Newtons." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\lvert\\vec{T}\\rvert = $ 562 $N $" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First choose an angle alpha\n", + "alpha = np.pi/120\n", + "\n", + "# Then compute the tension using our equation\n", + "T = tension_norm(alpha)\n", + "\n", + "# And print the result with a pretty format\n", + "display(Math(r'$\\lvert\\vec{T}\\rvert = $'+' {:8.0f} $N $'.format(T)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get an idea of how big this value is, you can think about our jeans which weight 3 kg: the force exerted by earth gravity on the jeans is $\\lvert\\vec{F}\\rvert = $ 29 $N$ only!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 1 \n", + "What is the value of the tension for an angle of 0.5$^\\circ = \\frac{\\pi}{360}$? \n", + "In the code cell above, change the value of `alpha` and re-execute the cell to see the result." + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Type the value you obtain here:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You can check your answers with the solution available [in this file](solution/Physics-solution.ipynb).*\n", + "\n", + "## Looking at how the tension in the cable evolves with the angle $\\alpha$\n", + "\n", + "Now we want to look at **how the tension evolves** when the angle $\\alpha$ changes. \n", + "Thanks to our previously defined Python function, we are going to compute the tension in the cable for 100 different values of $\\alpha$ and plot the result on a graph. \n", + "**Execute the code cell below** to see the resulting graph.\n", + "\n", + "*Note:* \n", + "Python code for plotting can be quite verbose and not particularly interesting to look at unless you want to learn how to generate plots in Python. \n", + "The good news is that you can **hide** a code cell from the notebook by selecting it and clicking on the blue bar which appears on its left. To make the cell visible again, just click again on the blue bar, or on the three \"dots\" which represent the collapsed cell." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's define the boundaries of the graph\n", + "a_start = 21.8 # start the angle at 21.8° which is the initial angle that our cable makes with the horizon\n", + "a_stop = 0 # stop at O°\n", + "\n", + "# Let's define how fine we want the grid on the graph\n", + "a_step = 1 # we want the grid to be shown every 1°\n", + "\n", + "# Now we generate 100 possible values for the angle alpha between a_start and a_stop (excluded)\n", + "a_deg = np.linspace(start=a_start, stop=a_stop, num=100, endpoint = False)\n", + "\n", + "# Then we compute the value of the tension for all the 100 possible angles alpha using our previously defined function\n", + "# But since our previously defined function works with angles expressed in radians, we first convert our list of angles from degrees to radians\n", + "a_rad = degrees_to_radians(a_deg)\n", + "\n", + "t = tension_norm(a_rad)\n", + "\n", + "# And we plot the result\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Tension in the cable')\n", + "ax.set_ylabel('Tension T (N)')\n", + "ax.set_xlabel(r'Angle $\\alpha$ ($^\\circ$)')\n", + "ax.set_xlim(a_deg[0], 0) # We make the angle decreasing for a more readable plot\n", + "ax.xaxis.set_major_locator(ticker.MultipleLocator(a_step)) # We set the step for the grid\n", + "ax.plot(a_deg, t, color='red')\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2 \n", + "For which angle does the tension reach 500 Newtons, approximately? And 1000 Newtons?" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Type your answer here." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*You can check your answers with the solution available [in this file](solution/Physics-solution.ipynb).*\n", + "\n", + "## What are the consequences?\n", + "\n", + "As you can see, **the tension increases very very fast when the cable approaches the horizon**: what the graph shows is that the value of the tension **tends towards $+\\infty$** when the angle $\\alpha$ approaches 0. This is what makes it impossible to pull the cable taut completely horizontally.\n", + "\n", + "It is important to know that high tension in a cable is very dangerous and can lead to serious accidents, especially when the cable is not well adapted for its intended use (i.e. not strong enough) or when the cable is progressively deteriorating with use. \n", + "\n", + "Question 3 \n", + "Execute the cell below to see the video and watch the first minute (sound is not necessary). \n", + "What happens at time 0:53? Why?" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('KIbd5zBek5s', 600, 337)" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Type your answer here." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + "*You can check your answers with the solution available [in this file](solution/Physics-solution.ipynb).*\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What have you learned so far?\n", + "\n", + "Write **3 things you have learned** about the **tension force** in a cable:" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "- \n", + "- \n", + "- " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can you identify **other real-life situations** in which cables are used to suspend objects or in which cables are taut between poles? \n", + "Write 2 or 3 ideas:" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "- \n", + "- \n", + "- " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you are finished with the above questions, **check-in with the instructor**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "# Additional exercises (optional)\n", + "\n", + "## Expressing the tension in 'kilogram-force'\n", + "To have a better intuition about how big the tension is, people like to express it in kilograms. The idea is to make a parallel with the force exerted by gravity i.e. the weight, $\\vec{F} = m.\\vec{g}$, and to compute which mass $m$ would create an equivalent force. \n", + "To get the value in 'kilogram-force' of a tension, you divide its value in Newtons by the value of gravity: \n", + "\n", + "$\n", + "\\begin{align}\n", + "T' = \\frac{T}{g}\n", + "\\end{align}\n", + "$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 1 \n", + "Complete the code in the cell below to compute the value in 'kilogram-force' of the tension we have computed above. Then execute the cell to see the result." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\lvert\\vec{T}\\rvert = $ 0 kg$_F$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: replace the \"0\" in the line below with the expression of the equation above\n", + "T_prime = 0\n", + "\n", + "# pretty printing of the result\n", + "display(Math(r'$\\lvert\\vec{T}\\rvert = $'+' {:8.0f} kg$_F$'.format(T_prime)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To go further, you could transform your code above into a function, which would take `T` as an input parameter and return the value of `T` in 'kilogram-force'." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What happens to the tension when $\\alpha$ = 0?\n", + "\n", + "What happens with our piece of Python code when we say that the cable it taut completely horizontal, i.e. the angle $\\alpha$ = 0$^\\circ$, which is actually impossible in real life? \n", + "\n", + "Question 2 \n", + "In the cell where we have computed $T$ above, change the value of `alpha` to $0$ and re-execute the cell. \n", + "What happens? " + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "Type your answer here." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + "*You can check your answers for this activity with the solution available [in this file](solution/Physics-solution.ipynb).*\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Is it possible to pull the cable taut completely horizontally?\n", + "\n", + "In this section we demonstrate the physical and mathematical reasoning to answer this question.\n", + "\n", + "### Goal\n", + "\n", + "For the cable to be taut completely horizontally means that the angle $\\alpha$ that the cable makes with the horizon is 0$^\\circ$. \n", + "In other words, the question could be reframed as: which mass $m_{cw}$ should we put as a counterweight to get $\\alpha$ = 0$^\\circ$?\n", + "If we can find a 'reasonable' value for the counterweight then it will mean that it is possible to pull the cable taut completely horizontally.\n", + "\n", + "To answer this question, we therefore look for an expression relating the **mass of the counterweight $m_{cw}$** and the **angle $\\alpha$** that the cable makes with the horizon.\n", + "\n", + "\n", + "### Method\n", + "\n", + "Given that the system is in static equilibrium, the sum of external forces exerted on the system will be zero, so using Newton's second law should be easy. The force that the counterweight exerts on the system will involve the mass of the counterweight so we should be able to rewrite Newton's second law to get an expression of the form $m_{cw} = ...$.\n", + "\n", + "### Hypotheses and simplifications\n", + "\n", + "We make the following assumptions and simplifications:\n", + "* the jeans are considered as positioned exactly mid-way between the poles so the tension is equal on both sides of the cable\n", + "* we represent the jeans by the point at which they are suspended\n", + "* the cable is considered as rigid (not bended), with a negligible mass\n", + "* the pulley is considered as perfect, without mass nor friction\n", + "* we consider the static equilibrium obtained after changing the weight, once the system is stabilized\n", + "\n", + "### Resolution\n", + "\n", + "First, let's draw a diagram and represent the different forces involved.\n", + "\n", + "\n", + "The *forces applied on the jeans* are:\n", + "* the weight: $\\vec F_j = m_j \\vec g$ \n", + "* the force exerted by the cable on each side of the jeans: assuming the jeans are suspended at the exact center of the cable, then the tension applied on each of the two sides is is equally distributed $\\vec T$, which combine into a vertical resulting tension $\\vec T_r = 2.\\vec T$\n", + "\n", + "From Newton's second law in a static equilibrium we can write: $\\sum \\vec F_j = \\vec 0$ \n", + "With the forces on the jeans we get: $\\vec F_j + \\vec T_r = 0$ \n", + "Using the fact that the tension is equal on both sides of the jeans we get: $\\vec F_j + 2.\\vec T = 0$\n", + "\n", + "If we project on $x$ and $y$ axes, we get: \n", + "$\\left\\{\\begin{matrix} F_{jx} + 2.T_x = 0 \\\\ F_{jy} + 2.T_y = 0\\end{matrix}\\right. $\n", + "\n", + "Since the weight does not have a component on the x axis, it simplifies into: \n", + "$\\left\\{\\begin{matrix} T_x = 0 \\\\ F_{jy} + 2.T_y = 0\\end{matrix}\\right. $\n", + "\n", + "The component of the weight on the y axis is $F_{jy} = - m_j.g$, which gives us: \n", + "$\\left\\{\\begin{matrix} T_x = 0 \\\\ - m_j.g + 2.T_y = 0\\end{matrix}\\right. $\n", + "\n", + "Using the angle $\\alpha$ we can get the tension $T_y$ expressed as a function of T since $sin(\\alpha) = \\frac{T_y}{T}$, therefore $T_y = T.sin(\\alpha)$\n", + "\n", + "By replacing $T_y$ by this expression in the above equation we get: \n", + "$\\left\\{\\begin{matrix} T_x = 0 \\\\ - m_j.g + 2.T.sin(\\alpha) = 0\\end{matrix}\\right. $\n", + "\n", + "From there we can get $T$, and this is equation number $(1)$: \n", + "\n", + "$\n", + "\\begin{align}\n", + "T = \\frac{m_j.g}{2.sin(\\alpha)}\n", + "\\end{align}\n", + "$\n", + "\n", + " \n", + "\n", + "We now want to make the mass of the counterweight appear in this expression. \n", + "So we will now look at the forces applied on the *counterweight*.\n", + "\n", + " \n", + "\n", + "The forces applied on the *counterweight* are:\n", + "* the weight: $\\vec F_{cw} = m_{cw} \\vec g$ \n", + "* the force exerted by the cable: a simple pulley simply changes the direction of the tension so the tension applied on the counterweight is therefore $\\vec T$\n", + "\n", + "From Newton's second law in a static equilibrium we can write: $\\sum \\vec F_{cw} = \\vec 0$ \n", + "With the forces involved in our problem : $\\vec F_{cw} + \\vec T = \\vec 0$ \n", + "\n", + "All forces being vertical, there is no need to project on $x$ so we get: $- F_{cw} + T = 0$ \n", + "We replace the weight by its detailed expression: $-m_{cw}.g + T = 0$ \n", + "Now we can express $T$ as a function of the other parameters, which is equation number $(2)$: $T = m_{cw}.g$ \n", + "\n", + " \n", + "\n", + "Let's now summarize what we have so far with equations $(1)$ and $(2)$: \n", + "\n", + "$\n", + "\\begin{align}\n", + "\\left\\{\\begin{matrix}T = \\frac{m_j.g}{2.sin(\\alpha)} \\\\ T = m_{cw}.g\\end{matrix}\\right. \n", + "\\end{align}\n", + "$\n", + "\n", + "These two equations combined give us:\n", + "\n", + "$\n", + "\\begin{align}\n", + "\\frac{m_j.g}{2.sin(\\alpha)} = m_{cw}.g\n", + "\\end{align}\n", + "$\n", + "\n", + "This allow us to find the mass of the counterweight as a function of the *mass of the jeans* and of the *angle that the cable makes with the horizon*: \n", + "\n", + "
\n", + "\n", + "$$m_{cw} = \\frac{m_j}{2.sin(\\alpha)}$$\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conclusion\n", + "\n", + "When the cable approaches the horizon, $\\alpha$ is really small i.e. really close to zero. \n", + "This means that $sin(\\alpha)$ is also close to zero, which means in turn that $m_{cw}$ is very big.\n", + "Therefore, **the more we want the cable to be close to the horizon, the bigger $m_{cw}$ we will need!**\n", + "\n", + "Mathematically speaking, the limit of the expression defining the mass of the counterweight when alpha tends to 0 is:\n", + "\n", + "$\n", + "\\begin{align}\n", + "\\lim_{\\alpha\\to0}m_{cw} = \\lim_{\\alpha\\to0}\\frac{m_j}{2.sin(\\alpha)} = +\\infty\n", + "\\end{align}\n", + "$\n", + "\n", + "So basically, we would need to put an **infinitely heavy counterweight** to make the angle null and that is why it is impossible to get the cable taut so that it is absolutely straight (the cable would break before that! :-p)...\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " \n", + "\n", + "### Numerical application\n", + "\n", + "We have already defined above the constant `jeans_mass` which represents the mass of our jeans (3 kg).\n", + "\n", + "Let's define a Python function that represents the above equation. \n", + "The function takes one input parameters, `alpha`, the angle that the cable makes with the horizon. \n", + "It returns the mass of the counterweight as computed with the equation above." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def counterweight_mass(alpha):\n", + " return jeans_mass / (2 * np.sin(alpha))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For an angle of $1.5^\\circ = \\frac{\\pi}{120}$, we need to put a counterweight of:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "57.30 kg\n" + ] + } + ], + "source": [ + "# Choose a value for angle alpha\n", + "alpha = np.pi / 120\n", + "\n", + "# Computes the mass of the counterweight using our function\n", + "mcw = counterweight_mass(alpha)\n", + "\n", + "# And print the result\n", + "print('{:.02f} kg'.format(mcw))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can check that you get a similar result with the virtual lab above.\n", + "\n", + "You can also check what happens when you put `alpha = 0`...\n", + "\n", + " " + ] + } + ], + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/figs/jeans-solution.png b/figs/jeans-solution.png new file mode 100644 index 0000000..0499a36 Binary files /dev/null and b/figs/jeans-solution.png differ diff --git a/lib/suspendedobjects.py b/lib/suspendedobjects.py new file mode 100644 index 0000000..16269d1 --- /dev/null +++ b/lib/suspendedobjects.py @@ -0,0 +1,371 @@ +import numpy as np + +from ipywidgets import interact, interactive, fixed, interact_manual +from ipywidgets import HBox, VBox, Label, Layout +import ipywidgets as widgets + +from IPython.display import IFrame +from IPython.display import set_matplotlib_formats, display, Math, Markdown, Latex, HTML +set_matplotlib_formats('svg') + +# Enable interactive backend for matplotlib +from IPython import get_ipython +get_ipython().run_line_magic('matplotlib', 'widget') + +import matplotlib.pyplot as plt +import matplotlib.patches as pat +import matplotlib.ticker as ticker +plt.style.use('seaborn-whitegrid') # global style for plotting + +class SuspendedObjectsLab: + """ + This class embeds all the necessary code to create a virtual lab to study the static equilibrium of an object suspended on a clothesline with a counterweight. + """ + + def __init__(self, m_object = 3, distance = 5, height = 1, x_origin = 0, y_origin = 0): + ''' + Initiates and displays the virtual lab on suspended objects. + + :m_object: mass of the suspended object + :distance: horizontal distance between the two poles + :height: height of the poles (same height for both) + :x_origin: x coordinate of the bottom of the left pole (origin of the coordinate system) + :y_origin: y coordinate of the bottom of the left pole (origin of the coordinate system) + ''' + + ###--- Static parameters of the situation + self.m_object = m_object # mass of the wet object, in kg + + self.distance = distance # distance between the poles, in m + self.height = height # height of the poles, in m + + self.x_origin = x_origin # x coordinate of point of origin of the figure = x position of the left pole, in m + self.y_origin = y_origin # y coordinate of point of origin of the figure = y position of the lower point (ground), in m + + + + ###--- Then we define the elements of the ihm: + # parameters for sliders + self.m_counterweight_min = 0.0 + self.m_counterweight_max = 100.0 + self.m_counterweight = self.m_counterweight_min # initial mass of the counterweight (0 by default, no counterweight at the beginning) + + # IHM input elements + self.m_counterweight_label = Label('Mass of the counterweight ($kg$):', layout=Layout(margin='0px 5px 0px 0px')) + self.m_counterweight_widget = widgets.FloatSlider(min=self.m_counterweight_min,max=self.m_counterweight_max,step=0.5,value=self.m_counterweight, layout=Layout(margin='0px')) + self.m_counterweight_note = Label('[Note: once you have clicked on the slider (the circle becomes blue), you can use the arrows from your keyboard to make it move.]', layout=Layout(margin='0px 0px 15px 0px')) + + self.m_counterweight_input = VBox([HBox([self.m_counterweight_label, self.m_counterweight_widget], layout=Layout(margin='0px')), self.m_counterweight_note]) + + # IHM output elements + self.quiz_output = widgets.Output() + + # Linking widgets to handlers + self.m_counterweight_widget.observe(self.m_counterweight_event_handler, names='value') + + + + ###--- Compute variables dependent with the counterweight selected by the user + alpha = self.get_angle(self.m_counterweight) + alpha_degrees = alpha*180/np.pi + alpha_text = r'$\alpha$ = {:.2f} $^\circ$'.format(alpha_degrees) + + coord_object = self.get_object_coords(alpha) + height_text = r'h = {:.2f} $m$'.format(coord_object[1]) + + + + ###--- Create the figure + plt.ioff() # deactivate interactive mode until we actually decide to show it + plt.clf() # clear any previously drawn figure + + # Create the figure and subplots in it + self.fig = plt.figure(num='Suspended Object Lab', constrained_layout=False, figsize=(10,4)) # hack for interactive backend: num is the title which appears above the canvas + gs = self.fig.add_gridspec(ncols=7, nrows=1, wspace=0.5, hspace=0, right=0.95, top=0.9, left=0.05, bottom=0.1) + ax1 = self.fig.add_subplot(gs[0, :3]) + ax2 = self.fig.add_subplot(gs[0, 3:5], sharey = ax1) + ax3 = self.fig.add_subplot(gs[0, 5:7], sharex = ax2) + + # Deactivate toolbar (hack for interactive backend) + # NOT WORKING + self.fig.canvas.toolbar_visible = False + self.fig.canvas.toolbar_position = 'right' + + # Deactivate coordinate formatter (hack for interactive backend) + ax1.format_coord = lambda x, y: '' + ax2.format_coord = lambda x, y: '' + ax3.format_coord = lambda x, y: '' + + # Adjust canvas size so that quiz below is visible (hack for interactive backend) + # NOT WORKING + # self.fig.set_size_inches([10,4], forward = True) + + ###--- First display the clothesline + ax1.set_title('Suspended object ({} kg)'.format(self.m_object)) + + # Fix graph to problem boundaries + ymargin = .06 + xmargin = .4 + ax1.set_ylim(bottom = self.y_origin - ymargin) # limit bottom of y axis to ground + ax1.set_ylim(top = self.y_origin + self.height + ymargin) # limit top of y axis to values just above height + + # Customize graph style so that it doesn't look like a graph + ax1.grid(False) # hide the grid + ax1.set_ylabel("Height ($m$)") # add a label on the y axis + ax1.get_xaxis().set_visible(False) # hide x axis + ax1.spines['top'].set_visible(False) # hide the frame + ax1.spines['bottom'].set_visible(False) + ax1.spines['right'].set_visible(False) + ax1.spines['left'].set_visible(False) + + # Draw the poles + x_pole1 = np.array([self.x_origin, self.x_origin]) + y_pole1 = np.array([self.y_origin, self.y_origin+self.height]) + ax1.plot(x_pole1, y_pole1, "k-", linewidth=7, zorder=1) + x_pole2 = np.array([self.x_origin+self.distance, self.x_origin+self.distance]) + y_pole2 = np.array([self.y_origin, self.y_origin+self.height]) + ax1.plot(x_pole2, y_pole2, "k-", linewidth=7, zorder=1) + + # Draw the ground + ax1.axhline(y=self.y_origin, color='black', linewidth=1, zorder=2) + ax1.add_patch(pat.Polygon([[self.x_origin-xmargin, self.y_origin], [self.x_origin+self.distance+xmargin, self.y_origin], [self.x_origin+self.distance+xmargin, self.y_origin-ymargin], [self.x_origin-xmargin, self.y_origin-ymargin]], closed=True, fill="white", facecolor="white", edgecolor="gray", hatch='///', linewidth=0.0, zorder=2)) + + # Draw the horizon line + ax1.axhline(y=self.y_origin+self.height, color='gray', linestyle='-.', linewidth=1, zorder=1) + + # -DYN- Draw the hanging cable + x = np.array([self.x_origin, coord_object[0], self.x_origin+self.distance]) + y = np.array([self.y_origin+self.height, coord_object[1], self.y_origin+self.height]) + self.cable, = ax1.plot(x, y, linewidth=2, linestyle = "-", color="black") + + # -DYN- Draw the angle between the hanging cable and horizonline + ellipse_radius = 0.2 + fig_ratio = self.height / self.distance + self.cable_angle = pat.Arc(xy = (self.x_origin, self.y_origin+self.height), width = ellipse_radius/fig_ratio, height = ellipse_radius, theta1 = -1*alpha_degrees, theta2 = 0, color="gray", linestyle='-.') + ax1.add_patch(self.cable_angle) + self.cable_angle_text = ax1.annotate(alpha_text, xy=(self.x_origin, self.y_origin+self.height), xytext=(30, -15), textcoords='offset points', bbox=dict(boxstyle="round", facecolor = "white", edgecolor = "white", alpha = 0.8)) + + # -DYN- Draw the point at which the object is suspended + self.cable_point = ax1.scatter(coord_object[0], coord_object[1], s=80, c="black", zorder=15) + self.cable_point_text = ax1.annotate(height_text, xy=(coord_object[0], coord_object[1]), xytext=(10, -10), textcoords='offset points', bbox=dict(boxstyle="round", facecolor = "white", edgecolor = "white", alpha = 0.8)) + + # -DYN- Draw the force vectors + # Parameters for drawing forces + self.gravity = 9.81 + self.force_scaling = .01 + + # Weight + Fy = self.m_object*self.gravity*self.force_scaling + self.cable_weight = ax1.quiver(coord_object[0], coord_object[1], 0, -Fy, color='blue', angles='xy', scale_units='xy', scale=1, zorder=12, width=0.007) + self.cable_weight_text = ax1.annotate(r'$\vec{F}$', xy=(coord_object[0], coord_object[1]), xytext=(10, -55), textcoords='offset points', color='blue') + + # Tension + Tx = ((self.m_object*self.gravity) / (2*np.tan(alpha)))*self.force_scaling + Ty = .5*self.m_object*self.gravity*self.force_scaling + self.cable_tension_right = ax1.quiver(coord_object[0], coord_object[1], Tx, Ty, color='red', angles='xy', scale_units='xy', scale=1, zorder=12, width=0.007, linewidth=1) + self.cable_tension_right_text = ax1.annotate(r'$\vec{T}$', xy=(coord_object[0], coord_object[1]), xytext=(40, 5), textcoords='offset points', color='red') + self.cable_tension_left = ax1.quiver(coord_object[0], coord_object[1], -Tx, Ty, color='red', angles='xy', scale_units='xy', scale=1, zorder=12, width=0.007, linewidth=1) + self.cable_tension_left_text = ax1.annotate(r'$\vec{T}$', xy=(coord_object[0], coord_object[1]), xytext=(-45, 5), textcoords='offset points', color='red') + self.cable_tension_sum = ax1.quiver(coord_object[0], coord_object[1], 0, Fy, color='red', angles='xy', scale_units='xy', scale=1, zorder=12, width=0.007, facecolor="none", edgecolor="red", hatch="/"*8, linewidth=0.0) + self.cable_tension_sum_text = ax1.annotate(r'$\vec{T_r}$', xy=(coord_object[0], coord_object[1]), xytext=(10, 45), textcoords='offset points', color='red') + + + ###--- Then display the angle and the height as functions from the mass of the counterweight + # Create all possible values of the mass of the counterweight + m_cw = np.linspace(self.m_counterweight_min, self.m_counterweight_max, 100) + + # Compute the angle (in degrees) and height for all these values + angle = [] + height = [] + for m in m_cw: + a = self.get_angle(m) + angle.append(a*180/np.pi) + + c = self.get_object_coords(a) + height.append(c[1]) + + # Display the functions on the graphs + ax2.set_title(r'Height ($m$)') + ax2.set_xlabel('Mass of the counterweight (kg)') + ax2.plot(m_cw, height, "green") + + ax3.set_title(r'Angle $\alpha$ ($^\circ$)') + ax3.set_xlabel('Mass of the counterweight (kg)') + ax3.plot(m_cw, angle, "green") + + + # Draw the horizon lines + ax2.axhline(y=self.y_origin+self.height, color='gray', linestyle='-.', linewidth=1, zorder=1) + ax3.axhline(y=self.y_origin, color='gray', linestyle='-.', linewidth=1, zorder=1) + + # -DYN- Add the current height from the counterweight selected by the user + self.graph_height_point = ax2.scatter(self.m_counterweight, coord_object[1], s=80, c="black", zorder=15) + self.graph_height_text = ax2.annotate(height_text, xy=(self.m_counterweight, coord_object[1]), xytext=(10, -10), textcoords='offset points', bbox=dict(boxstyle="round", facecolor = "white", edgecolor = "white", alpha = 0.8)) + + # -DYN- Add the current angle from the counterweight selected by the user + self.graph_angle_point = ax3.scatter(self.m_counterweight, alpha_degrees, s=80, c="black", zorder=15) + self.graph_angle_text = ax3.annotate(alpha_text, xy=(self.m_counterweight, alpha_degrees), xytext=(10, 5), textcoords='offset points', bbox=dict(boxstyle="round", facecolor = "white", edgecolor = "white", alpha = 0.8)) + + + + ###--- Add a quiz from Moodle + iframe_quiz = ''' + + + ''' + widget_quiz = widgets.HTML(value=iframe_quiz) + + + ###--- Display the whole interface + display(VBox([self.fig.canvas, self.m_counterweight_input, widget_quiz])) + + # Hack: (brutal and not great, executes only once) hide the toolbar and the top and bottom part of figure using javascript and jquery + # js = """ + # """ + # display(HTML(js)); + + ###--- Add some javascript to have toggle solutions included in the notebook + # js = """ + # + # """ +# display(HTML(js)); +# + + + # Event handlers + def m_counterweight_event_handler(self, change): + self.m_counterweight = change.new + self.update_lab() + + + # Utility functions + def get_angle(self, m_counterweight): + """ + Computes the angle that the cable makes with the horizon depending on the counterweight chosen: + - if the counterweight is sufficient: angle = arcsin(1/2 * m_object / m_counterweight) + - else (object on the ground): alpha = arctan(height / (distance / 2)) + + :m_counterweight: mass of the chosen counterweight + + :returns: angle that the cable makes with the horizon (in rad) + """ + # Default alpha value i.e. object is on the ground + alpha_default = np.arctan(self.height / (self.distance / 2)) + alpha = alpha_default + + # Let's check that there is actually a counterweight + if m_counterweight > 0: + + # Then we compute the ratio of masses + ratio = 0.5 * self.m_object / m_counterweight + + # Check that the ratio of masses is in the domain of validity of arcsin ([-1;1]) + if abs(ratio) < 1: + alpha = np.arcsin(ratio) + + return min(alpha_default, alpha) + + + def get_object_coords(self, angle): + """ + Computes the position of the object on the cable taking into account the angle determined by the counterweight and the dimensions of the hanging system. + By default: + - the object is supposed to be suspended exactly in the middle of the cable + - the object is considered on the ground for all values of the angle which give a height smaller than the height of the poles + + :angle: angle that the cable makes with the horizon + + :returns: coordinates of the point at which the object are hanged + """ + # the jean is midway between the poles + x_object = self.x_origin + 0.5 * self.distance + + # default y value: the jean is on the ground + y_object = self.y_origin + + # we check that the angle is comprised between horizontal (greater than 0) and vertical (smaller than pi/2) + if angle > 0 and angle < (np.pi / 2): + # we compute the delta between the horizon and the point given by the angle + delta = (0.5 * self.distance * np.tan(angle)) + # we check that the delta is smaller than the height of the poles (otherwise it just means the jean is on the ground) + if delta <= self.height: + y_object = self.y_origin + self.height - delta + + return [x_object, y_object] + + + # Update the visualisation + def update_lab(self): + # Compute new values with the counterweight selected by the user + alpha = self.get_angle(self.m_counterweight) + alpha_degrees = alpha*180/np.pi + alpha_text = r'$\alpha$ = {:.2f} $^\circ$'.format(alpha_degrees) + + coord_object = self.get_object_coords(alpha) + height_text = r'h = {:.2f} $m$'.format(coord_object[1]) + + ### Update the clothesline figure + # Update of the cable line + x = np.array([self.x_origin, coord_object[0], self.x_origin+self.distance]) + y = np.array([self.y_origin+self.height, coord_object[1], self.y_origin+self.height]) + self.cable.set_xdata(x) + self.cable.set_ydata(y) + + # Update of the point + self.cable_point.set_offsets(coord_object) + self.cable_point_text.set_text(height_text) + self.cable_point_text.xy = (coord_object[0], coord_object[1]) + + # Update of the angle + self.cable_angle.theta1 = -1*alpha_degrees + self.cable_angle_text.set_text(alpha_text) + + # Update the weight position (direction does not change) + self.cable_weight.set_offsets(coord_object) + self.cable_weight_text.xy = (coord_object[0], coord_object[1]) + + # Update the tension position and directions + Tx = ((self.m_object*self.gravity) / (2*np.tan(alpha)))*self.force_scaling + Ty = .5*self.m_object*self.gravity*self.force_scaling + self.cable_tension_right.set_offsets(coord_object) + self.cable_tension_right.set_UVC(Tx, Ty) + self.cable_tension_right_text.xy = (coord_object[0], coord_object[1]) + self.cable_tension_left.set_offsets(coord_object) + self.cable_tension_left.set_UVC(-Tx, Ty) + self.cable_tension_left_text.xy = (coord_object[0], coord_object[1]) + self.cable_tension_sum.set_offsets(coord_object) + self.cable_tension_sum_text.xy = (coord_object[0], coord_object[1]) + + + ### Update the other two graphs + # Update point of angle + self.graph_angle_point.set_offsets([self.m_counterweight, alpha_degrees]) + self.graph_angle_text.set_text(alpha_text) + self.graph_angle_text.xy = (self.m_counterweight, alpha_degrees) + + # Update point of height + self.graph_height_point.set_offsets([self.m_counterweight, coord_object[1]]) + self.graph_height_text.set_text(height_text) + self.graph_height_text.xy = (self.m_counterweight, coord_object[1]) + + + # Display graph + self.fig.canvas.draw_idle() + + +def degrees_to_radians(angle_degrees): + return angle_degrees * np.pi / 180 + +def radians_to_degrees(angle_radians): + return angle_radians * 180 / np.pi + + +# EOF diff --git a/solution/Physics-solution.ipynb b/solution/Physics-solution.ipynb new file mode 100644 index 0000000..635c57a --- /dev/null +++ b/solution/Physics-solution.ipynb @@ -0,0 +1,112 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + " Teaching and Learning differently with Jupyter Notebooks - HEG, December 12, 2019
\n", + " C. Hardebolle, CC BY-NC-SA 4.0 Int.
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Solutions\n", + "\n", + "---\n", + "\n", + "## Activity 2: Looking more closely at the tension in the cable\n", + "\n", + "\n", + "Question 1 \n", + "\n", + "$\\lvert\\vec{T}\\rvert$ = 1686 $N$\n", + "\n", + "Question 2 \n", + "\n", + "The tension reaches 500 N for approximately 2°. \n", + "The tension reaches 1000 N for approximately 1°.\n", + "\n", + "Question 3 \n", + "\n", + "At time 0:53, the cable desintegrates completely. This is probably because it has grown weaker and weaker after repeated use until it cannot withstand the high tension anymore.\n", + "\n", + "
\n", + "\n", + "---\n", + "\n", + "## Additional exercises (optional)\n", + "\n", + "Question 1 \n", + "\n", + "A simple solution is:\n", + "```python\n", + "T_prime = T / gravity \n", + "``` \n", + "\n", + "This would give: $\\lvert\\vec{T}\\rvert = $ 172 kg$_F$ for a tension of 1686 $N$.\n", + "\n", + "A better designed option would be to first define a function so that you can reuse it at any time, then use the function to compute the value:\n", + "```python\n", + "def newtons_to_kgf(tension):\n", + " return tension / gravity\n", + "\n", + "T_prime = newtons_to_kgf(T)\n", + "```\n", + "\n", + "\n", + "Question 2 \n", + "\n", + "Two things happen:\n", + "* You get a warning message which says `RuntimeWarning: divide by zero encountered in double_scalars`\n", + "* The function nonetheless returns a value which is `inf`\n", + "\n", + "When the angle $\\alpha$ = 0 then $sin(\\alpha)$ = 0 and therefore we divide `(.5 * jeans_mass * gravity)` by 0 so on one hand, mathematically speaking, we know that the result should be $+\\infty$. On the other hand, we also know that usually division by 0 is not well supported by computers.\n", + "\n", + "Actually, division by 0 is not supported in standard Python. Try to execute the cell below to see what happens." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "(0.5 * 3 * 9.81)/0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, because in the calculation we use the function `np.sin()` from the Numpy library, our data is automatically converted to Numpy types, which support division by zero and returns the \"real\" result which is $+\\infty$. \n", + "By convention, Numpy also generates a warning message but this can be deactivated when not necessary. \n", + "If you are curious, you can take a look at [the errors generated by Numpy for floating-point calculations](https://docs.scipy.org/doc/numpy/reference/generated/numpy.seterr.html#numpy.seterr)." + ] + } + ], + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}