{
"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-11, 12, 13 (Stand: Oktober 2023)\n",
"\n",
"[Raum F1-19](https://labs.physik.kit.edu/img/Praktikum/Lageplan_P1.png)\n",
"\n",
"\n",
"\n",
"# Elastizität"
]
},
{
"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: __________________"
]
},
{
"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",
"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",
"import uncertainties\n",
"from uncertainties import ufloat, unumpy\n",
"from uncertainties.unumpy import uarray as uarr\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 scipy\n",
"import matplotlib.image as mpimg\n",
"from io import StringIO\n",
"\n",
"mpl.rcParams['figure.dpi'] = 100\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)\n",
" \n",
"def uplot(x,y,*args, **kwargs):\n",
" utypes = (uncertainties.core.\n",
"Variable,uncertainties.core.AffineScalarFunc)\n",
" xplt = x\n",
" yplt = y\n",
" if type(x[0]) in utypes:\n",
" xplt = nomv(x)\n",
" kwargs[\"xerr\"] = stdv(x)\n",
" if type(y[0]) in utypes:\n",
" yplt = nomv(y)\n",
" kwargs[\"yerr\"] = stdv(y)\n",
" plt.errorbar(xplt,yplt,*args,**kwargs)\n",
"\n",
"def pltimg(path):\n",
" try:\n",
" img = mpimg.imread(path)\n",
" imgplot = plt.imshow(img)\n",
" plt.axis('off')\n",
" plt.show()\n",
" except Exception as e:\n",
" print(\"Image Not Found\")\n",
" print(e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Durchführung\n",
"\n",
"## Aufgabe 1: Elastizitätsmodul aus der Biegung flacher Stäbe\n",
"\n",
"Bei diesem Versuchsteil bestimmen Sie für einige Stoffe den Elastizitätsmodul $E$ aus der Biegung zweiseitig aufgelagerter\n",
"und in der Mitte belasteter, flacher Stäbe. Hierzu stehen Ihnen fünf Materialien zur Verfügung: \n",
"\n",
" * Kupfer,\n",
" * Aluminium,\n",
" * Edelstahl,\n",
" * Messing,\n",
" * PVC.\n",
"\n",
"### Aufgabe 1.1: Messuhr\n",
"\n",
"Bestimmen Sie $E$ aus der Biegung $s$ des Stabs als Funktion der Kraft $F_{g}$ angehängter Gewichte, mit Hilfe einer Messuhr. Für $s$ gilt der Zusammenhang\n",
"\n",
"$$\n",
"s(F_{g}) = \\frac{L^{3}\\,F_{g}}{4E\\,b\\,d^{3}},\n",
"$$\n",
"\n",
"worin $L$ dem Abstand zwischen den beiden Auflagepunkten des jeweiligen Stabs, $b$ der Breite und $d$ der Dicke des Stabs entsprechen. Berücksichtigen Sie für Ihre Messung, dass die Messuhren eine zusätzliche Kraft von $3,6\\,\\mathrm{g/mm}$ auf den jeweiligen Stab ausüben.\n",
"\n",
"---"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ΔUhr = 10e-6\n",
"ΔMassen = 0.5e-3\n",
"\n",
"uL = ufloat(450e-3,2e-3)\n",
"ub = ufloat(25e-3, 0.1e-3)\n",
"ud = ufloat(6e-3, 0.1e-3)\n",
"ug = ufloat(9.809599, 0.00001)\n",
"\n",
"%m In diesem Experiment geht es darum das Elastizitätsmodul aus der Biegung eines Stabes bei verschiedenen Kräften zu bestimmen. Folgende Messwert werden von dem Aufbau geliefert:\n",
"\n",
"a11 = \"\"\"\n",
"Masse in kg, PVC in mm, Aluminium in mm, Edelstahl in mm, Kupfer in mm, Messing in mm\n",
"0, 8e-2, 0, 0, 0, 0\n",
"0.2, 78e-2, 12e-2, 4.5e-2, 6e-2, 8.7e-2\n",
"0.5, 186.5e-2, 30e-2, 11e-2, 16e-2, 21.2e-2\n",
"1, 364.5e-2, 62e-2, 22e-2, 32e-2, 42e-2\n",
"\"\"\"\n",
"\n",
"m, PVC, Al, Fe, Cu, CuZn = np.genfromtxt(StringIO(a11), delimiter=',')[1:].transpose()\n",
"PVC, Al, Fe, Cu, CuZn = PVC*1e-3, Al*1e-3, Fe*1e-3, Cu*1e-3, CuZn*1e-3\n",
"\n",
"mpg = pd.read_csv(StringIO(a11))\n",
"#mpg.rename(columns={\"l\": 'l in m', \"l'\": \"l' in m\",\"s\": \"d in m\", \"ds\": \"Unsicherheit in m\"}, inplace=True)\n",
"display(mpg)\n",
"\n",
"%m Die Messuhr hat eine Unsicherheit von [!ΔUhr*1e3!]mm. Die Massen der Gewichte haben eine Unsicherheit von [!ΔMassen*1e3!]g. Die Balken haben alle die gleichen Abmessungen $d = [!ud.n!]$m und $b = [!ub.n!]$m. Der Abstand der Auflageflächen wurde mit $L = [!uL.n!]$m bestimmt. Für L wurde die Unsicherheit auf [!uL.s*1e3!]mm geschätzt, für d und u auf [!ud.s*1e3!]mm.\n",
"\n",
"%m Durch die Kraft, die die Messuhr auf den Stab ausübt setzt sich F aus zwei Kräften $F_g$ und $F_m = \\alpha\\,g\\,s$ zusammen. Damit ist die Formel für die Auslenkung leicht verändert: $s(F) = \\frac{L^{3}\\,(F_{g} + \\alpha\\,g\\,s)}{4E\\,b\\,d^{3}}$. Aufgelöst nach s ergibt sich ein neuer Zusamenhang von $F_g$ und $s$ wie folgt $s = \\frac{L^3 F_g}{4 E b d^3 - \\alpha \\,g L^3}$ mit $\\alpha = 3.6\\frac{Kg}{m}$. Diesen Zusammenhang zusammen mit einem y-Achsenabschnit können wir im folgenden als Funktion für einen Fit mit Kafe2 verwenden. Für die Erdbeschleunigung wurde hier ein 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 abgerufen am 01.12.2023)\n",
"\n",
"def model(m, L, b, d, g, nullfehler, E=10):\n",
" #print(4*E*b*d**3, 3.6*g*L**3)\n",
" s = (L**3*m*g)/(4*E*1e9*b*d**3 - 3.6*g*L**3)\n",
" #s = (L**3*m*g)/(4*E*b*d**3)\n",
" return s+nullfehler\n",
"\n",
"mats = (\"PVC\", \"Aluminium\", \"Edelstahl\", \"Kupfer\", \"Messing\")\n",
"data = (PVC, Al, Fe, Cu, CuZn)\n",
"for i in range(5):\n",
" %m Anpassung für [!mats[i]!]\n",
" xy_data = kafe2.XYContainer(x_data=m, y_data=data[i])\n",
" xy_data.add_error(axis='x', err_val=ΔMassen)\n",
" xy_data.add_error(axis='y', err_val=ΔUhr)\n",
"\n",
" lin_fit = kafe2.Fit(data=xy_data, model_function=model)\n",
" lin_fit.add_parameter_constraint(name='L',value=uL.n,uncertainty=uL.s)\n",
" lin_fit.add_parameter_constraint(name='b',value=ub.n,uncertainty=ub.s)\n",
" lin_fit.add_parameter_constraint(name='d',value=ud.n,uncertainty=ud.s)\n",
" lin_fit.add_parameter_constraint(name='g',value=ug.n,uncertainty=ug.s)\n",
" lin_fit.do_fit()\n",
"\n",
" p = kafe2.Plot(lin_fit)\n",
" p.x_label = 'Masse in Kg'\n",
" p.y_label = 'Auslenkung s in m'\n",
" p.plot()\n",
" plt.title(mats[i])\n",
" p.show()\n",
" \n",
" _,_,_,_,_,E = lin_fit.parameter_values\n",
" _,_,_,_,_,ΔE = lin_fit.parameter_errors\n",
" uE = ufloat(E,ΔE)*1e9\n",
" \n",
" %m Damit ergibt sich ein Wert von $E = [!uE.n*1e-9:.2f!]Gpa \\pm [!uE.s*1e-9:.2f!]Gpa$ für [!mats[i]!]\n",
" \n",
"%m Die $χ^2$-Werte sind in einem annehmbaren Bereich und die Geraden passen gut zu den Daten. Bei den Messungen für Messing, Kupfer und Edelstahl sind die Messunsicherheiten zu groß geschätzt. Hier scheint eine relative Unsicherheit in der Messuhr zu existieren, die aber leider nicht genau bekannt ist. Insgesamt passen die bestimmten E-Module aber gut zu den erwarteten Werten."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Aufgabe 1.2: Spiegelsystem\n",
"\n",
"Für diesen Aufgabenteil bestimmen Sie die Biegung des Stabs aus der zusätzlichen Neigung $\\alpha$ der Stabenden bei Belastung. Diese bestimmen Sie mit Hilfe zweier Spiegel, die nahe den Stabenden, leicht gegeneinander geneigt montiert sind. Über die Spiegel wird ein punktförmiger Laserstrahl auf einen entfernten Schirm gelenkt. Aus der Verschiebung $\\delta$ der Strahlposition mit und ohne Belastung kann $\\alpha$ nach der Formel \n",
"\n",
"$$\n",
"\\alpha(F_{g}) = \\frac{3L^{2}\\,F_{g}}{4E\\,b\\,d^{3}}\n",
"$$\n",
"\n",
"berechnet werden.\n",
"\n",
"---"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%m In diesem Versuch soll das Elastizitätsmodul eines Balkens mit Hilfe von Spiegeln auf den Auflagepunktn bestimmt werden. Aus dem Winkel $\\alpha$ ergibt sich die verschiebung auf dem Schirm direkt als $v = 2L\\alpha + 4(l+L)\\alpha$ unter Annahme der Kleinwinkelnäherung die hier anwenbar ist. Die Spiegel wurden aus Stabilitätsgründen $\\bar{l}=3\\,mm$ innerhalb der Stützstellen montiert. Dementsprechend muss die Formel folgendermaßen modifiziert werden: $v = 2L\\alpha + 4(l-\\bar{l}+L)\\alpha$.\n",
"\n",
"# Die Spiegel sitzen 3mm weiter innen als erhofft die . \n",
"\n",
"ΔUhr = 0.5e-3\n",
"ΔUhr2 = 5e-3\n",
"ΔMassen = 0.5e-3\n",
"\n",
"uL = ufloat(455e-3,2e-3)\n",
"ulfehler = ufloat(3e-3,0.3e-3)\n",
"ub = ufloat(25e-3, 0.5e-3)\n",
"ud = ufloat(6e-3, 0.5e-3)\n",
"ug = ufloat(9.809599, 0.00001)\n",
"\n",
"ul = ufloat(4.877,2e-3)\n",
"\n",
"%m Folgende Messwert werden für die Verschiebung v des Lasers von dem Aufbau geliefert:\n",
"#alle PVC Messwerte relativ zum 1kg Wert\n",
"a11 = \"\"\"\n",
"Masse in kg, PVC in mm, Aluminium in mm, Messing in mm\n",
"0 , -531 , 0 , 0\n",
"0.2 , -439 , 17.5 , 12.3\n",
"0.5 , -276 , 46 , 31\n",
"0.7 , -165 , 64.5 , 43.3\n",
"1 , 0 , 92 , 62\n",
"\"\"\"\n",
"\n",
"m, PVC, Al, CuZn = np.genfromtxt(StringIO(a11), delimiter=',')[1:].transpose()\n",
"PVC = PVC - PVC[0]\n",
"PVC, Al, CuZn = PVC*1e-3, Al*1e-3, CuZn*1e-3\n",
"\n",
"mpg = pd.read_csv(StringIO(a11))\n",
"mpg[\" PVC in mm\"] = mpg[\" PVC in mm\"] - mpg[\" PVC in mm\"][0]\n",
"display(mpg)\n",
"\n",
"%m Das Ablesen der Verschiebung für den Laserstrahl wird mit einem Geodreieck gemacht und hat eine Unsicherheit von [!ΔUhr*1e3!]mm außer bei PVC, wo die Verschiebungen zu groß sind für das Geofreieck, sodass ein weniger genaues Maßband genutzt wird mit einer Unsicherheit von [!ΔUhr2*1e3!]mm. Die Massen der Gewichte haben eine Unsicherheit von [!ΔMassen*1e3!]g. Die Balken haben alle die gleichen Abmessungen $d = [!ud.n!]$m und $b = [!ub.n!]$m. Der Abstand der Auflageflächen wurde mit $L = [!uL.n!]$m bestimmt. Für L wurde die Unsicherheit auf [!uL.s*1e3!]mm geschätzt, für d und u auf [!ud.s*1e3!]mm. Für die Erdbeschleunigung wurde hier ein 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 abgerufen am 01.12.2023). Der Abstand $l$ zwischen Wand und dem der Wand am nächsten stehenden Spiegel ist $l = [!ul.n!]$m und wurde mit einer Unsicherheit von $[!ul.s!]$m bestimmt.\n",
"\n",
"def model(m, L, b, d, g, l, lfehler, E=10):\n",
" α = (3*L**2*m*g)/(4*E*1e9*b*d**3)\n",
" v = (4*(l-2*lfehler)+6*L)*α\n",
" return v\n",
"\n",
"mats = (\"PVC\", \"Aluminium\", \"Messing\")\n",
"data = (PVC, Al, CuZn)\n",
"for i in range(3):\n",
" %m Anpassung für [!mats[i]!]\n",
" xy_data = kafe2.XYContainer(x_data=m, y_data=data[i])\n",
" xy_data.add_error(axis='x', err_val=ΔMassen)\n",
" xy_data.add_error(axis='y', err_val=ΔUhr2 if mats[i]==\"PVC\" else ΔUhr)\n",
" \n",
" lin_fit = kafe2.Fit(data=xy_data, model_function=model)\n",
" lin_fit.add_parameter_constraint(name='L',value=uL.n,uncertainty=uL.s)\n",
" lin_fit.add_parameter_constraint(name='b',value=ub.n,uncertainty=ub.s)\n",
" lin_fit.add_parameter_constraint(name='d',value=ud.n,uncertainty=ud.s)\n",
" lin_fit.add_parameter_constraint(name='g',value=ug.n,uncertainty=ug.s)\n",
" lin_fit.add_parameter_constraint(name='l',value=ul.n,uncertainty=ul.s)\n",
" lin_fit.add_parameter_constraint(name='lfehler',value=ulfehler.n,uncertainty=ulfehler.s)\n",
" lin_fit.do_fit()\n",
"\n",
" p = kafe2.Plot(lin_fit)\n",
" p.x_label = 'Masse in Kg'\n",
" p.y_label = 'Auslenkung v in m'\n",
" p.plot()\n",
" plt.title(mats[i])\n",
" p.show()\n",
" \n",
" _,_,_,_,_,_,E = lin_fit.parameter_values\n",
" _,_,_,_,_,_,ΔE = lin_fit.parameter_errors\n",
" uE = ufloat(E,ΔE)*1e9\n",
" \n",
" %m Damit ergibt sich ein Wert von $E = [!uE.n*1e-9:.2f!]Gpa \\pm [!uE.s*1e-9:.2f!]Gpa$ für [!mats[i]!]\n",
" \n",
"%m Die hier bestimmten Werte sind im Rahmen der bestimmten Messunsicherheiten mit den im vorherigen Versuch bestimmten Werten kompatibel."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Aufgabe 2: Elastizitätsmodul aus der Schallgeschwindigkeit \n",
"\n",
"In diesem Versuchsteil bestimmen Sie die Zeit $\\Delta t$, die ein Verdichtungsstoß benötigt, um mehrfach im Stab der Länge $L$ hin- und herzulaufen. Der Verdichtungsstoß wird verursacht durch das axiale Anschlagen einer Pendelkugel ans entsprechende Stabende erzeugt. Die entstehende Welle wird an den freien Stabenden jeweils reflektiert wird. Am erregerfernen Stabende werden die Schallsignale mit Hilfe eines Piezokristalls in Spannungspulse umgewandelt und mit einem Oszilloskop aufgenommen.\n",
"\n",
"Bestimmen Sie die Zeitdifferenzen $\\Delta t$ zu möglichst vielen Reflektionen und ermitteln Sie die Schallgeschwindigkeit $v_{\\mathrm{ph}}$ als Steigung der resultierenden Geraden. Beachten Sie, dass es bei jeder Messung nötig ist, in einem Vorversuch zunächst etwa die Mitte jenes Bereichs der Anschlagstärke zu suchen, in dem die Ergebnisse für $\\Delta t$ reproduzierbar sind. Störsignale, z.B. von unvermeidlichen andersartigen Anregungsmoden lassen sich auf dem Oszilloskop gut vom Hauptschwingungsmodus unterscheiden. Lediglich bei PVC wird das Signal so schnell gedämpft, dass nur wenige Reflektionen messbar sind.\n",
"\n",
"**Achtung:** Der Piezodetektor verträgt wegen der leicht aufbrechenden Klebungen keine harten Stöße. Die Pendelkugel darf daher aus höchstens $8\\,\\mathrm{cm}$ Entfernung vom Stabende losgelassen werden.\n",
"\n",
"---"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%m Es werden die zu vermessenden Stäbe einseitig mit einem Pendel angestoßen und die Erschütterung am anderen Ende mit einem PicoScope aufgezeichnet. Es werden mehrere Reflektionen gemessen und aus der Periodendauer mit der Länge des Stabs die Schallgeschwindigkeit im Medium ermittelt.\n",
"L = [ufloat(146e-2,2e-3),ufloat(1458e-3,2e-3),ufloat(1461e-3,2e-3)] #eintragen\n",
"L = [i+13e-3 for i in L]\n",
"d = [ufloat(1e-2,0.1e-3),ufloat(1e-2,0.1e-3),ufloat(1.06e-2,0.1e-3)]\n",
"m = [ufloat(1032e-3,1e-3),ufloat(327e-3,1e-3),ufloat(167e-3,1e-3)]\n",
"ρ = [4*m[i]/(np.pi*d[i]**2*L[i]) for i in np.arange(0,len(L))]#aus Durchmesser und Länge mit Masse errechnen\n",
"names =[\"Kupfer\",\"Aluminium\",\"PVC\"]\n",
"Δt_all = [50e-6,80e-6,660e-6]\n",
"\n",
"v = [0 for i in L]\n",
"Δv = [0 for i in L]\n",
"E = [0 for i in L]\n",
"ΔE = [0 for i in L]\n",
"\n",
"def lineModel(i,v=300,L=nomv(L[0])):\n",
" return i*2*L/v\n",
"autokorruse = True\n",
"\n",
"if autokorruse:\n",
" %m Die Daten wurden am PC durch Setzen zweier Cursor an der geschätzten Maxima ermittelt. Für die Daten wurde jeweils die größte Breite eines Peaks als Unsicherheit angenommen, da im verwischten Maximum keine größere Genauigkeit garantiert werden dann und sich diese Ungenauigkeit fortsetzen kann.\n",
" for k in range(0,len(L)):\n",
" file = \"A2_\" + names[k] + \".csv\"\n",
" mpg = pd.read_csv(file)\n",
" mpg.rename(columns={'i':'Anzahl Durchläufe','t': 'Zeit in s'}, inplace=True)\n",
" j,t = np.genfromtxt(file, delimiter=',')[1:].transpose()\n",
" Δt = Δt_all[k] #Abschätzen\n",
" %m Vermessung eines [!names[k]!]-Stabes der Länge $L=([!L[k].n:.4!]\\pm[!L[k].s!])m$, Dicke $d=([!d[k].n!]\\pm[!d[k].s!])m$ und Masse $m=([!m[k].n!]\\pm[!m[k].s!])kg$:\n",
" display(mpg)\n",
" #Fitten\n",
" %m An die Daten wird nun ein Modell der Form $t = i \\frac{2 L}{v}$ angepasst.\n",
" xy_data = kafe2.XYContainer(x_data=j, y_data=t)\n",
" line_fit = kafe2.Fit(data=xy_data, model_function=lineModel)\n",
" line_fit.add_error(\"y\",Δt)\n",
" line_fit.add_parameter_constraint(name='L', value=nomv(L[k]), uncertainty=stdv(L[k]))\n",
" line_fit.do_fit()\n",
" p = kafe2.Plot(line_fit)\n",
" p.x_label = 'Anzahl Durchläufe'\n",
" p.y_label = 'Zeit in s'\n",
" p.plot()\n",
" p.show()\n",
" v[k] = ufloat(line_fit.parameter_name_value_dict['v'],line_fit.parameter_errors[0])\n",
" %m Wie zu erkennen ist, ist die $\\chi^2-Wahrscheinlichkeit$ aller Fits äußerst gut, allerdings ist $\\frac{\\chi^2}{ndof}$ weit von 1 entfernt. Dies liegt zum Teil an den scheinbar recht groß abgeschätzten Fehlern - der Einfluss der breiteren Maxima auf die früheren Maxima ist wohl kleiner als erwartet. Aber auch die geringe Anzahl der Messpunkte ist problematisch, ist allerdings durch das recht schnelle Verwischen der Maxima bedingt, die ein Ablesen weiterer Werte dahingehend unmöglich machen, dass es zum Ratespiel wird, welches Maxima das richtige nächste ist. Eine messliche Verbesserung unsererseits wäre es dann gewesen für jedes Material mehrerere Messreihen aufzunehmen und immer die geringe Anzahl an bestimmbaren Perioden zu messen und diese dann zusammenzufügen. Diese Variante hätte auch definitiv erlaubt die Auswirkung der größeren Ableseungenauigkeit zu reduzieren.\n",
" \n",
" \n",
" \n",
" \n",
"else:\n",
" i = 0\n",
" #possibility 2 (with raw files)\n",
" #Ermittelung der Autokorrelation\n",
" file = \"A2_Rohdaten/Alu\" + \".csv\"\n",
" mpg = pd.read_csv(file)\n",
" mpg.rename(columns={'Kanal A':'Auslenkung','Zeit': 'Zeit in s'}, inplace=True)\n",
" t,ay = np.genfromtxt(file, delimiter=',')[1:].transpose()\n",
" Δt = 1E-3 #Abschätzen\n",
" %m Vermessung von [!names[i]!]:\n",
" display(mpg)\n",
" %m Diese Daten werden nun autokorreliert, um die Peaks und damit die Periodendauer der umlaufenden Erschütterung zu bestimmen.\n",
" autocov = np.correlate(ay,ay, 'full')[-len(ay):]\n",
" autocorr = autocov/autocov[0]\n",
" #Bestimmen der Minima und Maxima\n",
" ay_max = sci.signal.find_peaks(autocorr)[0]\n",
" ay_min = sci.signal.find_peaks(autocorr*(-1))[0]\n",
" # Darstellung der Autokorrelation und der Extrema\n",
" plt.plot(t,autocorr)\n",
" plt.scatter(t[ay_max],autocorr[ay_max])\n",
" plt.scatter(t[ay_min],autocorr[ay_min])\n",
" plt.xlabel(\"time difference\")\n",
" plt.ylabel(\"autocorrelation\")\n",
" plt.show()\n",
" t_diff = np.concatenate([np.diff(t[ay_max]),np.diff(t[ay_min])])\n",
" T_mean = np.mean(t_diff)\n",
" ΔT = np.sqrt(np.var(t_diff,ddof=1))\n",
" T = ufloat(T_mean,ΔT)\n",
" v[i] = L[i]/T\n",
" %m Es ergibt sich eine Periodendauer von $T_{[!names[i]!]} = ([!T_mean:.3!] \\pm [!ΔT:.3!])\\, s$ und damit eine Schallgeschwindigkeit von $v_{[!names[i]!]} = ([!nomv(v[i]):.2!] \\pm [!stdv(v[i]):.2!])\\, \\frac{m}{s}$ .\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"for i in range(0,len(v)):\n",
" E[i] = ρ[i]*v[i]**2 *1e-9\n",
"\n",
"%m Aus diesen Werten lassen sich nach $E=ρ v^2$ Werte für E folgern, wobei $v$ aus den Fits entnommen und $\\rho$ aus Masse und Volumen der Stäbe bestimmt wurde:\n",
"df = pd.DataFrame({\n",
" \"Material\": names,\n",
" r\"E-Modul in Gpa\": E\n",
"})\n",
"display(df)\n",
"%m Es gibt kein wirklichen Vergleichswerte für diese Werte, da die genauen Zusammensetzungen unbekannt sind und andere Stäbe als in den anderen Aufgaben verwendet werden, allerdings liegen die Werte in ähnlichen Größenordnungen. Lediglich der Wert für PVC ist etwas niedrig, was aber leicht durch die geringe Anzahl an Messpunkten und ihre große Unsicherheit zu begründen ist."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Aufgabe 3: Torsionsmodul\n",
"\n",
"Bestimmen Sie für wenigstens einen der zur Verfügung stehenden Stoffe den Schubmodul $G$ aus der Schwingungsdauer $T$ von\n",
"geeignet angeregten Torsionsschwingungen. \n",
"\n",
"Hierzu ist ein zylindrischer Stab aus dem zu untersuchenden Stoff jeweils am oberen Ende fest eingespannt und trägt am unteren Ende eine Drehscheibe. Die Drehscheibe wird um einen kleinen Winkel ausgelenkt und führt, nachdem Sie sie loslassen, Drehschwingungen aus. Verwenden Sie die Scheibe ohne, mit zwei und mit vier Zusatzmassen. Bestimmen Sie aus den zugehörigen Schwingungsdauern sowie den berechenbaren Zusatzträgheitsmomenten das Trägheitsmoment der Scheibe. \n",
"\n",
"Führen Sie diese Messung für mindestens eines der zur Verfügung stehenden Materialien durch. \n",
"\n",
" ---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In dieser Aufgabe geht es daum das Schubmodul bzw. Torsionsmodul eines Materials zu untersuchen. Dabei wird die Frequenz der Schwingung eines Torsionspendels gemessen wobei das zu untersuchende Material die Rückstellene Federkraft aufbringt. Dabei wird eine Auslenkung von 10° nicht überschritten, da für größere Winkel die Kleinwinkelnäherungen zunehmend ungenau werden und nichtlineare Terme einen wesentlichen Einfluss auf das Ergebnis nehmen. Außerdem wird sonst der Torsionsstab beschädigt.\n",
"\n",
"Aus dem Schubmodul kann die Torsionssteifigkeit $S_t$ als Produkt mit dem Torsionsträgheitsmoment errechnet werden $S_t = G I_T = G \\frac{r^4 \\pi}{2}$ und damit das Direktionsmoment $D = \\frac{S_t}{l}$ mit der Länge l des Stabes. Die Schwingdauer eines Drehpendels ergibt sich aus dem Trägheitsmoment $\\Theta$ sodass $T = 2 \\pi \\sqrt{\\frac{\\Theta}{D}}$\n",
"\n",
"Damit ergibt sich für einen Regression das Modell $T = \\sqrt{8 \\frac{\\Theta l \\pi}{G r^4}}$. Das Trägheitsmoment ergibt sich dann nach dem Satz von Steinert aus dem Trägheitsmoment der Platte und den Trägheitsmomenten und Abständen der Massen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%m In diesem Versuch wird das Schubmodul von Aluminium über die Periodendauer eines Torsionspendels bestimmt.\n",
"ul = ufloat(0.8, 1e-3)\n",
"ur = ufloat(3.97e-3, 0.1e-5)/2\n",
"\n",
"um = ufloat(0.837, 1e-3)\n",
"uR2 = ufloat(0.0349, 0.5e-3) #Masseradius\n",
"uR = np.sqrt(2)*(ufloat(0.08, 0.5e-3) + 2*uR2)/2 #Masseradius\n",
"\n",
"%m Folgende Messwert werden für die Schwingdauer T der Drehscheibe für 100 Perioden von dem Aufbau geliefert: \n",
" \n",
"a11 = \"\"\"\n",
"Anzahl extra Massen, Schwingdauer T in s, Unsicherheit in s\n",
"0,56.44,1\n",
"2,112.18,1\n",
"4,146.75,1\n",
"\"\"\"\n",
"\n",
"n, T, dT = np.genfromtxt(StringIO(a11), delimiter=',')[1:].transpose()\n",
"T, dT = T/100, dT/100\n",
"\n",
"%m Die Länge des Stabes beträgt ($[!ul.n*1e3:.2f!]\\pm[!ul.s*1e3:.2f!]$)mm. Der radius des Stabs beträgt ($[!ur.n*1e3:.2f!]\\pm[!ur.s*1e3:.2f!]$)mm. Die Masse der Zusatzgewichte beträgt laut Datenblatt ($[!um.n:.2f!]\\pm[!um.s:.3f!]$)Kg mit einem Radius von ($[!uR2.n*1e3:.2f!]\\pm[!uR2.s*1e3:.2f!]$)mm. Der Abstand der Massenschwerpunkte von der Rotationsachse ist nicht einfach zu messen, weswegen der Abstand zwischen zwei nebeneinanderliegenden Massen bestimmt wurde und darüber die diagonale des entstehenden Vierecks bestinmmt wurde unter der Annahme, dass der Aufbau in guter Näherung rotationssymmetrisch ist. Damit ergibt sich ein Wert von ($[!uR.n*1e3:.2f!]\\pm[!uR.s*1e3:.2f!]$)mm\n",
"\n",
"mpg = pd.read_csv(StringIO(a11))\n",
"display(mpg)\n",
"\n",
"def model(n, Θ_platte=0.007, R=uR.n, R2=uR2.n, r=ur.n, l=ul.n, m=um.n, G=1):\n",
" Θ = Θ_platte + n*m*(R2**2/2 + R**2)\n",
" T = np.sqrt((8*Θ*l*pi)/(G*1e9*r**4))\n",
" return T\n",
"\n",
"xy_data = kafe2.XYContainer(x_data=n, y_data=T)\n",
"xy_data.add_error(axis='x', err_val=0)\n",
"xy_data.add_error(axis='y', err_val=dT)\n",
"\n",
"lin_fit = kafe2.Fit(data=xy_data, model_function=model,minimizer=\"iminuit\")\n",
"lin_fit.add_parameter_constraint(name='R',value=uR.n,uncertainty=uR.s)\n",
"lin_fit.add_parameter_constraint(name='R2',value=uR2.n,uncertainty=uR2.s)\n",
"lin_fit.add_parameter_constraint(name='r',value=ur.n,uncertainty=ur.s)\n",
"lin_fit.add_parameter_constraint(name='l',value=ul.n,uncertainty=ul.s)\n",
"lin_fit.add_parameter_constraint(name='m',value=um.n,uncertainty=um.s)\n",
"lin_fit.do_fit()\n",
"\n",
"p = kafe2.Plot(lin_fit)\n",
"p.x_label = 'Anzahl Zusatzgewichte'\n",
"p.y_label = 'Periodendauer in s'\n",
"p.plot()\n",
"p.show()\n",
"\n",
"_,_,_,_,_,_,G = lin_fit.parameter_values\n",
"_,_,_,_,_,_,ΔG = lin_fit.parameter_errors\n",
"uG = ufloat(G,ΔG)*1e9\n",
"\n",
"%m Damit ergibt sich ein Wert von $G = [!uG.n*1e-9:.2f!]Gpa \\pm [!uG.s*1e-9:.2f!]Gpa$. Die Gerade passt gut zu den gemessenen Daten und die $\\chi^2$-Werte sind in einem guten Bereich. "
]
},
{
"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
}