{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Fakultät für Physik\n", "\n", "## Physikalisches Praktikum P1 für Studierende der Physik\n", "\n", "Versuch P1-20, 21, 22 (Stand: Oktober 2023)\n", "\n", "[Raum F1-11](https://labs.physik.kit.edu/img/Praktikum/Lageplan_P1.png)\n", "\n", "\n", "\n", "# Pendel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Name: _surname1_ Vorname: _name1_ E\\-Mail: _mail1_\n", "\n", "\\begin{equation*}\n", "\\begin{split}\n", "&\\\\\n", "&\\\\\n", "\\end{split}\n", "\\end{equation*}\n", "\n", "Name: _surname2_ Vorname: _name2_ E\\-Mail: _mail2_\n", "\n", "\\begin{equation*}\n", "\\begin{split}\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "\\end{split}\n", "\\end{equation*}\n", "\n", "Gruppennummer: _groupnumber_\n", "\n", "\\begin{equation*}\n", "\\begin{split}\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "\\end{split}\n", "\\end{equation*}\n", "\n", "Betreuer: \n", "\n", "\\begin{equation*}\n", "\\begin{split}\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "\\end{split}\n", "\\end{equation*}\n", "\n", "Versuch durchgeführt am: _date_" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "**Beanstandungen:**\n", "\n", "\\begin{equation*}\n", "\\begin{split}\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "&\\\\\n", "\\end{split}\n", "%\\text{\\vspace{10cm}}\n", "\\end{equation*}\n", "\n", "
\n", "Testiert am: __________________ Testat: __________________\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Hilfsfunktionen. Nicht weiter beachten\n", "from IPython.core.display import Markdown\n", "from IPython.display import display\n", "def M_helper_func(txt):\n", " #print(txt)\n", " #print('fr\"'+txt.replace(\"§\",\"$\").replace(\"{\",\"{{\").replace(\"}\",\"}}\").replace(\"[!\",\"{\").replace(\"!]\",\"}\")+'\"')\n", " execreturnvalue = \"\"\n", " loc = {}\n", " exec('execreturnvalue = fr\"
'+txt.replace(\"{\",\"{{\").replace(\"}\",\"}}\").replace(\"[!\",\"{\").replace(\"!]\",\"}\")+'
\"', globals(), loc)\n", " display(Markdown(loc[\"execreturnvalue\"]))\n", " return loc[\"execreturnvalue\"]\n", "\n", "from IPython.core.magic import (register_line_magic,\n", " register_cell_magic)\n", "\n", "from IPython.core import magic\n", "\n", "def register_line_magic(f):\n", " setattr(f, magic.MAGIC_NO_VAR_EXPAND_ATTR, True)\n", " return magic.register_line_magic(f)\n", "\n", "@register_line_magic\n", "def m(line):\n", " M_helper_func(line)\n", "\n", "\n", "import os\n", "import numpy as np\n", "from numpy import pi\n", "import matplotlib.pyplot as plt\n", "import matplotlib as mpl\n", "import scipy as sci\n", "import kafe2\n", "import pandas as pd\n", "from uncertainties import ufloat, unumpy\n", "from uncertainties.unumpy import nominal_values, nominal_values as nomv, std_devs, std_devs as stdv\n", "from uncertainties.umath import sqrt as usqrt, sin as usin,exp as uexp\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "import scipy\n", "mpl.rcParams['figure.dpi'] = 100\n", "\n", "\n", "\n", "\n", "class ng:\n", " def __init__(self,x=None,stat=None,syst=None):\n", " if x == None:\n", " self.syst = None\n", " self.stat = None\n", " else:\n", " self.syst = ufloat(x,0)\n", " self.stat = ufloat(x,0)\n", " if syst != None:\n", " self.syst = ufloat(x,syst)\n", " if stat != None:\n", " self.stat = ufloat(x,stat)\n", " def SetSyst(self,syst):\n", " self.syst = ufloat(nomv(self.syst),syst)\n", " def SetStat(self,stat):\n", " self.stat = ufloat(nomv(self.stat),stat)\n", " def __str__(self):\n", " return f'{nomv(self.stat):.2}±ₛₜₐₜ{stdv(self.stat):.2}±ₛᵧₛₜ{stdv(self.syst):.2}'\n", " def __add__(self,o):\n", " res = ng()\n", " if type(o) == ng:\n", " res.syst = self.syst + o.syst\n", " res.stat = self.stat + o.stat\n", " else:\n", " res.syst = self.syst + o\n", " res.stat = self.stat + o\n", " return res\n", " def __iadd__(self,o):\n", " return self.__add__(o)\n", " def __sub__(self,o):\n", " res = ng()\n", " if type(o) == ng:\n", " res.syst = self.syst - o.syst\n", " res.stat = self.stat - o.stat\n", " else:\n", " res.syst = self.syst - o\n", " res.stat = self.stat - o\n", " return res\n", " def __isub__(self,o):\n", " return self.__sub__(o)\n", " def __mul__(self,o):\n", " res = ng()\n", " if type(o) == ng:\n", " res.syst = self.syst * o.syst\n", " res.stat = self.stat * o.stat\n", " else:\n", " res.syst = self.syst * o\n", " res.stat = self.stat * o\n", " return res\n", " def __imul__(self,o):\n", " return self.__mul__(o)\n", " def __truediv__(self,o):\n", " res = ng()\n", " if type(o) == ng:\n", " res.syst = self.syst / o.syst\n", " res.stat = self.stat / o.stat\n", " else:\n", " res.syst = self.syst / o\n", " res.stat = self.stat / o\n", " return res\n", " def __itruediv__(self,o):\n", " return self.__truediv__(o)\n", " def __pow__(self,o):\n", " res = ng()\n", " if type(o) == ng:\n", " res.syst = self.syst**o.syst\n", " res.stat = self.stat**o.stat\n", " else:\n", " res.syst = self.syst**o\n", " res.stat = self.stat**o\n", " return res\n", " def __ipow__(self,o):\n", " return self.__pow__(o)\n", "def sin(o):\n", " if type(o) == ng:\n", " res = ng()\n", " res.syst = usin(o.syst)\n", " res.stat = usin(o.stat)\n", " return res\n", " else:\n", " return np.sin(o)\n", "def exp(o):\n", " if type(o) == ng:\n", " res = ng()\n", " res.syst = uexp(o.syst)\n", " res.stat = uexp(o.stat)\n", " return res\n", " else:\n", " return np.exp(o)\n", "def sqrt(o):\n", " if type(o) == ng:\n", " res = ng()\n", " res.syst = usqrt(o.syst)\n", " res.stat = usqrt(o.stat)\n", " return res\n", " else:\n", " return np.sqrt(o)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wenn Sie die Kugel in den Draht der Aufhängung \"hineinfallen\" lassen, gehen Sie das Risiko ein den Draht zu zerstören.# Durchführung\n", "\n", "## Aufgabe 1: Fadenpendel\n", "\n", "**Hinweise zu allen hier durchzuführenden Messungen finden Sie in der Datei [Hinweise-Aufgabe-1.md](https://gitlab.kit.edu/kit/etp-lehre/p1-praktikum/students/-/blob/main/Pendel/doc/Hinweise-Aufgabe-1.md).**\n", "\n", "Nehmen Sie mit dem Fadenpendel die folgenden Untersuchungen vor:\n", "\n", " * Untersuchen Sie die Periode $T_{0}$ als Funktion der Anfangsauslenkung $\\varphi_{0}$ der Kugel bei *großer* Auslenkung aus der Ruhelage. (Sie können die Kugel bis zu $60^{\\circ}$ auslenken.) \n", " * Bestimmen Sie die Fallbeschleunigung $g$. Achten Sie in diesem Fall darauf, die Kugel *nicht zu weit* auszulenken. Welchen Effekt erwarten Sie für Ihre Wahl von $\\varphi_{0}$, Ihrer ersten Untersuchung zufolge, durch die Annahme der Kleinwinkelnäherung?\n", "\n", "---\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "###Grundlegende Messungen der Pendelmaße\n", "L = 2.355 \n", "ΔL_syst = 0.003 \n", "\n", "m = 0.860 \n", "Δm_syst = 0.5 * 10**(-3)\n", "\n", "r = 1/2*61.75E-3\n", "Δr_syst =2E-3 #stat\n", "Δr_stat = 1E-3 \n", "s = L +r/2#Gewicht des Fadens wird vernachlässigt\n", "Δs_syst = np.sqrt(ΔL_syst**2+Δr_syst**2)\n", "Δs_stat = Δr_stat\n", "\n", "ΔSchranke = 0.002\n", "\n", "### Erste Messungen kleiner Auslenkungen\n", "%m
Bestimmung von g unter gültiger Kleinwinkelnäherung
\n", "%m Zunächst wurde das Pendel nur 5° ausegelenkt, um innerhalb der Kleinwinkelnäherung zu bleiben und es wurden die Dauern verschiedene Anzahlen an Perioden mit einer Lichtschranke gemessen. Der aus diesen Werten gebildeten Wert wurde aus folgendem Fit bestimmt, während die Unsicherheit als Unsicherheit einer Stichprobe und als rel. Unsicherheit auf den erhaltenen Wert bestimmt wurde.\n", "\n", "T_mess = [3.051,9.204,15.356,21.509,27.665,33.833,39.978,46.128,52.266,58.436] #hier Periodendauern eintragen\n", "i = np.arange(0,len(T_mess))\n", "i = [(1+k*2) for k in i]\n", "def lin_model(i,T=3):\n", " return i*T\n", "\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_mess)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = 't in s'\n", "p.plot()\n", "p.show()\n", "\n", "T_perP = []\n", "for i in range(0,len(T_mess)):\n", " T_perP +=[T_mess[i]/(1+i*2)]\n", "T = lin_fit.parameter_values[0]\n", "ΔT_stat = np.var([T_perP],ddof=1)\n", "ΔT_syst = ΔSchranke*T\n", "\n", "%m Er ergab sich eine Periodendauer $T = ([!T:.2!]\\pm_{stat}[!ΔT_stat*1E5:.2f!]\\cdot 10^{-5}\\pm_{syst}[!ΔT_syst:.2!])s$.\n", "%m Betrachtet wurden dabei als statistischer Fehler der statistische Fehler in Form der aus den Messungen errechneten Varianz und als systematischer Fehler der relative Messfehler der Lichtschranke von [!ΔSchranke*100.:.2!]% auf den Mittelwert.\n", "\n", "###Bestimmung von g aus den Periodendauern\n", "%m Mit dieser Periodendauer wurde in der Kleinwinkelnäherung ein Wert für die Erdbeschleunigung g berechnet, wobei die Fehler mit Gausscher Fehlerfortpflanzung bestimmt wurden. Hinzu kamen dabei der statistische Fehler in Form der Varianz auf mehrere Messungen des Radius der Kugel und damit auch die Schwerpunktsdistanz. Systematische Fehler wurden bei der Messung der Länge $\\Delta L_{syst} = [!ΔL_syst:.2!]\\,m$ und der Masse $\\Delta m_{syst} = [!Δm_syst:.2!]\\,kg$ in Form einer Angabe, auf den Radius der Kugel durch Annahme von $\\Delta r_{syst} = [!Δr_syst:.2!]\\,m$ Genauigkeit des Messinstruments berücksichtigt.\n", "g = 4*np.pi**2/T**2 *(s+2/5*r**2/s)\n", "#Δg = sqrt((dg/dT)**2*ΔT**2+(dg/ds)**2*Δs**2+(dg/dr)**2*Δr**2) = 2*np.pi*np.sqrt((T**(-2)*(s+2/5*r**2/s))**2*ΔT**2+(T**(-1)*(1-2/5*r**2*s**(-2)))**2*Δs**2+(T**(-1)*(2/5*2*r/s))**2*Δr**2)\n", "Δg_syst = 2*np.pi*np.sqrt((T**(-2)*(s+2/5*r**2/s))**2*ΔT_syst**2+(T**(-1)*(1-2/5*r**2*s**(-2)))**2*Δs_syst**2+(T**(-1)*(2/5*2*r/s))**2*Δr_syst**2)\n", "Δg_stat = 2*np.pi*np.sqrt((T**(-2)*(s+2/5*r**2/s))**2*ΔT_stat**2+(T**(-1)*(1-2/5*r**2*s**(-2)))**2*Δs_stat**2+(T**(-1)*(2/5*2*r/s))**2*Δr_syst**2)\n", "%m Dabei ergab sich eine Erdbeschleunigung $g= ([!g:.2!]\\pm_{stat}[!Δg_stat:.2!]\\pm_{syst}[!Δg_syst:.2!])\\frac{m}{s^2}$. Dieser Wert ist mit dem Literaturwert von $9,809599\\frac{m}{s^2}$ (in Mannheim nach https://www.ptb.de/cms/fileadmin/internet/fachabteilungen/abteilung_1/1.1_masse/1.15/tabelle.pdf) im Rahmen der angenommenen Unsicherheiten nicht kompatibel. Dies liegt vermutlich vor allem an zu klein geschätzten systematischen Fehlern. Diese könnten entweder in veralteten Angaben oder an zu kleinen Ungenauigkeiten der Messinstrumente liegen.\n", "\n", "%m
Überprüfung der Gültigkeit der Kleinwinkelnäherung
\n", "%m Daraufhin wurde die Kleinwinkelnäherung für größere Winkel überprüft, indem das Pendel bis zu 60° Grad ausgelenkt und die Dauer von 5 Perioden mit selbiger Lichtschranke gemessen wurde. Die daraus berechneten Werte für g weichen gut erkennbar mit steigendem Winkel immer mehr vom in der Kleinwinkelnäherung bestimmten Wert ab. Gründe dafür sind zum einen, dass der Sinus für steigende Winkel immer weniger linear ist, aber auch andere Faktoren beeinträchtigen die Genauigkeit der Messungen bei höheren Winkel. Dazu zählen unter anderem, dass keine perfekte Spannung des Fadens mehr garantiert werden kann und die zunehmende Geschwindigkeit, die zu größeren Reibungseffekten führt.\n", "\n", "###Messung Periodendauern großer Winkel\n", "ϕ_0 = [60,55,50,45,40,35,30,25,20,15,10,5] #in Grad\n", "ϕ_0 = [i *np.pi/180 for i in ϕ_0] #Umrechnung in Rad\n", "Δϕ_0_syst = 2 * np.pi/180 \n", "T_0_mess = [16.457,16.274,16.071,15.945,15.829,15.725,15.619,15.531,15.475,15.421,15.379,15.356]\n", "T_0_mess = [1/5*i for i in T_0_mess] #um Periodendauer einer Periode zu erhalten\n", "#Anlegen eines kleinen Fits ohne Hinzufügen von Fehlern, um die statistische Varianz zu erhalten\n", "def sinsquare_model(ϕ_0,T=3):\n", " return T*(1+1/4*np.sin(1/2*ϕ_0)*np.sin(1/2*ϕ_0))\n", "\n", "xy_data = kafe2.XYContainer(x_data=ϕ_0, y_data=T_0_mess)\n", "sinsquare_fit = kafe2.Fit(data=xy_data, model_function=sinsquare_model)\n", "\n", "sinsquare_fit.do_fit()\n", "ΔT_0_stat = np.sqrt(np.var(T_0_mess))\n", "#print(ΔT_0_stat)\n", "ΔT_0_stat = np.sqrt(sinsquare_fit.parameter_cov_mat[0][0])\n", "#print(ΔT_0_stat)\n", "ΔT_0_syst = 0.002 #rel Fehler, wird mit jeweiligem Wert mult\n", "\n", "\n", "\n", "\n", "#Berechnen von g aus den Werten großer Winkel in Kleinwinkelnäherung\n", "g_big = [4*np.pi**2/i**2 *(s+2/5*r**2/s) for i in T_0_mess]\n", "Δg_big_syst = [2*np.pi*np.sqrt((T**(-2)*(s+2/5*r**2/s))**2*(T*ΔT_0_syst)**2+(T**(-1)*(1-2/5*r**2*s**(-2)))**2*Δs_syst**2+(T**(-1)*(2/5*2*r/s))**2*Δr_syst**2) for T in T_0_mess]\n", "Δg_big_stat = [2*np.pi*np.sqrt((T**(-2)*(s+2/5*r**2/s))**2*ΔT_stat**2+(T**(-1)*(1-2/5*r**2*s**(-2)))**2*Δs_stat**2+(T**(-1)*(2/5*2*r/s))**2*Δr_syst**2) for T in T_0_mess]\n", "Δg_big_full =[]\n", "for i in range (0,len(g_big)):\n", " Δg_big_full += [np.sqrt(Δg_big_syst[i]**2+Δg_big_stat[i]**2)]\n", "#Plotten der bestimmet Erdbeschleunigung aus kleinen Winkeln im Vergleich mit den neuen Werten\n", "plt.scatter(ϕ_0,g_big,label=\"g für große ϕ mit Kleinwinkelnäherung\")#Fehler\n", "plt.errorbar(ϕ_0,g_big,yerr=Δg_big_full,xerr=[Δϕ_0_syst for i in ϕ_0],ls=\"none\")\n", "x = np.linspace(np.min(ϕ_0),np.max(ϕ_0),100)\n", "y = np.ones(100)*g\n", "plt.plot(x,y,'r',label=\"Bestimmtes g\")\n", "plt.title(\"Vergleich bestimmtes g mit g aus Vernachlässigung großer Winkel\")\n", "plt.xlabel(\"ϕ_0 in Rad\")\n", "plt.ylabel(r'Beschleunigung in $\\frac{m}{s^2}$')\n", "plt.legend()\n", "plt.show()\n", "%m Auch hier zeigt sich ein recht klein angenommener Fehler von g, der dazu führt, dass die Werte nicht kompatibel mit den vorherigen sind.\n", "\n", "\n", "%m Dies zeigt, dass für größere Auslenkungen eine andere Näherung benutzt werden muss, um mit den anderen Messungen kompatibel zu bleiben, in diesem Fall die Mittelwinkelnäherung.\n", "#Fitten und Plotten der Mittelwinkelnäherung\n", "%m
Anwenden der Mittelwinkelnäherung
\n", "def sinsquare_model(ϕ_0,T=3):\n", " return T*(1+1/4*np.sin(1/2*ϕ_0)*np.sin(1/2*ϕ_0))\n", "\n", "xy_data = kafe2.XYContainer(x_data=ϕ_0, y_data=T_0_mess)\n", "xy_data.add_error(axis='x', err_val=Δϕ_0_syst)\n", "xy_data.add_error(axis='y', err_val=ΔT_0_syst,relative=True)\n", "sinsquare_fit = kafe2.Fit(data=xy_data, model_function=sinsquare_model)\n", "\n", "sinsquare_fit.do_fit()\n", "#sinsquare_fit.report(asymmetric_parameter_errors=True)\n", "p = kafe2.Plot(sinsquare_fit)\n", "p.x_label = 'ϕ_0 in Rad'\n", "p.y_label = 'T_0 in s'\n", "p.plot(asymmetric_parameter_errors=True)\n", "p.show()\n", "%m Auch in dieser zeigt sich allerdings bei großen Winkeln eine größere Abweichung, sodass man zur Verwendung dieser Messpunkte in einer kompatiblen Messung einen weiteren Term der Näherung nutzen müsste. Trotzdem zeigt sich, dass der in der Näherung bestimmte Wert von g im Rahmen der Genauigkeit mit der für bei kleinen Auslenkungen bestimmten Periodendauer kompatibel ist." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Aufgabe 2: Reversionspendel\n", "\n", "**Hinweise zu allen hier durchzuführenden Messungen finden Sie in der Datei [Hinweise-Aufgabe-2.md](https://gitlab.kit.edu/kit/etp-lehre/p1-praktikum/students/-/tree/main/Pendel/doc/Hinweise-Aufgabe-2.md).**\n", "\n", "### Aufgabe 2.1: Funktionsweise\n", "\n", "Beschreiben Sie die Eigenschaften und Funktionsweise des [Reversionspendles](https://de.wikipedia.org/wiki/Reversionspendel) zur Bestimmung von $g$ in eigenen Worten. \n", "\n", "---\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Das Reversionspendel ist ein langer Stab mit zwei Halterungen, auf denen der Stab kippbar in einer starren Halterung gelagert werden kann. Eine der Halterungen ist auf dem Stab verschiebbar. Wenn sich die Halterungen im korrekten Abstand zueinander befinden ist die Periodendauer der Schwingungen auf den jeweiligen Halterungen gleich. Die richtige Position kann leicht durch Vergleich der Periodendauern gefunden werden. \n", "\n", "$g$ kann dann einfach aus dem Abstand und der Periodendauer bestimmt werden ohne, dass das Trägheitsmoment bestimmt werden muss. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "L = 0.962\n", "ΔL = 0.00002\n", "ρ = 4940\n", "Δρ = 0\n", "D = 0.0015\n", "ΔD = 0.00002\n", "\n", "m_K = 0.083\n", "Δm_K = 1E-3\n", "m_K = 0.083\n", "Δm_K = 1E-3\n", "\n", "%m Ohne die verschiebbare Masse ergibt sich für das Pendel ein Trägheismoment von $\\Theta = \\frac{m l^2}{3} = \\frac{\\pi L ρ d^2 l^2}{3} = [!pi*L*ρ*D**2*L**2/3:.4f!]\\,\\mathrm{Kg\\,m^2}$\n", "\n", "%m Der Schwerpunkt $s$ liegt bei $s = \\frac{L}{2} = [!L/2:.4f!]\\,\\mathrm{m}$\n", "\n", "%m Die reduzierte Länge $l_r$ liegt bei $s = \\frac{2 L}{3} = [!2*L/3:.4f!]\\,\\mathrm{m}$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Halterungen um $K$ und $K'$ zu fixieren befinden sich am Aufhängungspunkt und bei der reduzierten Länge. Dementsprechend ist der Einfluss der Halterung bei $K$ minimal, da sie nah am Rotationszentrum sitzt und so kaum zum Trägheitsmoment beiträgt. Der Einfluss der Halterung bei $K'$ auf die Periodendauer ist auch vernachlässigbar, da es sich bei der reduzierten Länge befindet und nur eine sehr kleine Ausdehnung und damit vernachlässigbares eigenes Trägheitsmoment im Vergleich zum Trägheitsmoment des Pendels hat. Auch der Durchmesser des Stabes ist klein im Vergleich zur Länge des Pendels weswegen die Annäherung als dünner Stab gut ist." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Aufgabe 2.2: Bestimmung von $g$\n", "\n", "Suchen Sie, indem Sie den beweglichen Keil $K'$ des Reversionspendels geeignet verschieben, den Abstand $d$, der $\\ell_{r}$ entspricht. Bestimmen Sie für diese Konfiguration des Pendels die folgenden Größen mit entsprechenden Unsicherheiten: \n", "\n", " * Den Wert von $\\ell_{r}$ und $\\Delta\\ell_{r}$;\n", " * Die Periode $T_{0}$ und $\\Delta T_{0}$;\n", " * Die Erbeschleunigung $g$ und $\\Delta g$.\n", " \n", " ---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Kalibrierung der Lichtschranke" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%m Im folgenden werden Korrekturdaten und statistische Unsicherheiten für die Lichtschranke bestimmt. Es wird jeweils die Zeit bestimmt, die das Pendel für 1, 2, 3, 4 und 5 Perioden braucht wobei jedes mal eine neue Messung begonnen wird. Die Messwerte sind in folgender Tabelle zu sehen.\n", "\n", "mpg = pd.read_csv('Periodendauern_calibrierug.csv')\n", "mpg.rename(columns={'#': 'Anzahl Perioden','T_0': 'Periodendauer T_0 in s'}, inplace=True)\n", "display(mpg)\n", "\n", "%m Die Daten sollten einem linearen zusammenhang folgen, weswegen ein linearer Fit durchgeführt wird.\n", "\n", "nums, T_0s = np.genfromtxt('Periodendauern_calibrierug.csv', delimiter=',')[1:].transpose()\n", "\n", "def line_model(x, s, offset):\n", " return x*s+offset\n", "\n", "(slope, offset), convM = scipy.optimize.curve_fit(line_model, nums, T_0s)\n", "_, Δoffset = np.sqrt(np.diag(convM))\n", "uoffset_stat = ufloat(offset, Δoffset)\n", "uoffset_sys = ufloat(offset, abs(offset*2E-3))\n", "\n", "plt.plot(nums, T_0s, \".\")\n", "lin = np.linspace(1.5,5.5,2)\n", "plt.plot(lin, lin*slope+uoffset_sys.n)\n", "plt.show()\n", "\n", "ΔT_0 = np.std(T_0s - (nums*slope+uoffset_sys.n))\n", "\n", "%m Es ergibt sich aus dem linearen Fit ein statistischer Fehler auf den y-Achsenabschnitt von $[!uoffset_stat.s:.4f!]\\,\\mathrm{s}$. Weiter gibt es einen Systematischen Fehler von 0.2%. Der y-Achsenabschnitt ist also $T_0 = [!uoffset_stat.n:.3f!]\\,\\mathrm{s} \\pm_{stat} [!uoffset_stat.s*1E3:.3f!]\\,\\mathrm{ms} \\pm_{sys} [!uoffset_sys.s*1E3:.3f!]\\,\\mathrm{ms}$ und wird im folgenden (Gemeint ist hier der Rest der Aufgabe 2.2) zur Korrektur immer von den Messerten abgezogen.\n", "\n", "%m Aus der Standardabweichung der einzelnen Abständen von den Messwerten zur Fitgeraden kann eine Unsicherheit statistische für die Zeitmessung angegeben werden die $ΔT_0 = [!ΔT_0*1E3:.4f!]\\,\\mathrm{ms}$ beträgt." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Messung" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%m In der Folgenden Tabelle sind unsere Messdaten zu finden. Es wurde jeweils der Abstand zwischen den Schneiden der Klemmen, die Periodendauer für die normale Schwingung und die Periodendauer für die inverse Schwingung an der verschiebbaren Schneide gemessen. Es wurden jeweils 5 Perioden gemessen, also 10 Durchschwünge der Lichtschranke und die Gesamtzeit in die Tabelle eingetragen.\n", "\n", "mpg = pd.read_csv('Periodendauern_revisionspendel.csv')\n", "mpg.rename(columns={'d': 'l in m','T_0': 'T_0 in s', 'T_0reduziert': 'T_0\\' in s'}, inplace=True)\n", "\n", "display(mpg)\n", "\n", "d, T_0, T_0reduziert = np.genfromtxt('Periodendauern_revisionspendel.csv', delimiter=',')[1:].transpose()\n", "T_0 /= 5\n", "T_0reduziert /= 5\n", "\n", "Δd_sys = 0.001\n", "Δd_stat = 0.001\n", "\n", "%m Für die Längenmessung wird eine systematische Unsicherheit von 1mm für die Skala des Linals angesetzt und eine statistische Unsicherheit von 1mm beim Ablesen des Wertes. Für die Zeitmessung wird die in der vorherigen Aufgabe bestimmte Messunsicherheit verwendet. \n", "\n", "%m Für die Zeitwerte wir die zuvor bestimmte statistische Unsicherheit verwendet. Die Systematische Unsicherheit ist wie vorher 0.2%.\n", "\n", "ud_sys = unumpy.uarray(d, Δd_sys)\n", "ud_stat = unumpy.uarray(d, Δd_stat)\n", "\n", "uT_0_sys = unumpy.uarray(T_0, T_0*2E-3) - uoffset_sys / 5\n", "uT_0_stat = unumpy.uarray(T_0, ΔT_0) - uoffset_stat / 5\n", "uT_0reduziert_sys = unumpy.uarray(T_0reduziert, T_0reduziert*2E-3/5) - uoffset_sys/5\n", "uT_0reduziert_stat = unumpy.uarray(T_0reduziert, ΔT_0/5) - uoffset_stat/5\n", "\n", "plt.scatter(d,nomv(uT_0_stat), label=\"$K$\", color=\"blue\", )\n", "#plt.errorbar(d,nomv(uT_0), color=\"blue\", yerr=stdv(uT_0), capsize=3)\n", "plt.scatter(d,nomv(uT_0reduziert_stat), label=\"$K'$\", color=\"green\")\n", "#plt.errorbar(d,nomv(uT_0reduziert), color=\"green\", yerr=stdv(uT_0reduziert), capsize=3)\n", "plt.plot(np.linspace(np.min(d), np.max(d)), np.linspace(np.min(d), np.max(d)) * np.polyfit(d, nomv(uT_0_stat), 1)[0] + np.polyfit(d, nomv(uT_0_stat), 1)[1], color=\"blue\", linestyle=\"dotted\")\n", "plt.plot(np.linspace(np.min(d), np.max(d)), np.linspace(np.min(d), np.max(d)) * np.polyfit(d, nomv(uT_0reduziert_stat), 1)[0] + np.polyfit(d, nomv(uT_0reduziert_stat), 1)[1], color=\"green\", linestyle=\"dotted\")\n", "plt.legend()\n", "\n", "plt.ylabel(\"$T_0$ in s\")\n", "plt.xlabel(\"$d$ in m\")\n", "plt.show()\n", "\n", "%m Wie zu sehen ist, eignet sich ein Linearer Fit nicht mehr, da die Kurve von K' sichtbar gekrümmt ist. Deswegen wird im folgenden auf die Differenz der beiden Werte eine Parabel gefittet.\n", "\n", "uDeltaT_0_stat = uT_0_stat - uT_0reduziert_stat\n", "uDeltaT_0_sys = uT_0_sys - uT_0reduziert_sys\n", "\n", "def parabola_model(d, α=-7E-4, β=0.64, γ=0.80):\n", " return α*(β-d)*(γ-d)\n", "\n", "%m Fit für statistische Unsicherheiten:\n", "#Statistischer Unsicherheiten\n", "xy_data = kafe2.XYContainer(x_data=d, y_data=nomv(uDeltaT_0_stat))\n", "xy_data.add_error(axis='x', err_val=Δd_stat)\n", "xy_data.add_error(axis='y', err_val=stdv(uDeltaT_0_stat))\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=parabola_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'd in m'\n", "p.y_label = '$\\Delta T_0 in m$'\n", "p.plot()\n", "p.show()\n", "\n", "_, l_r, _ = lin_fit.parameter_values\n", "_, Δl_r, _ = lin_fit.parameter_errors\n", "ul_r_stat = ufloat(l_r, Δl_r)\n", "\n", "%m Fit für systematische Unsicherheiten:\n", "#Systematischer Unsicherheiten\n", "xy_data = kafe2.XYContainer(x_data=d, y_data=nomv(uDeltaT_0_sys))\n", "xy_data.add_error(axis='x', err_val=Δd_sys)\n", "xy_data.add_error(axis='y', err_val=stdv(uDeltaT_0_sys))\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=parabola_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'd in m'\n", "p.y_label = '$\\Delta T_0 in m$'\n", "p.plot()\n", "p.show()\n", "\n", "_, l_r, _ = lin_fit.parameter_values\n", "_, Δl_r, _ = lin_fit.parameter_errors\n", "ul_r_sys = ufloat(l_r, Δl_r)\n", "\n", "%m Es wurde zur bestimmtung von der reduzierten Länge $l_r$ mit Kafe2 jeweils ein Fit für statistische und systematische Unsicherheiten gemacht. Dabei wurde das Modell $\\alpha(\\beta - l)(\\gamma - l)$ gefittet, also eine Linearfaktorzerlegung der Parabel mit Startparametern so gewählt, dass der Parameter $\\beta$ die Nullstelle der Kurve enthält. Kafe2 liefert dazu gleich die Propagierten fehler für statistsche bzw. systematische Fehler.\n", "\n", "%m Damit ergibt sich $l_r = [!ul_r_sys.n:.3f!]\\,\\mathrm{m} \\pm_{stat} [!ul_r_stat.s*1E3:.3f!]\\,\\mathrm{mm} \\pm_{sys} [!ul_r_sys.s*1E3:.3f!]\\,\\mathrm{mm}$ Die Eingangsfehler sind 1mm für statistsichen und systematischen Fehler wie oben schon erwähnt. Daraus wurden mit der Likelyhoodmethode die propagierten Fehler im Fit bestimmt. (Man kann sie auch auf den beiden oberen Plots finden.)\n", "\n", "%m Um jetzt noch den dazugehörigen Wert von T_0 mit Unsicherheit zu finden muss ein linearer Fit in die ursprünglichen Messreihen von K gemacht werden und damit dann den T_0 - Wert zu bestimmen (Da nur K' eine sichtbare Krümmung auffweist und nicht K, reicht hier ein linearer Fit.)\n", "\n", "%m Um eine Korrelation der Steigung und des y-Achsenabschnitts zu vermeiden werden die Daten vor dem Fit um ihren Mittelwert verschoben, sodass beide Parameter unkorreliert sind.\n", "\n", "# Statistischer Unsicherheiten\n", "ud_stat_shifted = ud_stat - np.average(nomv(ud_stat))\n", "uT_0_stat_shifted = uT_0_stat - np.average(nomv(uT_0_stat))\n", "\n", "%m Fit für statistische Unsicherheiten\n", "%m Hier gehen die vorher festgelegten Unsicherheiten auf den Längenwerten und auf der Periodendauer ein. \n", "def lin_model(x, m, offset2):\n", " return x*m+offset2\n", "\n", "xy_data = kafe2.XYContainer(x_data=nomv(ud_stat_shifted), y_data=nomv(uT_0_stat_shifted))\n", "xy_data.add_error(axis='x', err_val=Δd_stat)\n", "xy_data.add_error(axis='y', err_val=stdv(uT_0_stat))\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'l in m'\n", "p.y_label = 'T_0 in s'\n", "p.plot()\n", "p.show()\n", "\n", "m, offset2 = lin_fit.parameter_values\n", "Δm, Δoffset2 = lin_fit.parameter_errors\n", "\n", "uT_0fin_stat = (ul_r_stat- np.average(nomv(ud_stat)))*ufloat(m,Δm) + ufloat(offset2, Δoffset2) + np.average(nomv(uT_0_stat))\n", "\n", "# Systematische Unsicherheiten\n", "ud_sys_shifted = ud_stat - np.average(nomv(ud_stat))\n", "uT_0_sys_shifted = uT_0_stat - np.average(nomv(uT_0_stat))\n", "\n", "%m Fit für systematische Unsicherheiten\n", "%m Hier gehen die vorher festgelegten Unsicherheiten auf den Längenwerten und auf der Periodendauer ein. \n", "def lin_model(x, m, offset2):\n", " return x*m+offset2\n", "\n", "xy_data = kafe2.XYContainer(x_data=nomv(ud_sys_shifted), y_data=nomv(uT_0_sys_shifted))\n", "xy_data.add_error(axis='x', err_val=Δd_sys)\n", "xy_data.add_error(axis='y', err_val=stdv(uT_0_sys))\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'l in m'\n", "p.y_label = 'T_0 in s'\n", "p.plot()\n", "p.show()\n", "\n", "m, offset2 = lin_fit.parameter_values\n", "Δm, Δoffset2 = lin_fit.parameter_errors\n", "\n", "uT_0fin_sys = (ul_r_sys- np.average(nomv(ud_sys)))*ufloat(m,Δm) + ufloat(offset2, Δoffset2) + np.average(nomv(uT_0_sys))\n", "\n", "%m Damit ergibt sich $T_0 = [!uT_0fin_sys.n:.3f!]\\,\\mathrm{s} \\pm_{stat} [!uT_0fin_stat.s*1E3:.3f!]\\,\\mathrm{ms} \\pm_{sys} [!uT_0fin_sys.s*1E3:.3f!]\\,\\mathrm{ms}$ direkt aus dem Kafe2 fit mit der Likelyhood-Methode wie im Plot abzulesen ist.\n", "\n", "ug_sys = 4*pi**2*ul_r_sys/uT_0fin_sys**2\n", "ug_stat = 4*pi**2*ul_r_stat/uT_0fin_stat**2\n", "\n", "%m Damit ergibt sich $g = [!ug_stat.n:.3f!]\\,\\mathrm{\\frac{m}{s^2}} \\pm_{stat} [!ug_stat.s*1E3:.3f!]\\,\\mathrm{\\frac{mm}{s^2}} \\pm_{sys} [!ug_sys.s*1E3:.3f!]\\,\\mathrm{\\frac{mm}{s^2}}$ nach gausscher Messunsicherheitsfortpflanzung aus $T_0$ und $l_r$ mit den oben bestimmten Unsicherheiten.\n", "\n", "%m Dieser Wert stimmt nicht innerhalb der Messunsicherheit mit dem Literaturwert überein. Das liegt daran, dass die Messung von l zwischen den beiden Schneiden vorgenommen wurde und die Schneiden natürlich nicht mit dem Schweerpunkt der Klemmen fluchten. Wenn man die halbe dicke der Klemmen auf die Abstandsmesswerte addiert kommt man auf Werte wesentlich näher am Literaturwert. Also ist die Ausdehnung der Klemmen hier nicht mehr vernachlässigbar und müsste genauer berücksichtigt werden." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Aufgabe 3: Gekoppelte Pendel\n", "\n", "**Hinweise zu allen hier durchzuführenden Messungen finden Sie in der Datei [Hinweise-Aufgabe-3.md](https://gitlab.kit.edu/kit/etp-lehre/p1-praktikum/students/-/tree/main/Pendel/doc/Hinweise-Aufgabe-3.md).**\n", "\n", "### Aufgabe 3.1: Justierung der einzelnen Pendel \n", "\n", "Stellen Sie bei den zwei baugleichen Pendeln durch Verschieben einer der Pendelscheiben gleiche Schwingungsdauern $T_{0}$ ein. \n", "\n", "---\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "L = ufloat(106.75E-2,2.5E-2) #Gesamtlänge Stab\n", "#Das schwerere, linke Pendel sei im folgenden Pendel L und das rechte, leichtere, Pendel R.\n", "L_L = ufloat(81.5E-2,2E-3)#zu messender Abstand der Pendelscheibe von der Aufhängung\n", "L_R = ufloat(81.2E-2,2E-3)#zu messender Abstand der Pendelscheibe von der Aufhängung\n", "T_0L = [1.61,3.40/2,5.16/3,6.94/4,8.75/5,10.45/6,12.37/7,14.14/8,15.82/9,17.6/10]#1.779\n", "T_0L = [1.61,3.40,5.16,6.94,8.75,10.45,12.37,14.14,15.82,17.6]#1.779\n", "T_0R = [1.65,2.31/2,4.94/3,6.92/4,8.72/5,10.38/6,12.17/7,13.92/8,15.71/9,17.57/10]#1.775\n", "T_0R = [1.65,2.31,4.94,6.92,8.72,10.38,12.17,13.92,15.71,17.57]#1.775\n", "T_0 = ufloat(1/2*(np.mean(T_0R)+np.mean(T_0L)),1.5)#zu messende, gleiche Schwingdauer\n", "#Wir nehmen das Trägheitsmoment des linken Pendels\n", "d = ufloat(17E-3,2E-3)\n", "b = ufloat(7E-3,2E-3)\n", "A = d*b#zu messender Querschnitt der Aufängung\n", "ρ = 7.44E3 #7,44g/cm^3\n", "m_k = ufloat(1.4,0.005)\n", "m_s = ufloat(1.4,0.005)\n", "r = ufloat(50E-3,2E-3) #Radius der Scheiben\n", "m = m_k + m_s #alles dazu\n", "\n", "%m Es wurde die Schwingdauer beider Pendel alleine, ohne Kopplung, über mehrere Perioden bestimmt.\n", "#Einfügen Fits Einzelschwing. bzw Werte\n", "i = np.arange(1,len(T_0L)+1)\n", "def lin_model(i,T=3,b=.3):\n", " return i*T+b\n", "\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_0L)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "lin_fit.limit_parameter(\"b\", lower=-0.3, upper=1.)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = 't in s'\n", "p.plot(asymmetric_parameter_errors= True)\n", "p.show()\n", "T_0L = lin_fit.parameter_values[0]\n", "\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_0R)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = 't in s'\n", "p.plot()\n", "p.show()\n", "T_0R = lin_fit.parameter_values[0]\n", "T_0 = 1/2*(T_0L + T_0R)\n", "%m Es ergaben sich aus den Fits Schwingdauern von $T_{0L} = [!T_0L:.4!]\\,s$ und $T_{0R} = [!T_0R:.4!]\\,s$.\n", "%m Die Werte liegen im Rahmen der Messunsicherheiten sehr nah beeinander, sodass im weiteren Verlauf ihr Mittelwert $T=[!T_0:.4!]\\,s$ als ungekoppelte Schwingdauer beider Pendel behandelt wird." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Aufgabe 3.2: Gekoppelte Pendel \n", "\n", "Koppeln Sie die Pendel mittels einer Schraubenfeder (mit der Federkonstanten $D$) in jeweils gleichem Abstand $\\ell$ von den Aufhängepunkten der Pendel. Hierbei, wie im Folgenden, sollte die koppelnde Feder die Pendel nur mit schwacher Spannung verbinden. Führen Sie dann das folgende Messprogramm durch: \n", "\n", "- Bestimmen Sie die Perioden $T_{1}$ und $T_{2}$ der beiden [Funda­men­talschwin­gungen](https://de.wikipedia.org/wiki/Gekoppelte_Pendel), bei denen keine Schwebung auftritt. \n", "- Wiederholen Sie die Messungen bei verändertem Abstand $\\ell'$. \n", "- Diskutieren Sie Ihre Ergebnisse für $T_{0},$ $T_{1}(\\ell)$, $T_{2}(\\ell)$, $T_{1}(\\ell')$ und $T_{2}(\\ell')$. \n", "- Bestimmen Sie für $\\ell$ und $\\ell'$ aus $T_{1/2}$ die Werte von $\\omega_{1/2}$. \n", "- Berechnen Sie auf der Grundlage des Modells eines [physikalischen Pendels](https://de.wikipedia.org/wiki/Physikalisches_Pendel) aus $\\omega_{1}$ das Trägheitsmoment $\\Theta$ und vergleichen Sie das Ergebnis mit Ihrer Erwartung aus den geometrischen Abmessungen und Massen der Pendel.\n", "- Berechnen Sie aus $\\omega_{2}$ das Direktionsmoment $D$ der koppelnden Feder. Führen Sie zwei alternative Bestimmung von $D$ durch und vergleichen Sie Ihre Ergebnisse: \n", " - Mit Hilfe des Hook'schen Gesetzes; \n", " - Unter Verwendung der koppelnden Feder als [Federpendel](https://de.wikipedia.org/wiki/Federpendel). \n", "\n", "---\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%m
Messung der Periodendauern der Eigenschwingungen
\n", "#Messung der beiden Periodenlängen durch Mitteln über mehrere \n", "l_0 = 41.5E-2\n", "Δl_0= 5E-3\n", "%m Die beiden Pendel wurden nun in einem Abstand $l = [!l_0:.3!]\\,m$ mit einer Feder gekoppelt und es wurden die Schwingdauer $T_{10}$ der gleichphasigen Eigenschwingung ohne Einfluss der Feder und $T_{20}$ der gegenphasigen Schwingung gemessen.\n", "#Messung der Schwingung,bei der beide Pendel in Phase schwingen\n", "T_10 = [ufloat(5.22/3,1),ufloat(8.77/5,1),ufloat(12.21/7,1),ufloat(15.96/9,1)]\n", "T_10 = [5.22,8.77,12.21,15.96]\n", "i = np.arange(3,9+1,2)\n", "def lin_model(i,T=3,b=.3):\n", " return i*T+b\n", "\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_10)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = r'$T_{10}$ in s'\n", "p.plot()\n", "p.show()\n", "T_10 = lin_fit.parameter_values[0]\n", "\n", "#Messung der Schwingung, bei der beide Pendel gegenphasig schwingen\n", "T_20 = [ufloat(4.33/3,1),ufloat(6.87/5,1),ufloat(9.86/7,1),ufloat(12.78/9,1)]\n", "T_20 = [4.33,6.87,9.86,12.78]\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_20)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = r'$T_{20}$ in s'\n", "p.plot()\n", "p.show()\n", "T_20 = lin_fit.parameter_values[0]\n", "\n", "%m Dabei ergaben sich Werte von $T_{10} = [!T_10:.3!]\\,s$ und $T_{20} = [!T_20:.3!]\\,s$. Man erwartet wegen der bei der gegenphasigen Schwingung hinzukommenden Kopplung $\\omega_1^2 < \\omega_2^2$, dann aber wegen $\\omega = \\frac{2\\pi}{T}$ folglich $T_{10} > T_{20}$, die gemessenen Werte entsprechen also in ihrem Verhältnis der Erwartung.\n", "\n", "#Wiederholen der vorherigen Messungen mit verändertem l (Abstand der Kopplung)\n", "l_1 = 30E-2\n", "Δl_1 =5E-3\n", "%m Anschließend wurde eine Kopplungshöhe $l_1 = [!l_1:.2!]\\,m$ eingestellt und es wurden die Schwingdauer $T_{11}$ der gleichphasigen Eigenschwingung ohne Einfluss der Feder und $T_{21}$ der gegenphasigen Schwingung gemessen.\n", "\n", "#Messung der Schwingung,bei der beide Pendel in Phase schwingen\n", "T_11 = [ufloat(5.24/3,1),ufloat(8.73/5,1),ufloat(12.52/7,1),ufloat(15.56/9,1)]\n", "T_11 = [5.24,8.73,12.52,15.56]\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_11)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = r'$T_{11}$ in s'\n", "p.plot()\n", "p.show()\n", "T_11 = lin_fit.parameter_values[0]\n", "\n", "\n", "#Messung der Schwingung, bei der beide Pendel gegenphasig schwingen\n", "T_21 = [ufloat(4.57/3,1),ufloat(7.7/5,1),ufloat(10.83/7,1),ufloat(13.72/9,1)]\n", "T_21 = [4.57,7.7,10.83,13.72]\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=T_21)\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = r'$T_{21}$'\n", "p.plot()\n", "p.show()\n", "T_21 = lin_fit.parameter_values[0]\n", "\n", "%m Dabei ergaben sich Werte von $T_{11} = [!T_11:.2!]\\,s$ und $T_{21} = [!T_21:.2!]\\,s$. Man erwartet wegen der bei der gegenphasigen Schwingung hinzukommenden Kopplung $\\omega_1^2 < \\omega_2^2$, dann aber wegen $\\omega = \\frac{2\\pi}{T}$ folglich $T_{11} > T_{21}$, die gemessenen Werte entsprechen also in ihrem Verhältnis der Erwartung.\n", "table = pd.DataFrame({\n", " \"l [m]\": [l_0, l_1],\n", " r\"$T_{1i}$ [s] (gleichphasig)\": [T_10, T_11],\n", " r\"$T_{2i}$ [s] (gegenphasig)\": [T_20, T_21],\n", "})\n", "display(Markdown(table.to_markdown()))\n", "%m Im Rahmen der Messungenauigkeiten sind die Werte sehr kompatibel miteinander, da die Verhältnisse gleich bleiben ($T_1 > T_2$). Die Unterschiede der einzelnen Periodendauern sind im Rahmen der Genauigkeit primär auf Unsicherheiten zurückzuführen, sodass ein Einfluss der Kopplungshöhe nicht zu vermuten ist, da sonst stärkere Unterschiede zu erwarten wären.\n", "\n", "#w_i = 2*pi/T_i\n", "#Δw = 2*pi*np.sqrt(T**(-2)*ΔT**2)\n", "ω_10 = 2*np.pi/T_10\n", "#Δω_10 = 2*np.pi*np.sqrt(T_10**(-2)*ΔT_10**2)\n", "ω_11 = 2*np.pi/T_11\n", "#Δω_11 = 2*np.pi*np.sqrt(T_11**(-2)*ΔT_11**2)\n", "ω_20 = 2*np.pi/T_20\n", "#Δω_20 = 2*np.pi*np.sqrt(T_20**(-2)*ΔT_20**2)\n", "ω_21 = 2*np.pi/T_21\n", "#Δω_21 = 2*np.pi*np.sqrt(T_21**(-2)*ΔT_21**2)\n", "#Mitteln der Werte\n", "ω_1 = 1/2 * (ω_10+ ω_11)\n", "ω_2 = 1/2 * (ω_20+ ω_21)\n", "\n", "%m Aus diesen Werten folgen Werte für ω:\n", "df = pd.DataFrame({\n", " \"l [m]\": [l_0, l_1],\n", " r\"$\\omega_{1i}$ [s] (gleichphasig)\": [ω_10, ω_11],\n", " r\"$\\omega_{2i}$ [s] (gegenphasig)\": [ω_20, ω_21]\n", "})\n", "'''\n", "df = pd.DataFrame({\n", " \"l [m]\": [l_0, l_1],\n", " r\"$\\omega_{1i}$ [s]\": [ω_10, ω_11],\n", " r\"$\\omega_{2i}$ [s]\": [ω_20, ω_21],\n", " r\"$\\omega_{i+1}$ [s]\": [ω_1,ω_2]\n", "})'''\n", "display(Markdown(df.to_markdown()))\n", "%m        Mittelwert: $ω_1 = [!ω_1:.2!]\\,s$ (gleichphasig) und $ω_2 = [!ω_2:.2!]\\,s$ (gegenphasig)\n", "%m Diese Werte sind aus der Diskussion über die entsprechenden Periodendauern folgend plausibel und den Erwartungen entsprechend.\n", "%m
Berechnung von $\\Theta$
\n", "#Berechnung Θ aus w1 durch Modell als physikalisches Pendel\n", "g = 9.809599#Literaturwert einfügen\n", "s = (m_k*l_0 + m_s * L_L + ρ/2*L**2*A)/(m_k + m_s + ρ*L_L*A)\n", "Θ_Modell = m*g*s/ω_1**2 \n", "%m Aus $ω_1$ und den Maßen des Pendels lässt sich $Θ_{Modell}= [!nomv(Θ_Modell):.2f!] \\,kg\\,m^2$ bestimmen.\n", "#Berechnung Θ aus Werten von Pendeln etc.\n", "Θ_Stab = 1/3 * ρ*A*L**3\n", "Θ_s = 1/2 * m_s * r**2 \n", "Θ_Theorie = Θ_Stab + Θ_s + m_s * L_L**2+m_k *l_0**2\n", "%m Es lässt sich aus den Abmessungen und Gewichten das Trägheitsmoment theoretisch zu $Θ_{Theorie}= [!nomv(Θ_Theorie):.2f!] \\,kg\\,m^2$ bestimmen.\n", "%m Diese Werte weichen durchaus voneinander ab, was im Rahmen der Zeitmessung allerdings wenig überraschend ist. In der weiteren Rechnung wird der Mittelwert der beiden Werte verwendet.\n", "%m\n", "%m Im folgenden soll das Direktionsmoment D, welches die Kopplung der beiden Pendel beschreibt, durch verschiedene Methoden bestimmt werden:\n", "%m Zunächst durch Verwendung des Trägheitsmoments und der beiden Eigenfrequenzen. \n", "%m
Berechnung von $D_{\\omega_2}$
\n", "#Berechnung D aus w2\n", "D_ω_2 = np.mean([Θ_Modell,Θ_Theorie])*(ω_2**2-ω_1**2)\n", "%m Es ergibt sich das Direktionsmoment $D_{ω_2} = Θ*(ω_2^2-ω_1^2) = [!nomv(D_ω_2):.2!]\\,\\frac{kg\\,m^2}{s^2}$.\n", "\n", "#Messung von D\n", "%m
Berechnung von $D_{hook}$
\n", "%m Nun soll es durch Anhängen verschiedener Massen und Messen der Auslenkungen unter Annahme des linearen Bereichs des Hookschen Gesetzes bestimmt werden.\n", "l_hook = 62.6E-2 -17.6E-2#Länge Feder messen\n", "Δl_hook = 2E-3\n", "#%m Bestimmung nach dem Hookschen Gesetz nach $\\begin{equation*}\\mathrm{d}F = k\\,\\mathrm{d}z.\\end{equation*}$\n", "m_i = [0.5,0.2,0.1] #angehängte Gewichte\n", "Δm_i = 0.005 #anpassen\n", "dz_i = [75.6E-2,67.8E-2,65.3E-2] #Auslenkung aus Ruhelage\n", "Δdz_i =1E-3 #Ableseganauigkeit\n", "def line_model(m_i,k=1,b=.3):\n", " return m_i*g/k+b\n", "xy_data = kafe2.XYContainer(x_data=m_i, y_data=dz_i)\n", "xy_data.add_error(axis='x', err_val=Δm_i)\n", "xy_data.add_error(axis='y', err_val=Δdz_i)\n", "line_fit = kafe2.Fit(data=xy_data, model_function=line_model)\n", "\n", "line_fit.do_fit()\n", "p = kafe2.Plot(line_fit)\n", "p.x_label = r'$m_i$ in kg'\n", "p.y_label = r'$dz_i$ in m'\n", "p.plot()\n", "p.show()\n", "\n", "k = line_fit.parameter_values[0]\n", "Δk = line_fit.parameter_errors[0]\n", "\n", "D_hook = k*l_0**2\n", "ΔD_hook = np.sqrt(l_0**4*Δk**2+(2*k*l_0)**2*Δl_0**2)\n", "%m
Berechnung von $D_{Pendel}$
\n", "%m Bei der Bestimmung über die Periodendauer des Federpendels wird die benötigte Zeit einer angehängten Masse für mehrere Schwingungen gemessen, um die Periodendauer und daraus über den Ansatz eines harmonischen Oszillators $D$ zu bestimmen.\n", "m_i = [0.2,0.2,0.2] #Angehängte Massen\n", "m_i = 0.2\n", "Δm_i = 0.005\n", "T_0D = [4.67,9.5,14.27]#gemessene Periodendauern\n", "times = [10,20,30]\n", "ΔT_0D = 0.5\n", "def square_model(i,k=0.3):\n", " return i*np.sqrt(4*np.pi*np.pi*m_i*k**(-1))\n", "xy_data = kafe2.XYContainer(x_data=times, y_data=T_0D)\n", "xy_data.add_error(axis='x', err_val=Δm_i)\n", "xy_data.add_error(axis='y', err_val=ΔT_0D)\n", "square_fit = kafe2.Fit(data=xy_data, model_function=square_model)\n", "\n", "square_fit.do_fit()\n", "p = kafe2.Plot(square_fit)\n", "p.x_label = r'$m_i$ in kg'\n", "p.y_label = r'$T_0$ in s'\n", "p.plot()\n", "p.show()\n", "\n", "k = square_fit.parameter_values[0]\n", "Δk = square_fit.parameter_errors[0]\n", "%m
Vergleich der D Werte
\n", "D_pendulum = k*l_0**2\n", "ΔD_pendulum = np.sqrt(l_0**4*Δk**2+(2*k*l_0)**2*Δl_0**2)\n", "%m $D_{ω_2}= [!nomv(D_ω_2):.2f!] \\,\\frac{kg\\,m^2}{s^2}$\n", "#%m $\\Delta D_{ω_2} = [!stdv(D_ω_2):.2f!] \\,\\mathrm{Nm}$\n", "%m $D_{Hooksch}= [!D_hook:.2f!]\\,\\frac{kg\\,m^2}{s^2}$\n", "#%m $\\Delta D_{Hooksch} = [!ΔD_hook:.2f!] \\,\\mathrm{Nm}$\n", "%m $D_{Pendel}= [!D_pendulum:.2f!] \\,\\frac{kg\\,m^2}{s^2}$\n", "#%m $\\Delta D_{Pendel} = [!ΔD_pendulum:.2f!] \\,\\mathrm{Nm}$\n", "%m Da $D_{ω_2}$ von den meisten gemessenen Werten abhängt und im Vergleich stärker von den anderen beiden Werten abweicht, als diese untereinander, ist davon auszugehen, dass die anderen beiden Messverfahren genauer sind. Dies könnte konkret daran liegen, dass die Feder bei der Kopplung durchhing und konstant gespannt war, während sie bei den anderen beiden Experimenten mehr der Theorie entsprechend gerade hing und in Ruhe eher entspannt war. Relevant zur Bewertung wären allerdings auch die hier nicht bestimmten Fehler, um einzuschätzen, wie kompatibel die Messungen sind." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Aufgabe 3.3: Schwebung\n", "\n", " * Messen Sie die Schwingungsperiode $\\overline{T}$ zur Kreisfrequenz $\\overline{\\omega}=\\frac{1}{2}(\\omega_{1}+\\omega_{2})$ und die Schwebungsperiode $\\tilde{T}$ zur Kreisfrequenz $\\tilde{\\omega}=\\frac{1}{2}\\left|\\omega_{1}-\\omega_{2}\\right|$, bei Anregung der gekop­pel­ten Pendel zu Schwebungen. Nutzen Sie dazu einen der Abstände $\\ell$, die Sie auch in Aufgabe 3.2 benutzt haben. \n", " * Prüfen Sie den erwarteten Zusammenhang zwischen $\\overline{T}$ und $\\tilde{T}$ mit $T_{1}$ und $T_{2}$.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%m Es wurde zu Beginn lediglich eines der Pendel so ausgelenkt und die Periodendauer $\\overline{T}$ der Schwingung eines Pendels und die Periodendauer $\\tilde{T}$ der Einhüllenden bestimmt.\n", "T_bar = [ufloat(1.73,1),\n", " ufloat(3.37,1),\n", " ufloat(4.97,1),\n", " ufloat(6.62,1),\n", " ufloat(8.34,1),\n", " ufloat(9.81,1), #weg?!\n", " ufloat(12.13,1),\n", " ufloat(13.89,1),\n", " ufloat(15.54,1),\n", " ufloat(17.21,1),\n", " ufloat(18.75,1)] #Dauer Eigenschwingung (kürzer)\n", "\n", "\n", "i = np.arange(1,len(T_bar)+1)\n", "def lin_model(i,T=3,b=.3):\n", " return i*T+b\n", "\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=nomv(T_bar))\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = r'$\\bar{T}$ in s'\n", "p.plot()\n", "p.show()\n", "T_bar = lin_fit.parameter_values[0]\n", "\n", "#Dauer Einhüllende (Energieübertragung, länger)\n", "T_tilde = [ufloat(11.06,1),\n", " ufloat(21.3,1),\n", " ufloat(31.29,1),\n", " ufloat(41.74,1),\n", " ufloat(52.41,1),\n", " ufloat(62.53,1),\n", " ufloat(73.07,1)]\n", "i = np.arange(1,len(T_tilde)+1)\n", "def lin_model(i,T=3,b=.3):\n", " return i*T+b\n", "\n", "xy_data = kafe2.XYContainer(x_data=i, y_data=nomv(T_tilde))\n", "lin_fit = kafe2.Fit(data=xy_data, model_function=lin_model)\n", "\n", "lin_fit.do_fit()\n", "p = kafe2.Plot(lin_fit)\n", "p.x_label = 'Anzahl der Perioden'\n", "p.y_label = r'$\\tilde{T}$ in s'\n", "p.plot()\n", "p.show()\n", "T_tilde = lin_fit.parameter_values[0]\n", "\n", "\n", "ω_bar = 2*np.pi/T_bar\n", "ω_tilde = 2*np.pi/T_tilde\n", "%m Die aus diesen gemessenen Werten bestimmten Frequenzen $\\overline{ω} = [!ω_bar:.2!]\\, \\frac{1}{s}$ und $\\tilde{ω} = [!ω_tilde:.2!]\\, \\frac{1}{s}$ passen im Rahmen der Messunsicherheiten einer Zeitmessung mit einer Stoppuhr und dem ungenau einzeln auszulenkenden Pendel, gut zu den aus Eigenfrequenzen zusammengesetzten Werten von $\\overline{ω}_{Eigen} = \\frac{1}{2}*(ω_2+ω_1) = [!1/2*(ω_1+ω_2):.2!]\\, \\frac{1}{s}$ und $\\tilde{ω}_{eigen} = \\frac{1}{2}*(ω_2-ω_1) = [!1/2*(ω_2-ω_1):.2!]\\, \\frac{1}{s}$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "argv": [ "/usr/bin/python3", "-m", "ipykernel", "--matplotlib=inline", "-c", "%config InlineBackend.figure_formats = set(['retina'])\nimport matplotlib; matplotlib.rcParams['figure.figsize'] = (12, 7)", "-f", "{connection_file}" ], "display_name": "Python 3 (Ubuntu Linux)", "env": {}, "language": "python", "name": "python3-ubuntu", "resource_dir": "/usr/local/share/jupyter/kernels/python3-ubuntu" }, "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.10.12" } }, "nbformat": 4, "nbformat_minor": 4 }