| \n", " | In class | \n", "Homework exercise | \n", "
|---|---|---|
| Suspended objects | \n", "This example includes an interactive prediction question in the form of a MCQ that can be asked to students using the notebook or any other technology of your choice (raise of hands, clickers, etc.) | \n", "The prediction question makes a nice quiz for students | \n", "
| Falling objects | \n", "In this example, the prediction question is paper-based, no technology involved other than the notebook! | \n", "This example illustrates the idea of a notebook \"to complete\", in which students write their own explanations and observations. \n", " This example contains a coding exercise allowing students to get a deeper understanding of how simulations work and develop their computational thinking | \n",
"
![\"apple](\"https://cdn4.iconfinder.com/data/icons/brainy-icons-free-36-science-and-education-icons/64/apple_64.png\"){kind=icon}
\n",
"\n",
"## The problem \n",
"We **drop** an object from a given height with **no initial velocity**. Just like an apple would fall from a tree. \n",
"We consider the movement of the object, **ignoring resistance from the air**.\n",
"\n",
" \n",
"\n",
"## Initial questions\n",
"\n",
"Answer the following questions _before_ using the virtual lab.\n",
"\n",
"**Question 1:** Which object would reach the ground first: a bowling ball (5 kg) or a tennis ball (0.05 kg)? Write down your answer in the cell below."
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Type your answer here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Question 2:** Why? In the cell below, describe in words your explanation for this behavior."
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Type your answer here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Tip:* In physics, as in many disciplines, sketching your ideas can really help you figure out problems. \n",
"It might be a good idea to take a piece of paper and sketch what you think the following variables will look like as a function of time: the *height* of the object, the *velocity* of the object and the *acceleration* of the object."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"## Virtual lab\n",
"The virtual demonstration below illustrates the movement of different objects. \n",
"Execute the cell below to launch the virtual demonstration, then *answer the questions below*."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"from lib.fallingobjects import *\n",
- "FallingObjectsLab();"
+ "FallingObjectsLab(show_withair=False);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"**Question 1:** Choose an initial height that will be the same for all the objects you will observe, e.g. 5 meters. \n",
"When does the each object reaches the ground? \n",
"Note down the time in seconds below."
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Object 1 reaches the ground at:\n",
"### Object 2 reaches the ground at:\n",
"### Object 3 reaches the ground at:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Tip:* Actually, the interactive figure allows you to plot the movement of several objects simultaneously by maintaining the 'ctrl' key selected while clicking with your mouse on the objects you want to display. \n",
"Try to select several objects to display simultaneously.\n",
"\n",
"**Question 2:** What can you conclude from this experiment? \n",
"*If you wonder how the virtual lab works and would like to see the code, [you can have a look at it at the end of this notebook](#How-does-the-virtual-lab-work%3F).*"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Type your answer here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"## Synthesis\n",
"\n",
"**Question 1:** How does your own explanation compare with the explanation provided below?"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Type your answer here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Problem analysis\n",
"![](\"Images/ball-diagram.png\")
\n",
"\n",
"We are looking for the time at which the object will reach the ground. Therefore *we are looking for an equation giving us the height of the object as a function of time*.\n",
"\n",
"We know the initial height and velocity of the object, as well as its mass. \n",
"In addition, if we ignore the friction from air, we know that the only force applied on the object is the weight: $\\vec F = m \\vec g$\n",
"\n",
"#### Movement of the object\n",
"Since there is only one force involved, it seems quite straightforward to use Newton's second law: $\\sum \\vec F = m \\vec a$\n",
"\n",
"With the weight the only force on the object, we get: $\\vec F = m \\vec a$ \n",
"Using the expression of the weight it gives us: $m \\vec g = m \\vec a$ \n",
"Therefore the movement of the object is described by $\\vec a = \\vec g$.\n",
"\n",
"To get the equation of acceleration as a function of time, we project onto our coordinate system: $a = -g$, therefore $a(t) = -g$. \n",
"This means that the ball is under **constant acceleration**.\n",
"\n",
"From there we can get the equations for velocity and height by integrating successively: \n",
"$\\left\\{\\begin{matrix} a(t) = -g \\\\ v(t) = -g\\,t + v_0 \\\\ h(t) = -\\frac{1}{2}\\,g\\,t^2 + v_0\\,t + h_0\\end{matrix}\\right. $\n",
"\n",
"The above equations have the following parameters:\n",
"* the initial height $h_0$ from which the object is dropped\n",
"* the initial velocity of the object $v_0$, with $v_0 = 0$ when the object is dropped with no initial velocity\n",
"* and of course the acceleration due to gravity $g$\n",
"\n",
"#### Conclusion\n",
"We see clearly that **the mass $m$ of the object plays no role at all in the equations of the movement**.\n",
"\n",
"**Question 2:** What happens if we don't ignore the resistance of the air?"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Type your answer here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Question 3:** Why is it reasonable to ignore the resistance of the air in this situation? \n",
"List the criteria that you could you to decide if resistance from the air can be ignored or not when solving a problem."
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"### Type your answer here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
" \n",
"\n",
"---\n",
"\n",
"## How does that look in real life?\n",
"\n",
"The following video demonstrates how a bowling ball and ostrich feathers fall in a vacuum chamber, thus illustrating how what we have seen so far looks in the real world."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.display import YouTubeVideo\n",
"YouTubeVideo('E43-CfukEgs', 560, 315)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"---\n",
"## How does the virtual lab work?\n",
"\n",
"You can have a look at the code of the virtual lab by [opening this python file](lib/fallingobjects.py). \n",
"By executing the following three cells, you will see the code of the three functions used to compute the movement equations for the falling object.\n",
"\n",
"#### Code of $a(t) = -g$\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"accel_time??"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Code of $v(t) = -g\\,t + v_0$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"veloc_time??"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Code of $h(t) = -\\frac{1}{2}\\,g\\,t^2 + v_0\\,t + h_0$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"height_time??"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"---\n",
"\n",
"## Other resources on the web\n",
"\n",
"Detailed explanations with examples on falling objects: https://opentextbc.ca/physicstestbook2/chapter/falling-objects/\n",
"\n",
"Impact of air resistance on falling objects (in French): http://www.physagreg.fr/mecanique/m12/M12-chute-libre-frottements.pdf"
]
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
diff --git a/TeachingExamples/SuspendedObjects-demo.ipynb b/TeachingExamples/SuspendedObjects-demo.ipynb
index 6da8587..a03263d 100644
--- a/TeachingExamples/SuspendedObjects-demo.ipynb
+++ b/TeachingExamples/SuspendedObjects-demo.ipynb
@@ -1,145 +1,148 @@
{
"cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This notebook is about demonstrating:\n",
+ "* using **different types of questions** to engage students with the virtual demonstration\n",
+ "* using **different types of visualizations** to help students understand the phenomena\n",
+ "\n",
+ "The example chosen is voluntarily *simple* so that anyone can understand what is illustrated and focus the pedagogical features of the example.\n",
+ "\n",
+ "---"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Suspended objects\n",
"\n",
"## In-class scenario\n",
"\n",
"### Problem\n",
"![](\"Images/jean.png\")
\n",
"\n",
"We consider a clothesline made of two poles and a cable. \n",
"The cable is fixed on one pole. A pulley on the other pole allows to attach a counterweight to pull the cable taut.\n",
"\n",
"### Questions\n",
"\n",
"1. Ask the following **prediction question** to students:\n",
- " * Estimate which counterweight allows to suspend wet jeans (3kg) on the cable so that the cable is taut as shown on the diagram: 1,5 kg, 3 kg, 6 kg, 20 kg, 50 kg or more\n",
+ " * Estimate which counterweight allows to suspend wet jeans (3kg) on the cable so that the cable is taut as shown on the diagram?\n",
+ " * 1,5 kg\n",
+ " * 3 kg\n",
+ " * 6 kg\n",
+ " * 20 kg\n",
+ " * 50 kg or more\n",
" * Why? Describe in words your explanation for this behavior.\n",
- " \n",
- "#### TODO: here, replace by interactive polling question!!!\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "from ipywidgets import interact\n",
- "print(\"Estimate which counterweight allows to suspend wet jeans (3kg) on the cable so that the cable is taut as shown on the diagram: \")\n",
- "f = lambda w:str(w)\n",
- "interact(f, w=['1,5 kg', '3 kg', '6 kg', '20 kg', '50 kg or more']);"
+ " "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"2. Run the demo and ask the following **observation questions** :\n",
" * What it the height of the point at which the jeans are suspended for a counterweight of 3kg?\n",
" * What it the height of the point at which the jeans are suspended for a counterweight of 6kg?\n",
" * What it the height of the point at which the jeans are suspended for a counterweight of 20kg?\n",
" * What it the height of the point at which the jeans are suspended for a counterweight of 50kg?\n",
" * What can you conclude from this experiment?\n",
"\n",
"\n",
"3. Provide the explanation (e.g. solving the problem on the board), and have students compare their explanation with your own explanation."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Virtual demo"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"from lib.suspendedobjects import *\n",
- "\n",
- "SuspendedObjectsLab(m_object = 3);"
+ "SuspendedObjectsLab();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*If you wonder how the virtual lab works and would like to see the code, [you can have a look at it at the end of this notebook](#How-does-the-virtual-lab-work%3F).*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"# How does the virtual demo work?\n",
"\n",
"You can have a look at the code of the virtual demo by [opening this python file](lib/suspendedobjects.py). \n",
"\n",
"## Use of the virtual demo\n",
"\n",
"Execute the cell below to see the documentation:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"SuspendedObjectsLab?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Utility computation function\n",
"\n",
"By executing the following cell, you will see the code of the function used to compute the angle that the line makes with the horizon depending on the masses of the object and the counterweight. \n",
"This function can be redefined and given as parameter when initializing the lab."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"get_angle_from_masses??"
]
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
diff --git a/TeachingExamples/SuspendedObjects-exercise.ipynb b/TeachingExamples/SuspendedObjects-exercise.ipynb
index b3e321c..9542ede 100644
--- a/TeachingExamples/SuspendedObjects-exercise.ipynb
+++ b/TeachingExamples/SuspendedObjects-exercise.ipynb
@@ -1,204 +1,205 @@
{
"cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This notebook is about demonstrating:\n",
+ "* making a demonstration available to students in the form of an exercise including **auto-corrected quizzes**\n",
+ "* using **different types of visualizations** to help students understand the phenomena\n",
+ "\n",
+ "The example chosen is voluntarily *simple* so that anyone can understand what is illustrated and focus the pedagogical features of the example.\n",
+ "\n",
+ "---"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Suspended objects\n",
"\n",
"## The problem\n",
"\n",
"\n",
"We consider a clothesline made of two poles and a cable.\n",
"The cable is fixed on one pole. A pulley on the other pole allows to attach a counterweight to pull the cable taut.\n",
"\n",
"## Initial questions\n",
"\n",
"**Question:** Estimate which counterweight allows to suspend wet jeans (3kg) on the cable so that the cable is taut as shown on the diagram below? \n",
"\n",
"#### TODO: here, replace by auto-corrected quiz!!!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Virtual lab"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"from lib.suspendedobjects import *\n",
"SuspendedObjectsLab();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"*If you wonder how the virtual lab works and would like to see the code, [you can have a look at it at the end of this notebook](#How-does-the-virtual-lab-work%3F).*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Conceptual explanation\n",
"\n",
"TODO"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Analytic explanation\n",
"\n",
"### Hypotheses and simplifications:\n",
"\n",
"* the jeans are exactly mid-way between the poles so the tension is equal on both sides of the cable\n",
- "* we represent the jeasn by the point at which they are suspended\n",
- "* the cable is considered as rigid (not bended)\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",
- "We are looking for the expression of the mass of the counterweight as a function of the other parameters of the problem.\n",
+ "We are looking for the expression of the **mass of the counterweight as a function of the other parameters of the problem**.\n",
"\n",
"![](\"Images/jean-solution.png\")
\n",
"\n",
- "The forces applied on the *jeans* are the following:\n",
+ "The *forces applied on the jeans* are the following:\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 tention $\\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",
- "\n",
- "With the forces: $\\vec F_j + \\vec T_r = 0$\n",
- "\n",
+ "From Newton's second law in a static equilibrium we can write: $\\sum \\vec F_j = \\vec 0$ \n",
+ "With the forces involved in our problem we get: $\\vec F_j + \\vec T_r = 0$ \n",
"Using the fact that the tension is equal on both sides of the jeans: $\\vec F_j + 2.\\vec T = 0$\n",
"\n",
- "If we project on $x$ and $y$ axes, we get:\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",
- "\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",
- "NB: $T_x = 0$ means that the tension on each side of the jeans cancel out.\n",
- "\n",
- "The component of the weight on the y axis is $F_{jy} = - m_j.g$, which gives us:\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",
- "So we get:\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$:\n",
- "\n",
+ "From there we can get $T$: \n",
"$T = \\frac{m_j.g}{2.sin(\\alpha)}$ $(1)$\n",
"\n",
+ " \n",
"\n",
"On the other hand, the forces applied on the *counterweight* are following:\n",
"* the weight: $\\vec F_{cw} = m_{cw} \\vec g$ \n",
"* the force exerted by the line: 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",
- "\n",
- "With the forces: $\\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",
- "\n",
- "With the detail of the weight: $-m_{cw}.g + T = 0$\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",
+ "Using the expression of the weight: $-m_{cw}.g + T = 0$ \n",
"Which gives us $T = m_{cw}.g$ $(2)$\n",
"\n",
- "From equations $(1)$ and $(2)$ we get:\n",
- "\n",
+ "From equations $(1)$ and $(2)$ we get: \n",
"$\\left\\{\\begin{matrix}T = \\frac{m_j.g}{2.sin(\\alpha)} \\\\ T = m_{cw}.g\\end{matrix}\\right. $\n",
"\n",
- "Which allows us to find the mass of the counterweight as a function of the *mass of the jeans* and of the *angle that the line makes with the horizon*:\n",
- "\n",
+ "Which allows us to find the mass of the counterweight as a function of the *mass of the jeans* and of the *angle that the line makes with the horizon*: \n",
"$m_{cw} = \\frac{m_j}{2.sin(\\alpha)}$\n",
"\n",
"For the line to be taut as show on the figure, $\\alpha$ has to be really small i.e. close to zero. \n",
"This means that $sin(\\alpha)$ will also be close to zero, which means in turn that $m_{cw}$ will be very big.\n",
"Actually, **the more we want the line to be close to the horizon, the bigger $m_{cw}$ we will need!**\n",
"In fact, it is impossible to get the line taut so that it is absolutely straight...\n",
"\n",
"### Application\n",
"\n",
"For a pair of wet jeans of $3 kg$ and an angle of $4^\\circ = \\frac{\\pi}{45}$, which is approximately like depicted on the figure, we need to put a counterweight of more than 20 kg!\n",
"\n",
"You can try out the manual calculation below and check that you get a similar result with the virtual lab above:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"m_j = 3\n",
"alpha = np.pi / 45\n",
"\n",
"m_cw = m_j / (2 * np.sin(alpha))\n",
"print(m_cw)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"---\n",
"# How does the virtual lab work?\n",
"\n",
"You can have a look at the code of the virtual lab by [opening this python file](lib/suspendedobjects.py).\n",
"\n",
"By executing the following cell, you will see the code of the function used to compute the angle that the line makes with the horizon depending on the masses of the object and the counterweight. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"get_angle_from_masses??"
]
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
diff --git a/TeachingExamples/lib/fallingobjects.py b/TeachingExamples/lib/fallingobjects.py
index f1a0ccc..1e4a1c5 100644
--- a/TeachingExamples/lib/fallingobjects.py
+++ b/TeachingExamples/lib/fallingobjects.py
@@ -1,242 +1,345 @@
import numpy as np
import pandas
from ipywidgets import interact, interactive, fixed, interact_manual
-from ipywidgets import HBox, VBox, Label, Layout
+from ipywidgets import Box, HBox, VBox, Label, Layout
import ipywidgets as widgets
from IPython.display import set_matplotlib_formats
set_matplotlib_formats('svg')
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid') # global style for plotting
-###--- Functions representing the equations of the movement as functions of time and the problem parameters
-def accel_time(g, h_0, v_0, m, t):
+###--- Equation functions implementing a model without air resistance (free fall)
+def accel_time(o, g, h_0, v_0, t):
'''
- Computes the acceleration of the object as a function of time
- a(t) = -g
+ Computes the acceleration of the object o as a function of time
+ Implements a constantly accelerated vertical motion (free fall) of equation: a(t) = -g
+ :o: object considered
:g: gravitational acceleration constant
:h_0: initial height of the object
:v_0: initial velocity of the object
- :m: mass of the object
:t: time scale (array of time points at which to compute the equation)
:returns: array of values for acceleration at each point of the time scale
'''
return [-g] * t.size # returning a list of same length as the time interval filled with -g
-def veloc_time(g, h_0, v_0, m, t):
+def veloc_time(o, g, h_0, v_0, t):
'''
- Computes the velocity of the object as a function of time
- v(t) = -g.t + v_0
+ Computes the velocity of the object o as a function of time
+ Implements a constantly accelerated vertical motion (free fall) of equation: v(t) = -g.t + v_0
+ :o: object considered
:g: gravitational acceleration constant
:h_0: initial height of the object
:v_0: initial velocity of the object
- :m: mass of the object
:t: time scale (array of time points at which to compute the equation)
:returns: array of values for velocity at each point of the time scale
'''
return -g * t + v_0
-def height_time(g, h_0, v_0, m, t):
+def height_time(o, g, h_0, v_0, t):
'''
- Computes the height of the object as a function of time
- h(t) = -1/2.g.t^2 + v_0.t + h_0
+ Computes the height of the object o as a function of time
+ Implements a constantly accelerated vertical motion (free fall) of equation: h(t) = -1/2.g.t^2 + v_0.t + h_0
+ :o: object considered
:g: gravitational acceleration constant
:h_0: initial height of the object
:v_0: initial velocity of the object
- :m: mass of the object
:t: time scale (array of time points at which to compute the equation)
:returns: array of values for height at each point of the time scale
'''
return -0.5 * g * (t **2) + v_0 * t + h_0
+###--- Equation functions implementing a model with linear friction from air
+def accel_time_withair(obj, g, h_0, v_0, t):
+ '''
+ Computes the height of the object o as a function of time
+ Implements a vertical motion taking into account a linear friction from air
+
+ :o: object considered -- must have a mass and a friction coefficient k
+ :g: gravitational acceleration constant
+ :h_0: initial height of the object
+ :v_0: initial velocity of the object
+ :t: time scale (array of time points at which to compute the equation)
+
+ :returns: array of values for height at each point of the time scale
+ '''
+ coeff = obj.k / obj.mass
+ return -g * np.exp(- coeff * t)
+
+def veloc_time_withair(obj, g, h_0, v_0, t):
+ '''
+ Computes the height of the object o as a function of time
+ Implements a vertical motion taking into account a linear friction from air
+
+ :o: object considered -- must have a mass and a friction coefficient k
+ :g: gravitational acceleration constant
+ :h_0: initial height of the object
+ :v_0: initial velocity of the object
+ :t: time scale (array of time points at which to compute the equation)
+
+ :returns: array of values for height at each point of the time scale
+ '''
+ coeff = obj.k / obj.mass
+ return (v_0 + (g / coeff)) * np.exp(- coeff * t) - (g / coeff)
+
+def height_time_withair(obj, g, h_0, v_0, t):
+ '''
+ Computes the height of the object o as a function of time
+ Implements a vertical motion taking into account a linear friction from air
+
+ :o: object considered -- must have a mass and a friction coefficient k
+ :g: gravitational acceleration constant
+ :h_0: initial height of the object
+ :v_0: initial velocity of the object
+ :t: time scale (array of time points at which to compute the equation)
+
+ :returns: array of values for height at each point of the time scale
+ '''
+ coeff = obj.k / obj.mass
+ return (1 / coeff) * (v_0 + (g / coeff)) * (1 - np.exp(- coeff * t)) - (g / coeff) * t + h_0
+
+
###--- Static list of objects with which we can experiment.
-# Objects come with a name, a mass (in kg) and a color for identifying them in the graphical display.
+# Objects come with a name, a mass (in kg), a friction coefficient and a color for identifying them in the graphical display.
objects = [{
'name':'Bowling ball',
'mass':5.0,
+ 'k': (6*np.pi*0.11) * 1.8*10**-5,
'color':'#DC143C'
},{
'name':'Tennis ball',
- 'mass':0.05,
+ 'mass':0.0567,
+ 'k': (6*np.pi*0.032) * 1.8*10**-5,
'color':'#2E8B57'
- },{
- 'name':'Ostrich feather',
- 'mass':0.005,
- 'color':'#483D8B'
+ },{
+ 'name':'Ping-pong ball',
+ 'mass':0.0027,
+ 'k': (6*np.pi*0.02) * 1.8*10**-5,
+ 'color':'#FF4500'
+ },{
+ 'name':'Air-inflated balloon',
+ 'mass':0.013,
+ 'k': 0.02,#(6*np.pi*0.28) * 1.8*10**-5,
+ 'color':'#000080'
}]
+def object_string(obj):
+ '''Utility function to print objects nicely'''
+ return '{!s}:\n mass = {} kg \n friction coeff. = {:.2e}'.format(obj.name, obj.mass, obj.k)
+
+###--- Virtual lab
class FallingObjectsLab:
"""
This class embeds all the necessary code to create a virtual lab to study the movement of objects falling vertically in vacuum.
"""
- def __init__(self, g = 9.81, h_0 = 5, v_0 = 0, t = np.linspace(0,3,25), objects = objects,
+ def __init__(self, objects = objects, g = 9.81, h_0 = 1.5, v_0 = 0, t = np.linspace(0,1.5,30),
accel_time = accel_time, veloc_time = veloc_time, height_time = height_time,
- show_v_0 = False):
+ accel_time_withair = accel_time_withair, veloc_time_withair = veloc_time_withair, height_time_withair = height_time_withair,
+ show_v_0 = False, show_withair = True):
'''
Initiates and displays the virtual lab on falling objects.
+ :objects: nested dictionnary with the objects to display, which should come with a name, a mass (in kg), a radius (in m) and a color (hex code)
+
:g: gravitational acceleration constant
:h_0: initial height of the objects
:v_0: initial velocity of the objects
:t: time scale (array of time points at which to compute the equation)
- :objects: nested dictionnary with the objects to display, which should come with a name, a mass (in kg) and a color (hex code)
- :accel_time: function to compute the acceleration of the objects as a function of time -- a(g, h_0, v_0, m, t)
- :veloc_time: function to compute the velocity of the objects as a function of time -- v(g, h_0, v_0, m, t)
- :height_time: function to compute the height of the objects as a function of time -- h(g, h_0, v_0, m, t)
-
+ :accel_time: function to compute the acceleration of an object as a function of time -- without air resistance -- a(o, g, h_0, v_0, t)
+ :veloc_time: function to compute the velocity of an object as a function of time -- without air resistance -- v(o, g, h_0, v_0, t)
+ :height_time: function to compute the height of an object as a function of time -- without air resistance -- h(o, g, h_0, v_0, t)
+
+ :accel_time_withair: function to compute the acceleration of an object as a function of time -- WITH air resistance -- a(o, g, h_0, v_0, t)
+ :veloc_time_withair: function to compute the velocity of an object as a function of time -- WITH air resistance -- v(o, g, h_0, v_0, t)
+ :height_time_withair: function to compute the height of an object as a function of time -- WITH air resistance -- h(o, g, h_0, v_0, t)
+
:show_v_0: when True, a slider to change the initial velocity of objects is displayed in the interface
+ :show_withair: when True, a checkbox allows to plot the equations which include air resistance
'''
###--- We define the parameters of our problem:
+ # Create indexed list of objects
+ self.objects_list = pandas.DataFrame(objects)
+ self.objects_list.set_index('name', inplace=True) # We index objects by their name to find them easily after
+
+ # Initialize list of currently selected objects with first element of the list
+ self.selected_objs_names = [self.objects_list.index[0],]
+
+
# The standard acceleration due to gravity
self.g = g # gravity in m/s2
# The initial conditions of our problem
self.h_0 = h_0 # initial height in m
self.v_0 = v_0 # initial velocity in m/s
# To plot the movement of our objects in time we need to define a time scale.
self.t = t # time interval from 0 to x seconds, with n points in the interval
- # Functions to compute movement equations
+ # Functions to compute movement equations - free fall (no air resistance)
self.accel_time = accel_time
self.veloc_time = veloc_time
self.height_time = height_time
-
- # Create indexed list of objects
- self.objects_list = pandas.DataFrame(objects)
- self.objects_list.set_index('name', inplace=True) # We index objects by their name to find them easily after
-
- # Initialize list of currently selected objects with first element of the list
- self.objs = [self.objects_list.index[0],]
+ # Functions to compute movement equations - with air resistance (linear friction)
+ self.withair = False
+ self.accel_time_withair = accel_time_withair
+ self.veloc_time_withair = veloc_time_withair
+ self.height_time_withair = height_time_withair
+
- ###--- Then we define the elements of the ihm:
+ ###--- Then we define the elements of the IHM:
# parameters for sliders
self.h_min = 0
- self.h_max = 10
+ self.h_max = 3
self.v_min = 0
- self.v_max = 5
+ self.v_max = 3
# IHM input elements
- input_layout=Layout(margin='5px 10px')
+ input_layout=Layout(margin='2px 6px')
self.h_label = Label('Initial height ($m$):', layout=input_layout)
- self.h_widget = widgets.FloatSlider(min=self.h_min,max=self.h_max,step=1,value=self.h_0, layout=input_layout)
+ self.h_widget = widgets.FloatSlider(min=self.h_min,max=self.h_max,value=self.h_0, layout=input_layout)
self.h_input = HBox([self.h_label, self.h_widget])
self.v_label = Label('Initial velocity ($m.s^{-1}$):', layout=input_layout)
- self.v_widget = widgets.FloatSlider(min=self.v_min,max=self.v_max,step=1,value=self.v_0, layout=input_layout)
+ self.v_widget = widgets.FloatSlider(min=self.v_min,max=self.v_max,value=self.v_0, layout=input_layout)
self.v_input = HBox([self.v_label, self.v_widget])
- self.obj_m_label = Label('Choice of object(s):', layout=input_layout)
- self.obj_m_widget = widgets.SelectMultiple(
+ self.obj_label = Label('Choice of object(s):', layout=input_layout)
+ self.obj_widget = widgets.SelectMultiple(
options = self.objects_list.index,
- value = self.objs,
+ value = self.selected_objs_names,
disabled = False,
layout=input_layout
)
- self.obj_m_input = HBox([self.obj_m_label, self.obj_m_widget])
-
+ self.obj_input = HBox([self.obj_label, self.obj_widget])
+
+ self.air_label = Label('Include air friction:', layout=input_layout)
+ #self.air_widget = widgets.Checkbox(value=self.withair, layout=input_layout)
+ self.air_widget = widgets.ToggleButton(value=self.withair, description="ok", layout=input_layout)
+ self.air_input = HBox([self.air_label, self.air_widget])
+
+
# IHM output elements
- self.obj_m_output = widgets.Output(layout=input_layout)
+ self.obj_output = widgets.Output(layout=input_layout)
self.graph_output = widgets.Output(layout=input_layout)
# Linking widgets to handlers
self.h_widget.observe(self.h_event_handler, names='value')
self.v_widget.observe(self.v_event_handler, names='value')
- self.obj_m_widget.observe(self.obj_m_event_handler, names='value')
+ self.obj_widget.observe(self.obj_event_handler, names='value')
+ self.air_widget.observe(self.air_event_handler, names='value')
- # Organize layout
+ # Organize layout
+ opt_inputs = [self.h_input]
+ if show_v_0: opt_inputs.append(self.v_input)
+ if show_withair: opt_inputs.append(self.air_input)
+
self.ihm = VBox([self.graph_output,
HBox([
- VBox([self.obj_m_input, self.obj_m_output]),
- VBox([self.h_input, self.v_input]) if show_v_0 else VBox([self.h_input])
+ VBox([self.obj_input, self.obj_output]),
+ VBox(opt_inputs)
])
])
###--- Finally, we display the whole interface and we update it right away so that it plots the graph with current values
display(self.ihm);
self.update_lab()
# Event handlers
def h_event_handler(self, change):
self.h_0 = change.new
self.update_lab()
def v_event_handler(self, change):
self.v_0 = change.new
self.update_lab()
- def obj_m_event_handler(self, change):
- self.objs = change.new
+ def obj_event_handler(self, change):
+ self.selected_objs_names = change.new
+ self.update_lab()
+
+ def air_event_handler(self, change):
+ self.withair = change.new
self.update_lab()
- # Display updated output function
+ # Update output function
def update_lab(self):
# Clear outputs
self.graph_output.clear_output(wait=True)
- self.obj_m_output.clear_output(wait=True)
+ self.obj_output.clear_output(wait=True)
# Create the figure
- fig, ax = plt.subplots(1, 3, sharex='col', figsize=(16, 4))
+ fig, ax = plt.subplots(1, 3, sharex='col', figsize=(14, 4))
# for each object currently selected
- for o in self.objs:
- # get mass
- m = self.objects_list.at[o,'mass']
- # get color
- c = self.objects_list.at[o,'color']
-
+ for o_name in self.selected_objs_names:
+ # Get the selected object
+ obj = self.objects_list.loc[o_name]
+
# Recompute equations with parameters set by the user
- h_t = self.height_time(self.g, self.h_0, self.v_0, m, self.t)
- v_t = self.veloc_time(self.g, self.h_0, self.v_0, m, self.t)
- a_t = self.accel_time(self.g, self.h_0, self.v_0, m, self.t)
-
+ h_t = self.height_time(obj, self.g, self.h_0, self.v_0, self.t)
+ v_t = self.veloc_time(obj, self.g, self.h_0, self.v_0, self.t)
+ a_t = self.accel_time(obj, self.g, self.h_0, self.v_0, self.t)
+
# Plot equations
ax[0].set_title('Height ($m$)')
- ax[0].plot(self.t, h_t, color=c, label=o)
- ax[0].set_ylim(bottom = 0, top = self.h_max+(self.v_max/2 if self.v_0 > 0 else 1))
+ ax[0].plot(self.t, h_t, color=obj.color, label=o_name)
+ ax[0].set_ylim(bottom = 0, top = self.h_max+(self.v_max/2 if self.v_0 > 0 else 0.2))
ax[1].set_title('Velocity ($m.s^{-1}$)')
- ax[1].plot(self.t, v_t, color=c, label=o)
+ ax[1].plot(self.t, v_t, color=obj.color, label=o_name)
ax[1].set_ylim(top = self.v_max+1)
ax[2].set_title('Acceleration ($m.s^{-2}$)')
- ax[2].plot(self.t, a_t, color=c, label=o)
- ax[2].set_ylim(top = 0)
-
- # Display weight of object selected
- with self.obj_m_output:
- print("Mass of the selected object (kg): ", m)
+ ax[2].plot(self.t, a_t, color=obj.color, label=o_name)
+ ax[2].set_ylim(top = 0, bottom = - self.g - 1)
+
+ # If air resistance is activated, then compute the equations and plot them on top
+ if self.withair:
+ h_t_withair = self.height_time_withair(obj, self.g, self.h_0, self.v_0, self.t)
+ ax[0].plot(self.t, h_t_withair, color=obj.color, linestyle='dashed', label=o_name+" with air friction")
+
+ v_t_withair = self.veloc_time_withair(obj, self.g, self.h_0, self.v_0, self.t)
+ ax[1].plot(self.t, v_t_withair, color=obj.color, linestyle='dashed', label=o_name+" with air friction")
+
+ a_t_withair = self.accel_time_withair(obj, self.g, self.h_0, self.v_0, self.t)
+ ax[2].plot(self.t, a_t_withair, color=obj.color, linestyle='dashed', label=o_name+" with air friction")
+
+
+ # Display characteristics of object selected
+ with self.obj_output:
+ print(object_string(obj))
# Add time axis and legend
for a in ax:
a.set_xlabel('Time (s)')
a.legend()
fig.tight_layout()
# Display graph
with self.graph_output:
plt.show();
-
+
+
# EOF
diff --git a/Welcome.ipynb b/Welcome.ipynb
index a0d3541..01c32f5 100644
--- a/Welcome.ipynb
+++ b/Welcome.ipynb
@@ -1,79 +1,79 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"# Welcome to 's  notebooks"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Congratulations!\n",
"\n",
"You have just used `nbgitpuller` to **clone** a git repository (https://c4science.ch/source/noto-poc-notebooks/) and **pull** its content in your jupyter workspace.\n",
"\n",
"The aim of this repository is to give you some practical hints on both the pedagogical and technical aspects of notebook writing.\n",
"\n",
"### Share the link !\n",
"\n",
"Feel free to share the following link and give other people access to this git repository: https://go.epfl.ch/bDS"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Available notebooks\n",
"\n",
"\n",
"|  | Using notebooks for teaching: examples | |  | Technical notebooks |\n",
"|:-|:-|--|:-|:-|\n",
- "|  | Examples of notebooks for [virtual demonstrations](Demonstrations/Demonstrations.ipynb) in class | |  | How to [organize](HowTos/OrganizeCode/OrganizeCode.ipynb) your Python code?|\n",
+ "|  | Examples of notebooks for [virtual demonstrations](TeachingExamples/Demonstrations.ipynb) in class | |  | How to [organize](HowTos/OrganizeCode/OrganizeCode.ipynb) your Python code?|\n",
"| | | |   | How to embed [external resources](HowTos/EmbedExternalResources/EmbedExternalResources.ipynb) in your notebooks? |\n",
"| | | |  | How to [share](HowTos/SharingYourNotebooks/SharingYourNotebooks.ipynb) your notebooks wih git? |\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Contact and support\n",
"\n",
"For any question, feel free to contact  support: [noto-support@groupes.epfl.ch](mailto:noto-support@groupes.epfl.ch)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**End of the notebook**"
]
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}