diff --git a/exercises-toolbox/1-python/Makefile b/exercises-toolbox/1-python/Makefile index 661a5fc7..c0bd8ffb 100644 --- a/exercises-toolbox/1-python/Makefile +++ b/exercises-toolbox/1-python/Makefile @@ -2,7 +2,13 @@ include ../../common/common.mk include ../../common/loesung.py.mk include ../../common/generate_vorlage.mk -all: 5-readwrite/test.txt +all: 5-readwrite/test.txt example-report/v16516.pdf 5-readwrite/test.txt: 5-readwrite/loesung2.py.dummy @echo "Dies ist ein Beispiel" > 5-readwrite/test.txt + +example-report/v16516.pdf: | ../8-all/report-example/loesung/v16516/build/v16516.pdf + cp ../8-all/report-example/loesung/v16516/build/v16516.pdf example-report + +../8-all/report-example/loesung/v16516/build/v16516.pdf: + $(MAKE) -C ../8-all/report-example/loesung/v16516/ diff --git a/exercises-toolbox/1-python/example-report b/exercises-toolbox/1-python/example-report new file mode 100644 index 00000000..43318a9c Binary files /dev/null and b/exercises-toolbox/1-python/example-report differ diff --git a/exercises-toolbox/1-python/report-example/aufgabe.txt b/exercises-toolbox/1-python/report-example/aufgabe.txt new file mode 100644 index 00000000..b9f4237c --- /dev/null +++ b/exercises-toolbox/1-python/report-example/aufgabe.txt @@ -0,0 +1,30 @@ +# Realistisches-Beispiel-Protokoll + +Einleitung: + +Wie der Name der Aufgabe schon verspricht, werdet ihr im Zuge dieser Aufgabe ein vollständiges +und realistisches Versuchsprotokoll erstellen. Diesem Ziel werdet ihr Tag für Tag etwas näher kommen +können, in dem die Themen des jeweiligen Tages integriert werden. + +Um zu wissen, wo es hingeht, findet ihr auch in diesem Ordner schon das vollständige Protokoll zum Ansehen. + +Aufgabe: + +Heute fällt diese Aufgabe noch nicht zu umfangreich aus. Es geht zunächst nur um das Kopieren +des Ordners in dem ihr diese Aufgabe immer weiter ergänzt. Dieser Ordner heißt 'v16516' und befindet sich +im Ordner 'vorlage'. Kopiert den Ordner 'v16516' in einen Ordner, in dem ihr diesen im Lauf des +Workshops wieder findet, z.B. '~/Documents/Toolbox-Workshop'. + +Das war es schon, morgen gehts weiter. + +Erklärung: + +Im Ordner 'v16516' befindet sich noch nicht viel, nur eine leere Pythondatei und ein Ordner 'data' in dem sich +die Textdateien mit den Messwerten befinden, die ihr für die Auswertung verwenden werdet. Das spaßige Abtippen +der Messwerte aus dem Laborbuch, haben wir euch schonmal abgenommen. ;) + + + + + + diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/auswertung.py b/exercises-toolbox/1-python/report-example/vorlage/v16516/auswertung.py new file mode 100644 index 00000000..e69de29b diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Bahn.txt b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..bc860551 --- /dev/null +++ b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l +80 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..72cb5208 --- /dev/null +++ b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,Fi,Ff, +4.5,436,492 +4.5,555,610 +4.5,672,729 +10,95,130 +10,199,235 +10,303,338 +15,91,119 +15,201,229 +15,335,362 +20,232,256 +20,323,347 +20,397,421 +25,153,174 +25,239,260 +25,322,343 +30,219,238 +30,319,338 +30,391,412 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..245c87d2 --- /dev/null +++ b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,21 @@ +#h,Fi,Ff +4.5,1018,1083 +4.5,1189,1248 +4.5,1340,1404 +10,596,636 +10,762,801 +10,882,921 +15,574,605 +15,766,798 +15,863,896 +20,679,707 +20,810,838 +20,930,959 +25,650,674 +25,892,917 +25,804,827 +30,642,664 +30,739,760 +30,900,922 +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Kamera.txt b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..1b429402 --- /dev/null +++ b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps +30 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Kugel.txt b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..1dc033ed --- /dev/null +++ b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,U +216,30.5 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Zylinder.txt b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..6ba4a540 --- /dev/null +++ b/exercises-toolbox/1-python/report-example/vorlage/v16516/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,U,d +186,24.3,3 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/2-numpy/report-example/aufgabe.txt b/exercises-toolbox/2-numpy/report-example/aufgabe.txt new file mode 100644 index 00000000..df77421e --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/aufgabe.txt @@ -0,0 +1,21 @@ +# Realistisches Beispiel Protokoll + +Einleitung: +Um dieser Aufgabe sinnvoll folgen zu können sollte diese von Anfang an bearbeitet werden. Folgt den +Anweisungen in den 'aufgabe.txt' Dateien im Ordner 'Realistisches-Beispiel-Protokoll', beginnend +im Aufgabenordner '1-python'. + +Aufgabe: +Mit den Informationen zu numpy habt ihr nun die Möglichkeit die Messwerte aus dem Ordner 'data' +einzulesen und zu verarbeiten. + +1. Importiert numpy in der Datei 'auswertung.py', lest die Messwerte in den Dateien im Ordner 'data' ein + (achtet auf die Angabe der Einheiten zu den Messwerten) +2. Gebt diese auf das Terminal aus um zu sehen ob, die Werte richtig geladen wurden +3. Berechnet mit den Daten folgende Werte (die Gleichungen stehen im fertigen Beispiel-Protokoll) + - Radius r von Ball und Zylinder + - Trägheitsmoment I von Ball und Zylinder + - Zeitdauern t für das Herabrollen beider Objekte +4. Gebt auch diese berechneten Werte auf das Terminal aus, um diese zu überprüfen +5. Die Messung wurde für jede Höhe dreifach durchgeführt. Berechnet für jede Höhe + jeweils den zugehörigen Mittelwert der Zeitdauern diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/auswertung.py b/exercises-toolbox/2-numpy/report-example/loesung/v16516/auswertung.py new file mode 100644 index 00000000..f584f4fd --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/auswertung.py @@ -0,0 +1,161 @@ +# Kommentar: +# Importiere numpy unter dem Namen np + +import numpy as np + +# Kommentar: +# Die Daten liegen im Ordner 'data'. Um die Dateien einlesen +# zu können, reicht es deswegen nicht den Dateinamen anzugeben, +# es muss der gesamte Pfad ('Orderabfolge') angegeben werden: +# +# Für die Datei: Messwerte_Bahn.txt also data/Messwerte_Bahn.txt +# +# Der Name der Variable in der die eingelesenen Werte gespeichert werden +# ist frei wählbar, es bietet sich bei 'langen' Skripten an (im Gegensatz zur Mathematik) +# nicht nur einbuchstabige Abkürzungen zu verwenden, um nicht die Übersicht zu verlieren. +# Also beispielsweise track_length statt L. Ein Kommentar zur erklären sollte aber drin sein. +# +# Es bietet sich an die Daten direkt beim Einlesen in eine sinnvolle Einheit umzuwandeln +# (falls nötig) und diese mit einem Kommentar zu vermerken + +# Länge der schiefen Ebene +L = np.genfromtxt("data/Messwerte_Bahn.txt", delimiter=",")/100 # m + +# Framerate der Kamera +fps = np.genfromtxt("data/Messwerte_Kamera.txt", delimiter=",") # 1/s +# Kommentar: +# Die Daten aus Dateien mit mehreren spalten muss man in einer extra Zeile skalieren + +# Masse und Umfang der Kugel +m_b, u_b = np.genfromtxt("data/Messwerte_Kugel.txt", delimiter=",", unpack=True) +m_b = m_b/1000 # kg +u_b = u_b/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Kugel) +h_b, Fi_b, Ff_b = np.genfromtxt("data/Messwerte_Frames_Kugel.txt", delimiter=",", unpack=True) +h_b = h_b/100 # m + +# Masse und Umfang des Zylinders +m_c, u_c, d_c = np.genfromtxt("data/Messwerte_Zylinder.txt", delimiter=",", unpack=True) +m_c = m_c/1000 # kg +u_c = u_c/100 # m +d_c = d_c/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Zylinder) +h_c, Fi_c, Ff_c = np.genfromtxt("data/Messwerte_Frames_Zylinder.txt", delimiter=",", unpack=True) +h_c = h_c/100 # m + +# Kommentar: +# Ein gewisses Maß an Struktur in der Benennung von Variablen hilft bei der Orientierung, +# gerade in der Zusammenarbeit mit euren jeweiligen Partnern. +# Man muss es aber auch nicht übertreiben. Gerade ein Sprachenmix aus deutsch und englisch +# ist nicht besonders tragisch: z.B. steht m_b für mass_ball aber u_b für umfang_ball, +# aber das p_b für perimeter_ball würde mir persönlich nicht so klar werden. + + +# Kommentar: +# Auch die einzelnen "Arbeitsschritte" der Auswertung sollten in einem +# kurzen Kommentar erklärt werden. + +# Berechnung der benötigten Größen: Radius und Trägheitsmoment + +# Radius der Kugel +r_b = u_b/(2*np.pi) + +# Äußerer Radius des Zylinders +ro_c = u_c/(2*np.pi) + +# Innerer Radius des Zylinders +ri_c = ro_c - d_c + + +# Trägheitsmoment der Kugel +I_b = 2/5 * m_b * r_b**2 + +# Trägheitsmoment des Zylinders +I_c = 1/2 * m_c * (ro_c**2 + ri_c**2) + +print("Trägheitsmoment (Kugel)") +print(I_b) + +print("Trägheitsmoment (Zylinder)") +print(I_c) + + +# Berechnung der Rollzeiten aus den Messwerten der Frames und Framerate +t_b = (Ff_b - Fi_b)/fps +t_c = (Ff_c - Fi_c)/fps + +# Berechnung des Mittelwerts für die Zeitdauer t für jede (dreifach gemessene) Höhe + +# Kommentar: +# Es ist ein neuer Name (t_b_mean) notwendig, wenn die alten Werte in t_b +# noch verfügbar bleiben sollen +# +# Hieran sieht man (schon im Kleinen) die Nützlichkeit der numpy arrays +# und der möglichen Manipulationen: +# reshape(-1,3): +# Im array t_b liegen die zu mittelnden Werte immer genau hintereinander +# durch reshape(-1,3) wird aus t_b ein 2D array erzeugt, das in jeder +# Zeile 3 Spalten hat. Das bedeutet: Nach jeweils 3 Werten in t_b wird eine neue +# Zeile begonnen, damit sind in jeder Zeile genau die Werte die gemittelt werden sollen. +# Die -1 als Anzahl der Zeilen ist gibt numpy die Anweisung, diese Anzahl +# selbst zu berechnen. +# +# mean(axis=1): +# Bei einem 2D array bezeichnet axis=0 die Zeilen und axis=1 die Spalten. +# Berechnet den Mittelwert "entlang der axis 1", d.h. die axis 1 ist die "Dimension" +# des arrays, über die summiert wird (die danach nur noch einen Wert enthält). +# Da jede Zeile genau die drei Werte enthält, die zu mitteln sind, enthält jede +# Zeile danach genau den jeweiligen Mittelwert. + +t_b_mean = t_b.reshape(-1,3).mean(axis=1) + + + +# Kommentar: +# Das Array h_b enthält jede Höhe dreifach, auch die Auswahl +# der einzelnen Höhen kann durch array Manipulation geschehen. +# +# Die Benennung der Variable (h_b_mean) wurde so gewählt, +# dass diese zur zugehörigen Variable für die Zeitdauern passt +# +# reshape(-1, 3): +# analog zur Manipulation von t_b +# [:,0] +# Aus jeder Zeile (= erster Index ist ':') wird die 'nullte' Spalte (= zweiter Index ist '0') +# ausgewählt, d.h. in jeder Zeile bleibt genau eine Höhe erhalten. + +h_b_mean = h_b.reshape(-1,3)[:,0] + + + +# Kommentar: +# analog für die andere Messreihe + +t_c_mean = t_c.reshape(-1,3).mean(axis=1) +h_c_mean = h_c.reshape(-1,3)[:,0] + +# Ausgabe verarbeiteten der Messwerte + +print("Messwerte (Kugel)") +print("alle Zeiten") +print(t_b) +print("alle Höhen") +print(h_b) +print("Höhe") +print(h_b_mean) +print("gemittlelte Zeit") +print(t_b_mean) +print("\n") + + +print("Messwerte (Zylinder)") +print("alle Höhen") +print(h_c) +print("alle Zeiten") +print(t_c) +print("Höhe") +print(h_c_mean) +print("gemittlelte Zeit") +print(t_c_mean) diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Bahn.txt b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..bc860551 --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l +80 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..72cb5208 --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,Fi,Ff, +4.5,436,492 +4.5,555,610 +4.5,672,729 +10,95,130 +10,199,235 +10,303,338 +15,91,119 +15,201,229 +15,335,362 +20,232,256 +20,323,347 +20,397,421 +25,153,174 +25,239,260 +25,322,343 +30,219,238 +30,319,338 +30,391,412 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..245c87d2 --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,21 @@ +#h,Fi,Ff +4.5,1018,1083 +4.5,1189,1248 +4.5,1340,1404 +10,596,636 +10,762,801 +10,882,921 +15,574,605 +15,766,798 +15,863,896 +20,679,707 +20,810,838 +20,930,959 +25,650,674 +25,892,917 +25,804,827 +30,642,664 +30,739,760 +30,900,922 +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Kamera.txt b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..1b429402 --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps +30 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Kugel.txt b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..1dc033ed --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,U +216,30.5 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Zylinder.txt b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..6ba4a540 --- /dev/null +++ b/exercises-toolbox/2-numpy/report-example/loesung/v16516/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,U,d +186,24.3,3 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/3-matplotlib/report-example/aufgabe.txt b/exercises-toolbox/3-matplotlib/report-example/aufgabe.txt new file mode 100644 index 00000000..2b8e8c97 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/aufgabe.txt @@ -0,0 +1,28 @@ +# Realistisches Beispiel Protokoll + +Einleitung: +Um dieser Aufgabe sinnvoll folgen zu können sollte diese von Anfang an bearbeitet werden. Folgt den +Anweisungen in den 'aufgabe.txt' Dateien im Ordner 'Realistisches-Beispiel-Protokoll', beginnend +im Aufgabenordner '1-python'. + +Aufgabe: +Mit den Informationen über matplotlib könnt ihr nun die zwei Plots aus den Daten erstellen, +die ihr in der letzten Aufgabe verarbeitet habt. + +Erstellt für jede Messreihe (Kugel, Zylinder) jeweils eine Abbildung: +1. Importiert matplotlib.pyplot in eure Datei auswertung.py +2. Erstellt jeweils eine Abbildung mit einem subplot, in dem die Messwerte (die berechneten Mittelwerte) + als schwarze '+' dargestellt werden. + +Die Berechnung von Ausgleichskurven wird erst durch eine weitere Bibliothek (scipy) möglich. +Jedoch könnt ihr den Verlauf der theoretischen Funktionen bereits in die Plots einzeichnen. + +3. Schreibt jeweils eine Python-Funktion für die Gleichungen t_B(h) und t_Z(h) (Gleichungen 4 und 5 im Protokoll). + Lls Wert für g könnt ihr 9.81 verwenden (auch dafür wird scipy noch eine bessere Lösung sein) +4. Erstellt mit np.linspace ein array mit vielen Werten die für den Plot der Theorie-Funktion verwendet werden können. + (da matplotlib im Prinzip einzelne Punkte zeichnet bzw. diese mit Geraden verbindet, braucht man für Theorie-Funktion + sehr viele Punkte und kann nicht einfach nur die Messwerte für h verwenden.) +5. Ergänzt die Theorie-Funktion im jeweiligen plot der Messwerte. + + + diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/auswertung.py b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/auswertung.py new file mode 100644 index 00000000..b97041f4 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/auswertung.py @@ -0,0 +1,157 @@ +import numpy as np +# Kommentar: +# Importiere matplotlib.pyplot unter dem Namen plt + +import matplotlib.pyplot as plt + +# Länge der schiefen Ebene +l = np.genfromtxt("data/Messwerte_Bahn.txt", delimiter=",")/100 # m + +# Framerate der Kamera +fps = np.genfromtxt("data/Messwerte_Kamera.txt", delimiter=",") # 1/s + +# Masse und Umfang der Kugel +m_b, u_b = np.genfromtxt("data/Messwerte_Kugel.txt", delimiter=",", unpack=True) +m_b = m_b/1000 # kg +u_b = u_b/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Kugel) +h_b, Fi_b, Ff_b = np.genfromtxt("data/Messwerte_Frames_Kugel.txt", delimiter=",", unpack=True) +h_b = h_b/100 # m + +# Masse und Umfang des Zylinders +m_c, u_c, d_c = np.genfromtxt("data/Messwerte_Zylinder.txt", delimiter=",", unpack=True) +m_c = m_c/1000 # kg +u_c = u_c/100 # m +d_c = d_c/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Zylinder) +h_c, Fi_c, Ff_c = np.genfromtxt("data/Messwerte_Frames_Zylinder.txt", delimiter=",", unpack=True) +h_c = h_c/100 # m + + +# Berechnung der benötigten Größen: Radius und Trägheitsmoment + +# Radius der Kugel +r_b = u_b/(2*np.pi) + +# Äußerer Radius des Zylinders +ro_c = u_c/(2*np.pi) + +# Innerer Radius des Zylinders +ri_c = ro_c - d_c + + +# Trägheitsmoment der Kugel +I_b = 2/5 * m_b * r_b**2 + +# Trägheitsmoment des Zylinders +I_c = 1/2 * m_c * (ro_c**2 + ri_c**2) + +print("Trägheitsmoment (Kugel)") +print(I_b) + +print("Trägheitsmoment (Zylinder)") +print(I_c) + + +# Berechnung der Rollzeiten aus den Messwerten der Frames und Framerate +t_b = (Ff_b - Fi_b)/fps +t_c = (Ff_c - Fi_c)/fps + +# Berechnung des Mittelwerts für die Zeitdauer t für jede (dreifach gemessene) Höhe + +t_b_mean = t_b.reshape(-1,3).mean(axis=1) +h_b_mean = h_b.reshape(-1,3)[:,0] +t_c_mean = t_c.reshape(-1,3).mean(axis=1) +h_c_mean = h_c.reshape(-1,3)[:,0] + +# Ausgabe verarbeiteten der Messwerte + +print("Messwerte (Kugel)") +print("alle Zeiten") +print(t_b) +print("alle Höhen") +print(h_b) +print("Höhe") +print(h_b_mean) +print("gemittlelte Zeit") +print(t_b_mean) +print("\n") + + +print("Messwerte (Zylinder)") +print("alle Höhen") +print(h_c) +print("alle Zeiten") +print(t_c) +print("Höhe") +print(h_c_mean) +print("gemittlelte Zeit") +print(t_c_mean) + + +# Erstelle Plots der Messwerte t_._mean und h_._mean + +# Kommentar: +# Funktionen für die Funktionsgleichungen der Theorie-Funktionen +# +# In Funktionen können Variablen verwendet werden, die außerhalb (global) definiert wurden +# wie hier: l, ri_c und ro_c +# Solche globalen Variablen können bei größeren Skripten/Programmen zu einem Problem werden +# es ist also zumindest Vorsicht geboten + +def theory_t_ball(h): + return np.sqrt(7/5 * 1/h * 2* l**2/9.81) + +def theory_t_cylinder(h): + return np.sqrt((3 + ri_c**2/ro_c**2) * l**2/9.81 * 1/h) + +# Kommentar: +# Die Werte für h die im Plot der Theorie-Funktionen verwendet werden, damit diese +# auch tatsächlich aussieht wie eine differenzierbare Funktion. +# Der Bereich in dem diese Werte liegen entspricht, aber dem der Messwerte ca. [0.03, 0.33] + +h_plot = np.linspace(0.03, 0.33, 205) + + +# Kommentar: +# Erstellen einer figure mit einem subplot darin (1 Zeile x 1 Spalte an subplots) + +fig, ax = plt.subplots(1, 1, layout="constrained") + +# Kommentar: +# Einstellung der Achsenbeschriftungen + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.plot(h_b_mean, t_b_mean, "k+", label="Daten: Kugel") +# Kommentar: +# Darstellen der Messwerte mit Legendeneintrag +ax.plot(h_plot, theory_t_ball(h_plot), label="Theorie") +ax.legend() +fig.savefig("plot_kugel.pdf") + + + +# Kommentar: +# Erstellen einer figure mit einem subplot darin (1 Zeile x 1 Spalte an subplots) + +fig, ax = plt.subplots(1, 1, layout="constrained") + +# Kommentar: +# Einstellung der Achsenbeschriftungen + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + +# Kommentar: +# Darstellen der Messwerte mit Legendeneintrag + +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Zylinder") +ax.plot(h_plot, theory_t_cylinder(h_plot), label="Theorie") +ax.legend() +fig.savefig("plot_zylinder.pdf") + diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Bahn.txt b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..bc860551 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l +80 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..72cb5208 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,Fi,Ff, +4.5,436,492 +4.5,555,610 +4.5,672,729 +10,95,130 +10,199,235 +10,303,338 +15,91,119 +15,201,229 +15,335,362 +20,232,256 +20,323,347 +20,397,421 +25,153,174 +25,239,260 +25,322,343 +30,219,238 +30,319,338 +30,391,412 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..245c87d2 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,21 @@ +#h,Fi,Ff +4.5,1018,1083 +4.5,1189,1248 +4.5,1340,1404 +10,596,636 +10,762,801 +10,882,921 +15,574,605 +15,766,798 +15,863,896 +20,679,707 +20,810,838 +20,930,959 +25,650,674 +25,892,917 +25,804,827 +30,642,664 +30,739,760 +30,900,922 +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Kamera.txt b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..1b429402 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps +30 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Kugel.txt b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..1dc033ed --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,U +216,30.5 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Zylinder.txt b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..6ba4a540 --- /dev/null +++ b/exercises-toolbox/3-matplotlib/report-example/loesung/v16515/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,U,d +186,24.3,3 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/4-scipy/report-example/aufgabe.txt b/exercises-toolbox/4-scipy/report-example/aufgabe.txt new file mode 100644 index 00000000..2447217a --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/aufgabe.txt @@ -0,0 +1,35 @@ +# Realistisches Beispiel Protokoll + +Einleitung: +Um dieser Aufgabe sinnvoll folgen zu können sollte diese von Anfang an bearbeitet werden. Folgt den +Anweisungen in den 'aufgabe.txt' Dateien im Ordner 'Realistisches-Beispiel-Protokoll', beginnend +im Aufgabenordner '1-python'. + + +Aufgabe: +Mit den Informationen zu scipy könnt ihr nun die Theorie-Funktionen aus der letzten Aufgabe +zu Fit-Funktionen abändern und so physikalische Größen als Fit-Parameter bestimmen. + +1. Ändert die Theorie-Funktionen aus der letzten Aufgabe zu Fit-Funktionen, diese benötigen + zusätzliche Argumente für die Fit-Parameter. Und diese Fit-Parameter müssen auch in der + Funktion verwendet werden. Konkret: + - Die Fallbeschleunigung g die in der letzten Aufgabe als 9.81 angenommen wurde, ist jetzt ein + Fit-Parameter g. + - Außerdem ist noch ein weiterer Parameter t0 nötig, wie ihr dem finalen Beispielprotokoll entnehmen könnt. + +2. Importiert die Funktion curve_fit aus scipy.optimize. + +3. Für jede der beiden Messreihen: + Verwendet curve_fit, um aus den gemittelten Messwerten für Höhe und Zeit die beiden Fit-Parameter + zu berechnen. + +4. Gebt die Parameter mit ihrer zugehörigen Unsicherheit auf das Terminal aus. + +5. Entfernt die Theorie-Funktionen aus den Plots und fügt stattdessen die Fit-Funktionen + mit den berechneten Parametern hinzu. + +6. Im finalen Beispielprotokoll wurden auch das Trägheitsmoment der Objekte durch einen weiteren + Fit bestimmt (dabei ist dann der Theoriewert von g anzunehmen). + Ergänzt die notwendigen Fit-Funktionen und Plots für diesen Auswertungsschritt in dem ihr die + vorangegangenen Schritte für diesen Fit wiederholt. + diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/auswertung.py b/exercises-toolbox/4-scipy/report-example/loesung/v16515/auswertung.py new file mode 100644 index 00000000..db624544 --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/auswertung.py @@ -0,0 +1,269 @@ +import numpy as np + +import matplotlib.pyplot as plt + +# Kommentar: +# Importiere curve_fit aus scipy.optimize +from scipy.optimize import curve_fit +from scipy.constants import physical_constants + +# Länge der schiefen Ebene +l = np.genfromtxt("data/Messwerte_Bahn.txt", delimiter=",")/100 # m + +# Framerate der Kamera +fps = np.genfromtxt("data/Messwerte_Kamera.txt", delimiter=",") # 1/s + +# Masse und Umfang der Kugel +m_b, u_b = np.genfromtxt("data/Messwerte_Kugel.txt", delimiter=",", unpack=True) +m_b = m_b/1000 # kg +u_b = u_b/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Kugel) +h_b, Fi_b, Ff_b = np.genfromtxt("data/Messwerte_Frames_Kugel.txt", delimiter=",", unpack=True) +h_b = h_b/100 # m + +# Masse und Umfang des Zylinders +m_c, u_c, d_c = np.genfromtxt("data/Messwerte_Zylinder.txt", delimiter=",", unpack=True) +m_c = m_c/1000 # kg +u_c = u_c/100 # m +d_c = d_c/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Zylinder) +h_c, Fi_c, Ff_c = np.genfromtxt("data/Messwerte_Frames_Zylinder.txt", delimiter=",", unpack=True) +h_c = h_c/100 # m + + +# Berechnung der benötigten Größen: Radius und Trägheitsmoment + +# Radius der Kugel +r_b = u_b/(2*np.pi) + +# Äußerer Radius des Zylinders +ro_c = u_c/(2*np.pi) + +# Innerer Radius des Zylinders +ri_c = ro_c - d_c + + +# Trägheitsmoment der Kugel +I_b = 2/5 * m_b * r_b**2 + +# Trägheitsmoment des Zylinders +I_c = 1/2 * m_c * (ro_c**2 + ri_c**2) + +print("Trägheitsmoment (Kugel)") +print(I_b) + +print("Trägheitsmoment (Zylinder)") +print(I_c) + + +# Berechnung der Rollzeiten aus den Messwerten der Frames und Framerate +t_b = (Ff_b - Fi_b)/fps +t_c = (Ff_c - Fi_c)/fps + +# Berechnung des Mittelwerts für die Zeitdauer t für jede (dreifach gemessene) Höhe + +t_b_mean = t_b.reshape(-1,3).mean(axis=1) +h_b_mean = h_b.reshape(-1,3)[:,0] +t_c_mean = t_c.reshape(-1,3).mean(axis=1) +h_c_mean = h_c.reshape(-1,3)[:,0] + +# Ausgabe verarbeiteten der Messwerte + +print("Messwerte (Kugel)") +print("alle Zeiten") +print(t_b) +print("alle Höhen") +print(h_b) +print("Höhe") +print(h_b_mean) +print("gemittlelte Zeit") +print(t_b_mean) +print("\n") + + +print("Messwerte (Zylinder)") +print("alle Höhen") +print(h_c) +print("alle Zeiten") +print(t_c) +print("Höhe") +print(h_c_mean) +print("gemittlelte Zeit") +print(t_c_mean) +print("\n") + +# Erstelle Plots der Messwerte t_._mean und h_._mean + + +# Kommentar: +# Umwandeln der Theorie-Funktion zu einer Fit-Funktion: +# Die Funktion erhält ein zusätzliches Argument für jeden Fitparameter, hier: g und t0 +# diese müssen auch in der Funktion verwendet werden. +# +# Namen sind wie immer beliebig und es gibt nicht "den einen richtigen Namen", +# aber es bietet sich wie immer an sprechende Namen zu verwenden, hier z.B. +# "fit_g_ball" als Abkürzung für "Fitfunktion für den Parameter g aus den Messwerten für die Kugel" + +def fit_g_ball(h, g, t0): + return np.sqrt(7/5 * 1/h * 2* l**2/g) + t0 + +def fit_g_cylinder(h, g, t0): + return np.sqrt((3 + ri_c**2/ro_c**2) * l**2/g * 1/h) + t0 + + +# Kommentar: +# Hier ist Vorsicht geboten, da die Fit-Funktion und Messwerte zusammen passen müssen +# an solchen Stellen zahlt sich eine konsistente Benennung aus. +# Berechnung der Fitparameter für die Kugel +params, covariance_matrix = curve_fit(fit_g_ball, h_b_mean, t_b_mean) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +# Kommentar: +# Ansehnliche Ausgabe der Parameter aufs Terminal +print("Fitparameter (Kugel)") +for name, value, uncertainty in zip("gt", params, param_uncertainties): + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + +h_plot = np.linspace(0.03, 0.33, 205) + + +# Fit Parameter für den Zylinder + + +fig, ax = plt.subplots(1, 1, layout="constrained") + + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +# Kommentar: +# Theorie-Funktion durch Fit-Funktion mit Fit-Parametern ersetzen + +ax.plot(h_b_mean, t_b_mean, "k+", label="Daten: Kugel") +ax.plot(h_plot, fit_g_ball(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-g_kugel.pdf") + + + +# Kommentar: +# Analog für die Messreihe des Zylinders +# Achtung! Copy-and-paste ist natürlich gängige Praxis, +# aber alle Variablen müssen angepasst werden. + +# Berechnung der Fitparameter für den Zylinder +params, covariance_matrix = curve_fit(fit_g_cylinder, h_c_mean, t_c_mean) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Zylinder)") +for name, value, uncertainty in zip("gt", params, param_uncertainties): + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Zylinder") +ax.plot(h_plot, fit_g_cylinder(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-g_zylinder.pdf") + + + +# Kommentar: +# Verwenden der physikalischen Konstanten aus scipy +# hier: g +# physical_constants enthält 3er-tuple, der erste Eintrag +# der tuple ist der Wert der Konstante, deswegen [0] + +def fit_I_ball(h, I, t0): + g = physical_constants["standard acceleration of gravity"][0] + return np.sqrt(2/g * 1/h * l**2 * (1 + I/(m_b * r_b**2)) ) + t0 + + +def fit_I_cylinder(h, I, t0): + g = physical_constants["standard acceleration of gravity"][0] + return np.sqrt(2/g * 1/h * l**2 * (1 + I/(m_c * ro_c**2) )) + t0 + + +# Kommentar: +# Durch den Fit wird diese Warnung auf das Terminal ausgegeben: +# .../v16515/auswertung.py:197: RuntimeWarning: invalid value encountered in sqrt +# return np.sqrt(2/g * 1/h * l**2 * (1 + I/(m_c * ro_c**2) )) + t0 +# +# Diese bedeutet, dass während des Fits negative Werte für I 'ausprobiert' wurden, +# von denen die Wurzel nicht berechnet werden konnte. +# Man kann das verhindern, in dem man die Parameter auf den physikalisch möglichen +# Bereich einschränkt. Dies tut man mit dem zusätzlichen Parameter bounds für curve_fit, +# hier müsste +# bounds=([0,-np.inf],[+np.inf,+np.inf]) +# als zusätzliches Argument für curve_fit ergänzt werden. +# bounds gibt den minimalen und den maximalen Wert für alle Parameter an, +# und zwar zuerst alle Minima und dann alle Maxima, +# in diesem konkreten Beispiel steht bounds also für: 0 < I < +np.inf und -np.inf < t0 < +np.inf + + +# Berechnung der Fitparameter für die Kugel +params, covariance_matrix = curve_fit(fit_I_ball, h_b_mean, t_b_mean) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Kugel)") +for name, value, uncertainty in zip("It", params, param_uncertainties): + # in kg*m² sehr klein, umwandlung zu kg*cm² + if name == "I": + value *= 10000 + uncertainty *= 10000 + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Kugel") +ax.plot(h_plot, fit_I_cylinder(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-I_kugel.pdf") + + +# Berechnung der Fitparameter für den Zylinder +params, covariance_matrix = curve_fit(fit_I_cylinder, h_c_mean, t_c_mean) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Zylinder)") +for name, value, uncertainty in zip("It", params, param_uncertainties): + # in kg*m² sehr klein, umwandlung zu kg*cm² + if name == "I": + value *= 10000 + uncertainty *= 10000 + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + + +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Zylinder") +ax.plot(h_plot, fit_I_cylinder(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-I_zylinder.pdf") diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Bahn.txt b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..bc860551 --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l +80 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..72cb5208 --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,Fi,Ff, +4.5,436,492 +4.5,555,610 +4.5,672,729 +10,95,130 +10,199,235 +10,303,338 +15,91,119 +15,201,229 +15,335,362 +20,232,256 +20,323,347 +20,397,421 +25,153,174 +25,239,260 +25,322,343 +30,219,238 +30,319,338 +30,391,412 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..245c87d2 --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,21 @@ +#h,Fi,Ff +4.5,1018,1083 +4.5,1189,1248 +4.5,1340,1404 +10,596,636 +10,762,801 +10,882,921 +15,574,605 +15,766,798 +15,863,896 +20,679,707 +20,810,838 +20,930,959 +25,650,674 +25,892,917 +25,804,827 +30,642,664 +30,739,760 +30,900,922 +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Kamera.txt b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..1b429402 --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps +30 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Kugel.txt b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..1dc033ed --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,U +216,30.5 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Zylinder.txt b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..6ba4a540 --- /dev/null +++ b/exercises-toolbox/4-scipy/report-example/loesung/v16515/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,U,d +186,24.3,3 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/5-uncertainties/report-example/aufgabe.txt b/exercises-toolbox/5-uncertainties/report-example/aufgabe.txt new file mode 100644 index 00000000..6a33b232 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/aufgabe.txt @@ -0,0 +1,39 @@ +# Realistisches Beispiel Protokoll + +Einleitung: +Um dieser Aufgabe sinnvoll folgen zu können sollte diese von Anfang an bearbeitet werden. Folgt den +Anweisungen in den 'aufgabe.txt' Dateien im Ordner 'Realistisches-Beispiel-Protokoll', beginnend +im Aufgabenordner '1-python'. + + +Aufgabe: +Mit den Informationen zu uncertainties könnt ihr jetzt den Umgang mit Messunsicherheiten +in die Auswertung aufnehmen. Die Messdaten im Ordner vorlage/v16516/data haben jetzt +zusätzliche Spalten mit den jeweiligen Unsicherheiten. + +1. Kopiert diese neuen Messwertdateien in euren eigenen Ordner data, um die Messwerte +mit Unsicherheiten zu haben. Die alten Dateien könnt ihr überschreiben oder vorher löschen. + +2. Importiert uncertainties und uncertainties.unumpy in eurer auswertung.py + +3. Ergänzt das Einlesen der Messdaten um die zusätzlichen Spalten mit Unsicherheiten, + eine Benennung der Form l_unc für "Unsicherheit des Messwerts l" ist hier sinnvoll + +4. Die eingelesenen Messwerte und Unsicherheiten müssen jetzt zu unsicherheitbehafteten + Messwerten zusammengefügt werden. Nutzt dafür ufloat (aus uncertainties) für einzelne Werte + und uarray (aus uncertainties.unumpy) für Messreihen. + +5. In den Fit-Funktionen müsst ihr von allen Konstanten die Unsicherheiten entfernen, + die dafür nötige Funktion heißt nominal_values und es bietet sich an diese in + abgekürzter Form zu importieren (genauso wie die Funktion std_devs): + from uncertainties.unumpy import (nominal_values as noms, std_devs as stds) + dann kann die Funktion noms() verwendet werden, um die Unsicherheit eines Wertes + zu entfernen. + +6. curve_fit kann mit Unsicherheiten nicht direkt umgehen, die unabhängige Variable + darf keine Unsicherheiten haben und den Wert bzw. die Unsicherheit + der abhängige Variable müssen getrennt übergeben werden. + +7. matplotlib kann auch nicht mit den Unsicherheiten umgehen: + Verwendet statt ax.plot die Funktion ax.errorbar um die Messwerte mit ihren + Unsicherheiten darzustellen. diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/auswertung.py b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/auswertung.py new file mode 100644 index 00000000..dda11ba7 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/auswertung.py @@ -0,0 +1,284 @@ +import numpy as np + +import matplotlib.pyplot as plt + +from scipy.optimize import curve_fit +from scipy.constants import physical_constants + + +# Kommentar: +# Importiere uncertainties unter dem Namen unc +# Importiere uncertainties.unumpy unter dem Namen unp +# Importiere der Funktionen nominal_values und std_devs +# aus uncertainties.unumpy, unter den kürzeren Namen +# noms respektive stds +import uncertainties as unc +import uncertainties.unumpy as unp +from uncertainties.unumpy import (nominal_values as noms, std_devs as stds) + + +# Kommentar: +# Die Dateien im Ordner data enthalten jetzt auch Spalten mit den Unsicherheiten +# für die meisten Messwerte. +# Beim Importieren der Daten muss beachtet werden, dass: +# (1) Messgröße und Unsicherheit jeweils eine eigene Variablennamen brauchen. +# Auch hier ist eine konsistente Benennung sinnvoll +# z.B. l (Messwerte) und l_unc (zugehörige Unsicherheiten) +# +# (2) die Unsicherheitbehafteten Messwerte noch erstellt werden müssen, +# entweder durch unc.ufloat oder durch das unp.uarray + + +# Länge der schiefen Ebene +l, l_unc = np.genfromtxt("data/Messwerte_Bahn.txt", delimiter=",")/100 # m +l = unc.ufloat(l, l_unc) + +# Framerate der Kamera (hat keine Unsicherheit, fps_unc = 0) +fps, fps_unc = np.genfromtxt("data/Messwerte_Kamera.txt", delimiter=",") # 1/s + +# Masse und Umfang der Kugel +m_b, m_b_unc, u_b, u_b_unc = np.genfromtxt("data/Messwerte_Kugel.txt", delimiter=",", unpack=True) + +m_b = unc.ufloat(m_b,m_b_unc)/1000 # kg +u_b = unc.ufloat(u_b,m_b_unc)/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Kugel) +h_b, h_b_unc, Fi_b, Fi_b_unc, Ff_b, Ff_b_unc = np.genfromtxt("data/Messwerte_Frames_Kugel.txt", delimiter=",", unpack=True) +h_b = unp.uarray(h_b, h_b_unc)/100 # m +Fi_b = unp.uarray(Fi_b, Fi_b_unc) +Ff_b = unp.uarray(Ff_b, Ff_b_unc) + + +# Masse und Umfang des Zylinders +m_c, m_c_unc, u_c, u_c_unc, d_c, d_c_unc = np.genfromtxt("data/Messwerte_Zylinder.txt", delimiter=",", unpack=True) +m_c = unc.ufloat(m_c, m_c_unc)/1000 # kg +u_c = unc.ufloat(u_c, u_c_unc)/100 # m +d_c = unc.ufloat(d_c, d_c_unc)/100 # m + +# Messreihe: Starthöhe und Startframe und Endframe (Zylinder) +h_c, h_c_unc, Fi_c, Fi_c_unc, Ff_c, Ff_c_unc = np.genfromtxt("data/Messwerte_Frames_Zylinder.txt", delimiter=",", unpack=True) +h_c = unp.uarray(h_c, h_c_unc)/100 # m +Fi_c = unp.uarray(Fi_c, Fi_c_unc) +Ff_c = unp.uarray(Ff_c, Ff_c_unc) + + + +# Kommentar: +# Die folgenden Berechnungen funktionieren alle weiterhin, nur jetzt mit automatischer Fehlerrechnung + + +# Berechnung der benötigten Größen: Radius und Trägheitsmoment + +# Radius der Kugel +r_b = u_b/(2*np.pi) + +# Äußerer Radius des Zylinders +ro_c = u_c/(2*np.pi) + +# Innerer Radius des Zylinders +ri_c = ro_c - d_c + + +# Trägheitsmoment der Kugel +I_b = 2/5 * m_b * r_b**2 + +# Trägheitsmoment des Zylinders +I_c = 1/2 * m_c * (ro_c**2 + ri_c**2) + +print("Trägheitsmoment (Kugel)") +print(I_b) + +print("Trägheitsmoment (Zylinder)") +print(I_c) + + +# Berechnung der Rollzeiten aus den Messwerten der Frames und Framerate +t_b = (Ff_b - Fi_b)/fps +t_c = (Ff_c - Fi_c)/fps + +# Berechnung des Mittelwerts für die Zeitdauer t für jede (dreifach gemessene) Höhe + +t_b_mean = t_b.reshape(-1,3).mean(axis=1) +h_b_mean = h_b.reshape(-1,3)[:,0] +t_c_mean = t_c.reshape(-1,3).mean(axis=1) +h_c_mean = h_c.reshape(-1,3)[:,0] + +# Ausgabe verarbeiteten der Messwerte + +print("Messwerte (Kugel)") +print("alle Zeiten") +print(t_b) +print("alle Höhen") +print(h_b) +print("Höhe") +print(h_b_mean) +print("gemittlelte Zeit") +print(t_b_mean) +print("\n") + + +print("Messwerte (Zylinder)") +print("alle Höhen") +print(h_c) +print("alle Zeiten") +print(t_c) +print("Höhe") +print(h_c_mean) +print("gemittlelte Zeit") +print(t_c_mean) +print("\n") + +# Erstelle Plots der Messwerte t_._mean und h_._mean + + +# Kommentar: +# Nur für die Erstellung der Plots und Fits ändert sich etwas: +# Weder scipy noch matplotlib können direkt mit den unsicherheitbehafteten +# Messwerten umgehen. +# Folgendes muss dafür geändert werden: +# +# (1) in der Fitfunktion müssen mit der Funktion noms() +# die Unsicherheiten von Konstanten entfernt werden +# +# (2) mit Unsicherheiten der unabhängigen Variable kann curve_fit nicht umgehen, +# diese müssen mit noms() entfernt werden. +# +# (3) die Werte und Unsicherheiten der abhängigen Variable (gemessene Funktionswerte) +# müssen getrennt übergeben werden: noms() und stds() +# +# (4) die Darstellung der Messwerte im Plot wird durch errorbar() ersetzt, +# um die Unsicherheiten anzeigen zu können +# +# In der Aufgabe 3-curve_fit muss eine Funktion ucurve_fit geschrieben werden, +# die die scipy Funktion curve_fit verwendet, die aber den Umgang mit den +# Unsicherheiten abstrahiert, sodass man das nicht jedes Mal aufs neue machen muss. + + + +def fit_g_ball(h, g, t0): + return np.sqrt(7/5 * 1/h * 2* noms(l)**2/g) + t0 + +def fit_g_cylinder(h, g, t0): + return np.sqrt((3 + noms(ri_c**2/ro_c**2)) * noms(l)**2/g * 1/h) + t0 + + +params, covariance_matrix = curve_fit(fit_g_ball, noms(h_b_mean), noms(t_b_mean), sigma=stds(t_b_mean)) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Kugel)") +for name, value, uncertainty in zip("gt", params, param_uncertainties): + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + +h_plot = np.linspace(0.03, 0.33, 205) + + +# Fitparameter für den Zylinder + + +fig, ax = plt.subplots(1, 1, layout="constrained") + + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + + +ax.errorbar(noms(h_b_mean), noms(t_b_mean), yerr=stds(t_b_mean), fmt="k+", label="Daten: Kugel") +ax.plot(h_plot, fit_g_ball(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-g_kugel.pdf") + + + + +# Berechnung der Fitparameter für den Zylinder +params, covariance_matrix = curve_fit(fit_g_cylinder, noms(h_c_mean), noms(t_c_mean), sigma=stds(t_c_mean)) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Zylinder)") +for name, value, uncertainty in zip("gt", params, param_uncertainties): + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.errorbar(noms(h_c_mean), noms(t_c_mean), yerr=stds(t_c_mean), fmt="k+", label="Daten: Zylinder") +ax.plot(h_plot, fit_g_cylinder(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-g_zylinder.pdf") + + + + +def fit_I_ball(h, I, t0): + g = physical_constants["standard acceleration of gravity"][0] + return np.sqrt(2/g * 1/h * noms(l)**2 * (1 + I/(noms(m_b * r_b)**2)) ) + t0 + + +def fit_I_cylinder(h, I, t0): + g = physical_constants["standard acceleration of gravity"][0] + return np.sqrt(2/g * 1/h * noms(l)**2 * (1 + I/(noms(m_c * ro_c**2)) )) + t0 + + +# Berechnung der Fitparameter für die Kugel +params, covariance_matrix = curve_fit(fit_I_ball, noms(h_b_mean), noms(t_b_mean), sigma=stds(t_b_mean)) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Kugel)") +for name, value, uncertainty in zip("It", params, param_uncertainties): + # in kg*m² sehr klein, umwandlung zu kg*cm² + if name == "I": + value *= 10000 + uncertainty *= 10000 + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.errorbar(noms(h_b_mean), noms(t_b_mean), yerr=stds(t_b_mean), fmt="k+", label="Daten: Kugel") +ax.plot(h_plot, fit_I_cylinder(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-I_kugel.pdf") + + +# Berechnung der Fitparameter für den Zylinder +params, covariance_matrix = curve_fit(fit_I_cylinder, noms(h_c_mean), noms(t_c_mean), sigma=stds(t_c_mean)) +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) + + +print("Fitparameter (Zylinder)") +for name, value, uncertainty in zip("It", params, param_uncertainties): + # in kg*m² sehr klein, umwandlung zu kg*cm² + if name == "I": + value *= 10000 + uncertainty *= 10000 + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") +print("\n") + + + +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.set_xlabel("$h$ / m") +ax.set_ylabel("$t$ / s") + + +ax.errorbar(noms(h_c_mean), noms(t_c_mean), yerr=stds(t_c_mean), fmt="k+", label="Daten: Zylinder") +ax.plot(h_plot, fit_I_cylinder(h_plot, *params), label="Fit") +ax.legend() +fig.savefig("plot-I_zylinder.pdf") diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Bahn.txt b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..cc6a4720 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l,sigma_l +80,0.5 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..91bc58b6 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,sigma_h,Fi,sigma_Fi,Ff,sigma_Ff +4.5,0.5,436,1,492,1 +4.5,0.5,555,1,610,1 +4.5,0.5,672,1,729,1 +10,0.5,95,1,130,1 +10,0.5,199,1,235,1 +10,0.5,303,1,338,1 +15,0.5,91,1,119,1 +15,0.5,201,1,229,1 +15,0.5,335,1,362,1 +20,0.5,232,1,256,1 +20,0.5,323,1,347,1 +20,0.5,397,1,421,1 +25,0.5,153,1,174,1 +25,0.5,239,1,260,1 +25,0.5,322,1,343,1 +30,0.5,219,1,238,1 +30,0.5,319,1,338,1 +30,0.5,391,1,412,1 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..2321d313 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,22 @@ +# h,sigma_h,Fi,sigma_Fi,Ff,sigma_Ff +4.5,0.5,1018,1,1083,1 +4.5,0.5,1189,1,1248,1 +4.5,0.5,1340,1,1404,1 +10,0.5,596,1,636,1 +10,0.5,762,1,801,1 +10,0.5,882,1,921,1 +15,0.5,574,1,605,1 +15,0.5,766,1,798,1 +15,0.5,863,1,896,1 +20,0.5,679,1,707,1 +20,0.5,810,1,838,1 +20,0.5,930,1,959,1 +25,0.5,650,1,674,1 +25,0.5,892,1,917,1 +25,0.5,804,1,827,1 +30,0.5,642,1,664,1 +30,0.5,739,1,760,1 +30,0.5,900,1,922,1 + +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Kamera.txt b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..add88808 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps,sigma_fps +30,0 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Kugel.txt b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..48b54cb9 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,sigma_m,U,sigma_U +216,1,30.5,0.1 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Zylinder.txt b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..d9d19ddf --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/loesung/v16516/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,sigma_m,U,sigma_U,d,sigma_d +186,1,24.3,0.1,3,1 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Bahn.txt b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..cc6a4720 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l,sigma_l +80,0.5 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..91bc58b6 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,sigma_h,Fi,sigma_Fi,Ff,sigma_Ff +4.5,0.5,436,1,492,1 +4.5,0.5,555,1,610,1 +4.5,0.5,672,1,729,1 +10,0.5,95,1,130,1 +10,0.5,199,1,235,1 +10,0.5,303,1,338,1 +15,0.5,91,1,119,1 +15,0.5,201,1,229,1 +15,0.5,335,1,362,1 +20,0.5,232,1,256,1 +20,0.5,323,1,347,1 +20,0.5,397,1,421,1 +25,0.5,153,1,174,1 +25,0.5,239,1,260,1 +25,0.5,322,1,343,1 +30,0.5,219,1,238,1 +30,0.5,319,1,338,1 +30,0.5,391,1,412,1 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..2321d313 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,22 @@ +# h,sigma_h,Fi,sigma_Fi,Ff,sigma_Ff +4.5,0.5,1018,1,1083,1 +4.5,0.5,1189,1,1248,1 +4.5,0.5,1340,1,1404,1 +10,0.5,596,1,636,1 +10,0.5,762,1,801,1 +10,0.5,882,1,921,1 +15,0.5,574,1,605,1 +15,0.5,766,1,798,1 +15,0.5,863,1,896,1 +20,0.5,679,1,707,1 +20,0.5,810,1,838,1 +20,0.5,930,1,959,1 +25,0.5,650,1,674,1 +25,0.5,892,1,917,1 +25,0.5,804,1,827,1 +30,0.5,642,1,664,1 +30,0.5,739,1,760,1 +30,0.5,900,1,922,1 + +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Kamera.txt b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..add88808 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps,sigma_fps +30,0 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Kugel.txt b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..48b54cb9 --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,sigma_m,U,sigma_U +216,1,30.5,0.1 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Zylinder.txt b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..d9d19ddf --- /dev/null +++ b/exercises-toolbox/5-uncertainties/report-example/vorlage/v16516/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,sigma_m,U,sigma_U,d,sigma_d +186,1,24.3,0.1,3,1 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/7-git/report-example/aufgabe.txt b/exercises-toolbox/7-git/report-example/aufgabe.txt new file mode 100644 index 00000000..c16906de --- /dev/null +++ b/exercises-toolbox/7-git/report-example/aufgabe.txt @@ -0,0 +1,42 @@ +# Realistisches Beispiel Protokoll + +Einleitung: +Um dieser Aufgabe sinnvoll folgen zu können sollte diese von Anfang an bearbeitet werden. Folgt den +Anweisungen in den 'aufgabe.txt' Dateien im Ordner 'Realistisches-Beispiel-Protokoll', beginnend +im Aufgabenordner '1-python'. + + +Aufgabe: +Diesmal arbeitet ihr nicht am Protokoll weiter. Das Ziel soll es sein, euren bisherigen (und zukünftigen) Fortschritt +am Beispielprotokoll in einem Git-Repository zu speichern und auf Github hochzuladen. + +1) Erstellt in dem Ordner, in dem ihr den Ordner v16516 für diese Aufgabe gespeichert habt +einen neuen Ordner (z.B. Beispiel-Praktikum). + +2) Verschiebt den Ordner v16516 in den neuen Ordner Beispiel-Praktikum. + +3) Navigiert mit dem Terminal in den neuen Ordner und initialisiert in diesem ein Git-Repository (init). + +4) Fügt alle Dateien zum Repository hinzu (add, commit). + +Repository auf Github hochladen: + +5) Erstellt euch einen Github-Account, falls ihr noch keinen habt. + +6) Navigiert zu https://github.com/dashboard. Erstellt über den Button "New" ein neues Repository. + Für diese Aufgabe müsst ihr dem Repository nur einen Namen geben, alle optionalen Einstellungen könnt ihr + unverändert lassen. + Nach dem Erstellen werden euch drei Möglichkeiten vorgeschlagen fortzufahren, da wir bereits einen + Repository auf dem Computer haben wählen wir die dritte Option: + "…or push an existing repository from the command line" + git remote add origin git@github.com:/.git + git branch -M main + git push -u origin main + +7) Navigiert mit dem Terminal in euer Beispiel-Praktikum Git-Repository und gebt die drei obigen + Befehle ein, am besten durch Kopieren aus dem Browser. + +8) Schaut euch euer Repository auf https://github.com/ an. + + + diff --git a/exercises-toolbox/8-all/report-example/Makefile-loesung b/exercises-toolbox/8-all/report-example/Makefile-loesung new file mode 100644 index 00000000..615f1166 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/Makefile-loesung @@ -0,0 +1,2 @@ +all: + $(MAKE) -C loesung diff --git a/exercises-toolbox/8-all/report-example/loesung/Makefile b/exercises-toolbox/8-all/report-example/loesung/Makefile new file mode 100644 index 00000000..554db107 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/Makefile @@ -0,0 +1,7 @@ +all: + $(MAKE) -C v16516 + +clean: + $(MAKE) -C v16516 clean + +.PHONY: all cleanX diff --git a/exercises-toolbox/8-all/report-example/loesung/README.md b/exercises-toolbox/8-all/report-example/loesung/README.md new file mode 100644 index 00000000..671fb24a --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/README.md @@ -0,0 +1,12 @@ +# Vorlage für Praktikumsprotokolle + + +Dieser Ordner enthält die Struktur für Praktikumsprotokolle mit +allem, was in diesem Kurs besprochen wurde. + +In Basisordner liegt der LaTeX-Header, Literaturdatenbank (`lit.bib`) sowie die der LaTeX-Header für matplotlib +und die matplotlibrc. +Außerdem haben wir in `programme.bib` die korrekten Quellen für die verwendete Software angegeben. + +In dem Unterordner `vXXX` liegt dann ein Template für einen einzelnen Versuch, +welches für die jeweiligen Versuche kopiert und „ausgefüllt“ werden kann. diff --git a/exercises-toolbox/8-all/report-example/loesung/header-matplotlib.tex b/exercises-toolbox/8-all/report-example/loesung/header-matplotlib.tex new file mode 100644 index 00000000..1d23aac1 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/header-matplotlib.tex @@ -0,0 +1,44 @@ +% unverzichtbare Mathe-Befehle +\usepackage{amsmath} +% viele Mathe-Symbole +\usepackage{amssymb} +% Erweiterungen für amsmath +\usepackage{mathtools} +% Fonteinstellungen +\usepackage{fontspec} +% Latin Modern Fonts werden automatisch geladen + +\usepackage[ + math-style=ISO, % ┐ + bold-style=ISO, % │ + sans-style=italic, % │ ISO-Standard folgen + nabla=upright, % │ + partial=upright, % ┘ + warnings-off={ % ┐ + mathtools-colon, % │ unnötige Warnungen ausschalten + mathtools-overbracket, % │ + }, % ┘ +]{unicode-math} + +% traditionelle Fonts für Mathematik +\setmathfont{Latin Modern Math} +\setmathfont{XITS Math}[range={scr, bfscr}] +\setmathfont{XITS Math}[range={cal, bfcal}, StylisticSet=1] + +% Zahlen und Einheiten +\usepackage[ + locale=DE, % deutsche Einstellungen + separate-uncertainty=true, % immer Unsicherheit mit \pm + per-mode=reciprocal, % ^-1 für inverse Einheiten + output-decimal-marker=., % . statt , für Dezimalzahlen +]{siunitx} + +% chemische Formeln +\usepackage[ + version=4, + math-greek=default, % ┐ mit unicode-math zusammenarbeiten + text-greek=default, % ┘ +]{mhchem} + +% schöne Brüche im Text +\usepackage{xfrac} diff --git a/exercises-toolbox/8-all/report-example/loesung/header.tex b/exercises-toolbox/8-all/report-example/loesung/header.tex new file mode 100644 index 00000000..8af6b5a9 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/header.tex @@ -0,0 +1,139 @@ +\documentclass[ + bibliography=totoc, % Literatur im Inhaltsverzeichnis + captions=tableheading, % Tabellenüberschriften + titlepage=firstiscover, % Titelseite ist Deckblatt +]{scrartcl} + +% Paket float verbessern +\usepackage{scrhack} + +% Warnung, falls nochmal kompiliert werden muss +\usepackage[aux]{rerunfilecheck} + +% unverzichtbare Mathe-Befehle +\usepackage{amsmath} +% viele Mathe-Symbole +\usepackage{amssymb} +% Erweiterungen für amsmath +\usepackage{mathtools} + +% Fonteinstellungen +\usepackage{fontspec} +% Latin Modern Fonts werden automatisch geladen +% Alternativ zum Beispiel: +%\setromanfont{Libertinus Serif} +%\setsansfont{Libertinus Sans} +%\setmonofont{Libertinus Mono} + +% Wenn man andere Schriftarten gesetzt hat, +% sollte man das Seiten-Layout neu berechnen lassen +\recalctypearea{} + +% deutsche Spracheinstellungen +\usepackage[ngerman]{babel} + + +\usepackage[ + math-style=ISO, % ┐ + bold-style=ISO, % │ + sans-style=italic, % │ ISO-Standard folgen + nabla=upright, % │ + partial=upright, % │ + mathrm=sym, % ┘ + warnings-off={ % ┐ + mathtools-colon, % │ unnötige Warnungen ausschalten + mathtools-overbracket, % │ + }, % ┘ +]{unicode-math} + +% traditionelle Fonts für Mathematik +\setmathfont{Latin Modern Math} +% Alternativ zum Beispiel: +%\setmathfont{Libertinus Math} + +\setmathfont{XITS Math}[range={scr, bfscr}] +\setmathfont{XITS Math}[range={cal, bfcal}, StylisticSet=1] + +% Zahlen und Einheiten +\usepackage[ + locale=DE, % deutsche Einstellungen + separate-uncertainty=true, % immer Unsicherheit mit \pm + per-mode=symbol-or-fraction, % / in inline math, fraction in display math +]{siunitx} + +% chemische Formeln +\usepackage[ + version=4, + math-greek=default, % ┐ mit unicode-math zusammenarbeiten + text-greek=default, % ┘ +]{mhchem} + +% richtige Anführungszeichen +\usepackage[autostyle]{csquotes} + +% schöne Brüche im Text +\usepackage{xfrac} + +% Standardplatzierung für Floats einstellen +\usepackage{float} +\floatplacement{figure}{htbp} +\floatplacement{table}{htbp} + +% Floats innerhalb einer Section halten +\usepackage[ + section, % Floats innerhalb der Section halten + below, % unterhalb der Section aber auf der selben Seite ist ok +]{placeins} + +% Seite drehen für breite Tabellen: landscape Umgebung +\usepackage{pdflscape} + +% Captions schöner machen. +\usepackage[ + labelfont=bf, % Tabelle x: Abbildung y: ist jetzt fett + font=small, % Schrift etwas kleiner als Dokument + width=0.9\textwidth, % maximale Breite einer Caption schmaler +]{caption} +% subfigure, subtable, subref +\usepackage{subcaption} + + +% Grafiken können eingebunden werden +\usepackage{graphicx} + +% schöne Tabellen +\usepackage{tabularray} +\UseTblrLibrary{booktabs,siunitx} + +% Verbesserungen am Schriftbild +\usepackage{microtype} + +% Literaturverzeichnis +\usepackage[ + backend=biber, +]{biblatex} +% Quellendatenbank +\addbibresource{lit.bib} +\addbibresource{programme.bib} + +% Hyperlinks im Dokument +\usepackage[ + german, + unicode, % Unicode in PDF-Attributen erlauben + pdfusetitle, % Titel, Autoren und Datum als PDF-Attribute + pdfcreator={}, % ┐ PDF-Attribute säubern + pdfproducer={}, % ┘ +]{hyperref} +% erweiterte Bookmarks im PDF +\usepackage{bookmark} + +% Trennung von Wörtern mit Strichen +\usepackage[shortcuts]{extdash} + +\author{% + Joshua Luckey\\% + \href{mailto:joshua.luckey@udo.edu}{joshua.luckey@udo.edu}% + \and% + PeP et al.: Toolbox Workshop\\% + \href{mailto:pep-toolbox.physik@lists.tu-dortmund.de}{pep-toolbox.physik@lists.tu-dortmund.de} +} diff --git a/exercises-toolbox/8-all/report-example/loesung/lit.bib b/exercises-toolbox/8-all/report-example/loesung/lit.bib new file mode 100644 index 00000000..f1915e13 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/lit.bib @@ -0,0 +1,23 @@ +@manual{V16516, + organization = {TU Dortmund, Fakultät Physik}, + title = {Anleitung: Versuch zur schiefen Ebene}, + year = 2023 +} + + + +@book{kuypers2016klassische, + title={Klassische Mechanik}, + author={Kuypers, Friedhelm}, + year={2016}, + publisher={John Wiley \& Sons} +} + +@online{galilei1623, +author = {Galilei, Galileo}, +title = {Il Saggiatore}, +url = {https://bibdig.museogalileo.it/tecanew/opera?bid=354802&seq=13}, +booktitle = {Le opere di Galileo Galilei}, +year = {1623} +} + diff --git a/exercises-toolbox/8-all/report-example/loesung/matplotlibrc b/exercises-toolbox/8-all/report-example/loesung/matplotlibrc new file mode 100644 index 00000000..1746ade8 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/matplotlibrc @@ -0,0 +1,23 @@ +# pgf-Backend benutzen +backend : pgf + +# Größe der Zeichenfläche in Zoll +figure.figsize : 5.78, 3.57 +figure.constrained_layout.use : True + +# Serifenfont benutzen +font.family : serif + +# Fontgrößen +font.size : 11 +legend.fontsize : medium +xtick.labelsize : 9 +ytick.labelsize : 9 + +# unsere Fonteinstellungen benutzen +pgf.rcfonts : False + +# TeX benutzen +text.usetex : True +pgf.texsystem : lualatex +pgf.preamble : \input{header-matplotlib.tex} diff --git a/exercises-toolbox/8-all/report-example/loesung/programme.bib b/exercises-toolbox/8-all/report-example/loesung/programme.bib new file mode 100644 index 00000000..efe7aa60 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/programme.bib @@ -0,0 +1,72 @@ +@article{matplotlib, + author = "Hunter, John D.", + title = "{Matplotlib}: A {2D} Graphics Environment", + publisher = "IEEE", + year = "2007", + journal = "Computing in Science \& Engineering", + volume = "9", + number = "3", + pages = "90--95", + url = "http://matplotlib.org/", + version = "1.4.3", + doi = {10.1109/MCSE.2007.55}, + addendum = {Current version 3.8.0, \textsc{doi}: \href{https://zenodo.org/record/8347255}{\texttt{10.5281/zenodo.8347255}}} +} + +% taken from https://numpy.org/citing-numpy/ but replaced the key 'harris2020array' with 'numpy' +% to keep the neccessary changes to this file +@article{ numpy, + title = {Array programming with {NumPy}}, + author = {Charles R. Harris and K. Jarrod Millman and St{\'{e}}fan J. + van der Walt and Ralf Gommers and Pauli Virtanen and David + Cournapeau and Eric Wieser and Julian Taylor and Sebastian + Berg and Nathaniel J. Smith and Robert Kern and Matti Picus + and Stephan Hoyer and Marten H. van Kerkwijk and Matthew + Brett and Allan Haldane and Jaime Fern{\'{a}}ndez del + R{\'{i}}o and Mark Wiebe and Pearu Peterson and Pierre + G{\'{e}}rard-Marchant and Kevin Sheppard and Tyler Reddy and + Warren Weckesser and Hameer Abbasi and Christoph Gohlke and + Travis E. Oliphant}, + year = {2020}, + month = sep, + journal = {Nature}, + volume = {585}, + number = {7825}, + pages = {357--362}, + doi = {10.1038/s41586-020-2649-2}, + publisher = {Springer Science and Business Media {LLC}}, + url = {https://doi.org/10.1038/s41586-020-2649-2} +} + +% taken from https://scipy.org/citing-scipy/ but replaced the key '2020SciPy-NMeth' with 'scipy' +% to keep the neccessary changes to this file +@article{scipy, + author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and + Haberland, Matt and Reddy, Tyler and Cournapeau, David and + Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and + Bright, Jonathan and {van der Walt}, St{\'e}fan J. and + Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and + Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and + Kern, Robert and Larson, Eric and Carey, C J and + Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and + {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and + Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and + Harris, Charles R. and Archibald, Anne M. and + Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and + {van Mulbregt}, Paul and {SciPy 1.0 Contributors}}, + title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific + Computing in Python}}, + journal = {Nature Methods}, + year = {2020}, + volume = {17}, + pages = {261--272}, + adsurl = {https://rdcu.be/b08Wh}, + doi = {10.1038/s41592-019-0686-2}, +} + +@software{uncertainties, + author = "Lebigot, Eric O.", + title = "Uncertainties: a Python package for calculations with uncertainties", + url = "http://pythonhosted.org/uncertainties/", + version = "3.1.7" +} diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/Makefile b/exercises-toolbox/8-all/report-example/loesung/v16516/Makefile new file mode 100644 index 00000000..3ee00846 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/Makefile @@ -0,0 +1,82 @@ +all: build/v16516.pdf + +# hier Python-Skripte: +build/plot-g_ball.pdf: auswertung.py ../matplotlibrc ../header-matplotlib.tex data/*| build + # so that matplotlib can find the tex header when running + # LaTeX in the tmp directory + # and set the matplotlibrc + TEXINPUTS=$$(pwd)/..: MATPLOTLIBRC=../matplotlibrc python auswertung.py + +build/parameter-g_ball.tex: build/plot-g_ball.pdf +build/parameter-t0-g_ball.tex: build/parameter-g_ball.tex + +build/plot-g_cylinder.pdf: build/parameter-t0-g_ball.tex +build/parameter-g_cylinder.tex: build/plot-g_cylinder.pdf +build/parameter-t0-g_cylinder.tex: build/parameter-g_cylinder.tex + +build/plot-I_ball.pdf: build/parameter-g_cylinder.tex +build/parameter-I_ball.tex: build/plot-I_ball.pdf +build/parameter-t0-I_ball.tex: build/parameter-I_ball.tex + +build/plot-I_cylinder.pdf: build/parameter-t0-I_ball.tex +build/parameter-I_cylinder.tex: build/plot-I_cylinder.pdf +build/parameter-t0-I_cylinder.tex: build/parameter-I_cylinder.tex + +build/table_all-measurements.tex: build/parameter-t0-I_cylinder.tex +build/table_averaged-measurements.tex: build/table_all-measurements.tex +build/tracklength.tex: build/table_averaged-measurements.tex +build/framerate.tex: build/tracklength.tex +build/mass_ball.tex: build/framerate.tex +build/radius_ball.tex: build/mass_ball.tex +build/theoretical-I_ball.tex: build/radius_ball.tex +build/mass_cylinder.tex: build/theoretical-I_ball.tex +build/radius-inner_cylinder.tex: build/mass_cylinder.tex +build/radius-outer_cylinder.tex: build/radius-inner_cylinder.tex +build/theoretical-I_cylinder.tex: build/radius-outer_cylinder.tex + +# hier weitere Abhängigkeiten für build/vXXX.pdf deklarieren: +build/v16516.pdf: build/plot-g_ball.pdf +build/v16516.pdf: build/parameter-g_ball.tex +build/v16516.pdf: build/parameter-t0-g_ball.tex +build/v16516.pdf: build/plot-g_cylinder.pdf +build/v16516.pdf: build/parameter-g_cylinder.tex +build/v16516.pdf: build/parameter-t0-g_cylinder.tex +build/v16516.pdf: build/plot-I_ball.pdf +build/v16516.pdf: build/parameter-I_ball.tex +build/v16516.pdf: build/parameter-t0-I_ball.tex +build/v16516.pdf: build/plot-I_cylinder.pdf +build/v16516.pdf: build/parameter-I_cylinder.tex +build/v16516.pdf: build/parameter-t0-I_cylinder.tex +build/v16516.pdf: build/framerate.tex +build/v16516.pdf: build/theoretical-I_ball.tex +build/v16516.pdf: build/theoretical-I_cylinder.tex +build/v16516.pdf: build/tracklength.tex +build/v16516.pdf: build/mass_ball.tex +build/v16516.pdf: build/mass_cylinder.tex +build/v16516.pdf: build/radius_ball.tex +build/v16516.pdf: build/radius-inner_cylinder.tex +build/v16516.pdf: build/radius-outer_cylinder.tex +build/v16516.pdf: build/table_all-measurements.tex +build/v16516.pdf: build/table_averaged-measurements.tex + +build/v16516.pdf: FORCE | build + # to find header and bib files in the main directory + TEXINPUTS=..: \ + BIBINPUTS=..: \ + max_print_line=1048576 \ + latexmk \ + --lualatex \ + --output-directory=build \ + --interaction=nonstopmode \ + --halt-on-error \ + v16516.tex + +build: + mkdir -p build + +clean: + rm -rf build + +FORCE: + +.PHONY: all clean diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/auswertung.py b/exercises-toolbox/8-all/report-example/loesung/v16516/auswertung.py new file mode 100644 index 00000000..9b5eced9 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/auswertung.py @@ -0,0 +1,416 @@ +import matplotlib.pyplot as plt +import numpy as np +import scipy.optimize +import scipy.constants + + +import uncertainties as unc +import uncertainties.unumpy as unp +from uncertainties.unumpy import ( + nominal_values as noms, + std_devs as stds, +) + +from curve_fit import ucurve_fit +from latex_formatting import make_qty + + +# Load all data files +camera = np.genfromtxt("data/Messwerte_Kamera.txt", names=True, delimiter=",") +track = np.genfromtxt("data/Messwerte_Bahn.txt", names=True, delimiter=",") +ball = np.genfromtxt("data/Messwerte_Kugel.txt", names=True, delimiter=",") +cylinder = np.genfromtxt("data/Messwerte_Zylinder.txt", names=True, delimiter=",") +measurements_ball = np.genfromtxt("data/Messwerte_Frames_Kugel.txt", names=True, delimiter=",") +measurements_cylinder = np.genfromtxt("data/Messwerte_Frames_Zylinder.txt", names=True, delimiter=",") + + +# overview of raw data +print("Übersicht der (rohen) Messwerte") +print("Kamera Einstellungen") +print(camera.dtype.names) +print(camera) +print("Bahn Eigenschaften") +print(track.dtype.names) +print(track) +print("Ball Eigenschaften") +print(ball.dtype.names) +print(ball) +print("Zylinder Eigenschaften") +print(cylinder.dtype.names) +print(cylinder) +print("Messreihe: Ball") +print(measurements_ball.dtype.names) +print(measurements_ball) +print("Messreihe: Zylinder") +print(measurements_cylinder.dtype.names) +print(measurements_cylinder) +print("-"*70,end="\n\n") + + +# create data with uncertainties and SI-Units + +framerate = camera["fps"] # frame/s +L = track_length = unc.ufloat(track["l"],track["sigma_l"])/100 # m + +m_B = ball_mass = unc.ufloat(ball["m"],ball["sigma_m"])/1000 # kg +U_B = ball_perimeter = unc.ufloat(ball["U"],ball["sigma_U"])/100 #m +R_B = ball_radius = ball_perimeter / (2 * np.pi) +I_B = ball_momentinertia = 2/5 * m_B * (R_B**2) + + +h_B = heights_ball = unp.uarray(measurements_ball["h"], measurements_ball["sigma_h"])/100 # m +fi_B = initalframes_ball = unp.uarray(measurements_ball["Fi"], measurements_ball["sigma_Fi"]) # 1 +ff_B = finalframes_ball = unp.uarray(measurements_ball["Ff"], measurements_ball["sigma_Ff"]) # 1 + +t_B = durations_ball = (ff_B - fi_B) / framerate #s + + +# each height was measured 3 times => calculating the mean of these measurements +# selecting each height once +h_B = h_B.reshape(-1, 3)[:,0] +t_B = t_B.reshape(-1, 3).mean(axis=1) + + + +m_C = cylinder_mass = unc.ufloat(cylinder["m"],cylinder["sigma_m"])/1000 # kg +U_C = cylinder_perimeter = unc.ufloat(cylinder["U"],cylinder["sigma_U"])/100 #m +d_C = cylinder_thickness = unc.ufloat(cylinder["d"],cylinder["sigma_d"])/1000 #m +Ro_C = cylinder_radius_outer = cylinder_perimeter / (2 * np.pi) +Ri_C = cylinder_radius_inner = cylinder_radius_outer - cylinder_thickness +I_C = cylinder_momentinertia = 1/2 * m_C * (Ro_C**2 + Ri_C**2) + +h_C = heights_cylinder = unp.uarray(measurements_cylinder["h"], measurements_cylinder["sigma_h"])/100 # m +fi_C = initalframes_cylinder = unp.uarray(measurements_cylinder["Fi"], measurements_cylinder["sigma_Fi"]) # 1 +ff_C = finalframes_cylinder = unp.uarray(measurements_cylinder["Ff"], measurements_cylinder["sigma_Ff"]) # 1 + +t_C = durations_cylinder = (ff_C - fi_C) / framerate #s + +# each height was measured 3 times => calculating the mean of these measurements +# selecting each height once +h_C = h_C.reshape(-1, 3)[:,0] +t_C = t_C.reshape(-1, 3).mean(axis=1) + +# Part 1: determination of the gravitational constant g + + +# fitting theoretical curve to data +def fit_g_ball(h, g, t0): + return np.sqrt(7/5 * 1/h * 2* noms(L)**2/g) + t0 + +params = ucurve_fit(fit_g_ball, noms(h_B), t_B, p0=[10, 0]) + + +print("Fit Parameter (Kugel):") +print(params) + + +# plotting data an fit +h_plot = np.linspace(0.03,0.33, 1000) +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.errorbar( + noms(h_B), + noms(t_B), + yerr=stds(t_B), + fmt="k_", + label="Daten: Kugel", +) +ax.plot(h_plot, fit_g_ball(h_plot, *noms(params)), "-", label="Fit") +ax.set_xlim(h_plot[0], h_plot[-1]) +ax.set_xlabel(r"$h \mathbin{/} \unit{\meter}$") +ax.set_ylabel(r"$t \mathbin{/} \unit{\second}$") +ax.legend(loc="best") +fig.savefig("build/plot-g_ball.pdf") + +# exporting fit parameters +parameter_g, parameter_t0 = params + +with open("build/parameter-g_ball.tex", "w") as f: + f.write(make_qty(parameter_g, r"\meter\per\second\squared")) + +with open("build/parameter-t0-g_ball.tex", "w") as f: + f.write(make_qty(parameter_t0, r"\second")) + + +# fitting theoretical curve to data +def fit_g_cylinder(h, g, t0): + return np.sqrt((3 + noms(Ri_C**2/Ro_C**2)) * noms(L)**2/(g*h)) + t0 + +params = ucurve_fit(fit_g_cylinder, noms(h_C), t_C, p0=[10, 0]) + +print("Fit Parameter (Zylinder):") +print(params) + + +# plotting data an fit +h_plot = np.linspace(0.03,0.33, 1000) +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.errorbar( + noms(h_C), + noms(t_C), + yerr=stds(t_C), + fmt="k_", + label="Daten: Zylinder", +) +ax.plot(h_plot, fit_g_cylinder(h_plot, *noms(params)), "-", label="Fit") +ax.set_xlim(h_plot[0], h_plot[-1]) +ax.set_xlabel(r"$h \mathbin{/} \unit{\meter}$") +ax.set_ylabel(r"$t \mathbin{/} \unit{\second}$") +ax.legend(loc="best") +fig.savefig("build/plot-g_cylinder.pdf") + +# exporting fit parameters +parameter_g, parameter_t0 = params + +with open("build/parameter-g_cylinder.tex", "w") as f: + f.write(make_qty(parameter_g, r"\meter\per\second\squared")) + +with open("build/parameter-t0-g_cylinder.tex", "w") as f: + f.write(make_qty(parameter_t0, r"\second")) + + + +# Part 2: determination of the Moment of inertia if g is assumed to be known +g = scipy.constants.g # m/s² + + + +# fitting theoretical curve to data +def fit_I_ball(h, I, t0): + return np.sqrt(2/g * 1/h * noms(L)**2 * (1 + I/(noms(m_B) * noms(R_B)**2) )) + t0 + +params = ucurve_fit(fit_I_ball, noms(h_B), t_B, p0=[0.001, -1]) + + +print("Fit Parameter (Kugel):") +print(params) + +# plotting data an fit +h_plot = np.linspace(0.03,0.33, 1000) +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.errorbar( + noms(h_B), + noms(t_B), + yerr=stds(t_B), + fmt="k_", + label="Daten: Kugel", +) +ax.plot(h_plot, fit_I_ball(h_plot, *noms(params)), "-", label="Fit") +ax.set_xlim(h_plot[0], h_plot[-1]) +ax.set_xlabel(r"$h \mathbin{/} \unit{\meter}$") +ax.set_ylabel(r"$t \mathbin{/} \unit{\second}$") +ax.legend(loc="best") +fig.savefig("build/plot-I_ball.pdf") + +# exporting fit parameters +parameter_I, parameter_t0 = params + +with open("build/parameter-I_ball.tex", "w") as f: + f.write(make_qty(parameter_I*10000, r"\kilo\gram\centi\meter\squared"))# change units: kg cm² + +with open("build/parameter-t0-I_ball.tex", "w") as f: + f.write(make_qty(parameter_t0, r"\second")) + + +# fitting theoretical curve to data +def fit_I_cylinder(h, I, t0): + return np.sqrt(2/g * 1/h * noms(L)**2 * (1 + I/(noms(m_C) * noms(Ro_C)**2) )) + t0 + +params = ucurve_fit(fit_I_cylinder, noms(h_C), t_C, p0=[0.001, -1]) + + +print("Fit Parameter (Zylinder):") +print(params) + + +# plotting data an fit +h_plot = np.linspace(0.03,0.33, 1000) +fig, ax = plt.subplots(1, 1, layout="constrained") + +ax.errorbar( + noms(h_C), + noms(t_C), + yerr=stds(t_C), + fmt="k_", + label="Daten: Zylinder", +) +ax.plot(h_plot, fit_I_cylinder(h_plot, *noms(params)), "-", label="Fit") +ax.set_xlim(h_plot[0], h_plot[-1]) +ax.set_xlabel(r"$h \mathbin{/} \unit{\meter}$") +ax.set_ylabel(r"$t \mathbin{/} \unit{\second}$") +ax.legend(loc="best") + +fig.savefig("build/plot-I_cylinder.pdf") + +# exporting fit parameters +parameter_I, parameter_t0 = params + +with open("build/parameter-I_cylinder.tex", "w") as f: + f.write(make_qty(parameter_I*10000, r"\kilo\gram\centi\meter\squared"))# change units: kg cm² + +with open("build/parameter-t0-I_cylinder.tex", "w") as f: + f.write(make_qty(parameter_t0, r"\second")) + + +# exporting non tabular data + +with open("build/theoretical-g.tex", "w") as f: + f.write(make_qty(g,r"\meter\per\second\squared", figures=2, formatting="per-mode=reciprocal")) + +with open("build/framerate.tex", "w") as f: + f.write(make_qty(framerate, r"\per\second", figures=0, formatting="per-mode=reciprocal")) + +with open("build/theoretical-I_ball.tex", "w") as f: + f.write(make_qty(I_B*10000,r"\kilo\gram\centi\meter\squared")) # change units: kg cm² + +with open("build/theoretical-I_cylinder.tex", "w") as f: + f.write(make_qty(I_C*10000,r"\kilo\gram\centi\meter\squared"))# change units: kg cm² + +with open("build/tracklength.tex", "w") as f: + f.write(make_qty(L,r"\meter")) + +with open("build/mass_ball.tex", "w") as f: + f.write(make_qty(m_B,r"\kilo\gram")) + +with open("build/mass_cylinder.tex", "w") as f: + f.write(make_qty(m_B,r"\kilo\gram")) + +with open("build/radius_ball.tex", "w") as f: + f.write(make_qty(R_B, r"\meter")) + +with open("build/radius-inner_cylinder.tex", "w") as f: + f.write(make_qty(Ri_C,r"\meter")) + +with open("build/radius-outer_cylinder.tex", "w") as f: + f.write(make_qty(Ro_C,r"\meter")) + +# writing latex tables +# first: writing all measured values not just the averages +# heights_ball, durations_ball, durations_cylinder +# have not been reduced to 6 values each +# Columns: +# %h +# %F_i +# %F_i_sigma +# %F_f +# %F_f_sigma +# %t +# %t_sigma +# %F_i +# %F_i_sigma +# %F_f +# %F_f_sigma +# %t +# %t_sigma + + + +table_header_all = r""" + \begin{tblr}{ + colspec = { + S[table-format=1.3] + S[table-format=4.0] + S[table-format=1.0] + S[table-format=4.0] + S[table-format=1.0] + S[table-format=1.3] + S[table-format=1.3] + S[table-format=4.0] + S[table-format=1.0] + S[table-format=4.0] + S[table-format=1.0] + S[table-format=1.3] + S[table-format=1.3] + }, + row{1} = {guard}, + row{2} = {guard, mode=math}, + vline{3,5,7,9,11,13} = {2}{-}{text=\clap{\pm}}, + } + \toprule + & + \SetCell[c=6]{c} Messung: Kugel & & & & & & + \SetCell[c=6]{c} Messung: Zylinder & & & & & \\ + \cmidrule[lr]{2-7}\cmidrule[lr]{8-14} + h \mathbin{/} \unit{\meter} &% + \SetCell[c=2]{c} F_\text{i} \mathbin{/} 1 & &% + \SetCell[c=2]{c} F_\text{f} \mathbin{/} 1 & &% + \SetCell[c=2]{c} t \mathbin{/} \unit{\second} & &% + \SetCell[c=2]{c} F_\text{i} & &% + \SetCell[c=2]{c} F_\text{f} & &% + \SetCell[c=2]{c} t \mathbin{/} \unit{\second}& \\ + \midrule +""" + + +table_footer = r""" \bottomrule + \end{tblr} +""" + + +row_template = ( + r"{0.n:1.3f} & {1.n:0.0f} & {1.s:0.0f} & {2.n:0.0f} & {2.s:0.0f}& {3.n:1.3f} & {3.s:1.3f} & {4.n:0.0f} & {4.s:0.0f}& {5.n:0.0f} & {5.s:0.0f}& {6.n:1.3f} & {6.s:1.3f} \\" +) + + + +with open("build/table_all-measurements.tex", "w") as f: + f.write(table_header_all) + for row in zip(heights_ball, initalframes_ball, finalframes_ball, durations_ball, initalframes_cylinder, finalframes_cylinder, durations_cylinder): + f.write(row_template.format(*row)) + f.write("\n") + f.write(table_footer) + + +# second: writing the averaged values and leaving out the frames +# heights_ball, durations_ball, durations_cylinder +# have not been reduced to 6 values each + + +table_header_averaged = r""" + \begin{tblr}{ + colspec = { + S[table-format=1.3] + S[table-format=2.3] + S[table-format=1.4] + S[table-format=3.3] + S[table-format=1.5] + }, + row{1} = {guard}, + row{2} = {guard, mode=math}, + vline{3,5,7,9} = {2}{-}{text=\clap{\pm}}, + } + \toprule + & + \SetCell[c=2]{c} Messung: Kugel & & + \SetCell[c=2]{c} Messung: Zylinder &\\ + \cmidrule[lr]{2-3}\cmidrule[lr]{4-5} + h \mathbin{/} \unit{\meter} &% + \SetCell[c=2]{c} t \mathbin{/} \unit{\second} & &% + \SetCell[c=2]{c} t \mathbin{/} \unit{\second}& \\ + \midrule +""" + + +table_footer = r""" \bottomrule + \end{tblr} +""" + + +row_template = ( + r"{0.n:1.3f} & {1.n:1.3f} & {1.s:1.3f} & {2.n:1.3f} & {2.s:1.3f} \\" +) + + +with open("build/table_averaged-measurements.tex", "w") as f: + f.write(table_header_averaged) + for row in zip(h_B, t_B, t_C): + f.write(row_template.format(*row)) + f.write("\n") + f.write(table_footer) + + + + + diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/content/auswertung.tex b/exercises-toolbox/8-all/report-example/loesung/v16516/content/auswertung.tex new file mode 100644 index 00000000..f3f7e84f --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/content/auswertung.tex @@ -0,0 +1,112 @@ +\section{Auswertung} +\label{sec:Auswertung} +Die für diesen Versuch relevanten physikalischen Größen für Kugel und Zylinder sind: +\begin{align} + \label{eq:physical-properties} + m_\text{Z} &= \input{mass_ball.tex} & m_\text{K} &= \input{mass_ball.tex}\nonumber\\ + r_{\text{Z},\text{i}} &= \input{../build/radius-inner_cylinder.tex} & r_\text{K} &= \input{radius_ball.tex}\\ + r_{\text{Z},\text{a}} &= \input{../build/radius-outer_cylinder.tex} &&\nonumber +\end{align} +Berechnet wurde aus diesen Größen das jeweilige, theoretische Trägheitsmoment +\begin{align} + \label{eq:moments-inertia} + I_\text{Z} &= \input{./../build/theoretical-I_cylinder.tex}\quad\text{ und } & I_\text{K} = \input{./../build/theoretical-I_ball.tex}. +\end{align} +Aus den aufgenommenen Videos der Versuche wurden die in \autoref{tab:all-measurements} folgenden Frameindizes extrahiert. +Die ebenfalls aufgeführte Zeitdauer $t$ wurde dann jeweils aus der aus dem Startframeindex $F_\text{i}$, +dem Endframeindex $F_\text{f}$ und der Kameraframerate $\operatorname{fps}=\input{framerate.tex}$ wie folgt +berechnet +\begin{equation*} + t = (F_\text{f} - F_\text{i})\cdot\operatorname{fps}^{-1} +\end{equation*} + +\begin{table} + \centering + \caption{Alle aufgenommenen Werte, das heißt mit dreifach wiederholter Messungen je Höhe.} + \label{tab:all-measurements} + \input{build/table_all-measurements.tex} +\end{table} + +Durch Mittelung der Messwerte für die selbe Höhe $h$ ergeben sich die Werte +in \autoref{tab:averaged-measurements}. Diese Werte werden für die folgenden +Auswertungsschritte verwendet. + +\begin{table} + \centering + \caption{Für gleiche Starthöhe $h$ gemittelte Messwerte der Zeit $t$.} + \label{tab:averaged-measurements} + \input{build/table_averaged-measurements.tex} +\end{table} + +\subsection{Bestimmung der Fallbeschleunigung $g$} + +Für die bestimmung der Fallbeschleunigung wurden eine Ausgleichsfunktion der Form +\eqref{eq:fit-function-g-ball} respektive \eqref{eq:fit-function-g-cylinder} an die Messwerte aus \autoref{tab:averaged-measurements} +angepasst. Die Daten und Ausgleichsfunktion sind für die Kugel in \autoref{fig:fit-g-ball} +und für den Zylinder in \autoref{fig:fit-g-cylinder} graphisch dargestellt. + +\begin{figure} + \centering + \includegraphics{plot-g_ball.pdf} + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für die Kugel, + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-g-ball} für die Bestimmung der Fallbeschleunigung $g$. + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-g_ball} angegeben.} + \label{fig:fit-g-ball} +\end{figure} + +\begin{figure} + \centering + \includegraphics{plot-g_cylinder.pdf} + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für den Zylinder, + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-g-cylinder} für die Bestimmung der Fallbeschleunigung $g$. + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-g_cylinder} angegeben.} + \label{fig:fit-g-cylinder} +\end{figure} + +Die Parameter der Ausgleichsrechnung ergeben sich für die Kugel zu +\begin{align} + \label{eq:parameters-g_ball} + g_\text{K} &= \input{parameter-g_ball.tex}\quad\text{ und } & t_{0,\text{K}} &= \input{parameter-t0-g_ball.tex} +\intertext{und für den Zylinder} + \label{eq:parameters-g_cylinder} + g_\text{Z} &= \input{parameter-g_cylinder.tex}\quad\text{ und } & t_{0,\text{Z}} &= \input{parameter-t0-g_cylinder.tex}. +\end{align} + +\subsection{Bestimmung der Trägheitsmomente $I$} + +Für die bestimmung der Fallbeschleunigung wurden eine Ausgleichsfunktion der Form +\eqref{eq:fit-function-I} an die Messwerte aus \autoref{tab:averaged-measurements} +angepasst. Die Daten und Ausgleichsfunktion sind für die Kugel in \autoref{fig:fit-I-ball} +und für den Zylinder in \autoref{fig:fit-I-cylinder} graphisch dargestellt. + + +\begin{figure} + \centering + \includegraphics{plot-I_ball.pdf} + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für den Kugel, + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-I} für die Bestimmung des Trägheitsmoments $I_\text{K}$. + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-I_ball} angegeben.} + \label{fig:fit-I-ball} +\end{figure} + + +\begin{figure} + \centering + \includegraphics{plot-I_cylinder.pdf} + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für den Zylinder, + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-I} für die Bestimmung des Trägheitsmoments $I_\text{Z}$. + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-I_cylinder} angegeben.} + \label{fig:fit-I-cylinder} +\end{figure} + +Die Parameter der Ausgleichsrechnung ergeben sich für die Kugel zu +\begin{align} + \label{eq:parameters-I_ball} + I_\text{K} &= \input{parameter-I_ball.tex}\quad\text{ und } &t_{0,\text{K}} &= \input{parameter-t0-I_ball.tex} + \intertext{und für den Zylinder} + \label{eq:parameters-I_cylinder} + I_\text{Z} &= \input{parameter-I_cylinder.tex}\quad\text{ und } & t_{0,\text{Z}} &= \input{parameter-t0-I_cylinder.tex}. +\end{align} + + + diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/content/diskussion.tex b/exercises-toolbox/8-all/report-example/loesung/v16516/content/diskussion.tex new file mode 100644 index 00000000..deea3f31 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/content/diskussion.tex @@ -0,0 +1,46 @@ +\section{Diskussion} +\label{sec:Diskussion} + + +TODO: Diskussion fertig machen ;-) + +Notizen: + +Bestimmung von g: + +Fits + +\autoref{fig:fit-g-ball} + +\autoref{fig:fit-g-cylinder} + +passen zu den Messwerten. + + +Die Fit parameter +\eqref{eq:parameters-g_ball} +\eqref{eq:parameters-g_cylinder} + +passen zum theoretischen Wert \input{theoretical-g.tex} +=> TODO: Abweichungen berechnen + +Die übereinstimmung der Fitparameter t0, weist auf eine systematische Unsicherheit +=> TODO: Berechnung des Offsets in Frames + +Analog für die Bestimmung von I: + +Fits: + +\autoref{fig:fit-I-ball} + +\autoref{fig:fit-I-cylinder} + +\eqref{eq:parameters-I_ball} + +\eqref{eq:parameters-I_cylinder} + +\eqref{eq:moments-inertia} + +=> TODO: Abweichungen berechnen + + diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/content/durchfuehrung.tex b/exercises-toolbox/8-all/report-example/loesung/v16516/content/durchfuehrung.tex new file mode 100644 index 00000000..090bea1a --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/content/durchfuehrung.tex @@ -0,0 +1,22 @@ +\section{Durchführung} +\label{sec:Durchführung} + +Wie in der Anleitung~\cite{V16516} beschrieben, wird der Versuch wie folgt durchgeführt. + +Wie einst von Galileo Galilei \cite[232]{galilei1623} persönlich, wurden im hier beschriebenen Versuch +Objekte (eine Kugel und Holzylinder in Form eines Glases) eine schiefe Ebene hinab gerollt. + +Notiert wird dabei die Starthöhen $h$. Der Prozess des Herabrollens wird mit einer Kamera +aufgezeichnet, um aus der Zeit $t$ bis zum erreichen des Endes der schiefen Ebene möglichst genau +aus den Einzelbildern (frames) des Films ablesen zu können. + +Die aufgenommenen Messdaten werden für zwei unabhängige Zwecke verwendet: + +\begin{enumerate} + \item {Bestimmung der Fallbeschleunigung $g$, dafür werden + die theoretischen Trägheitsmomente angenommen.} + \item {Bestimmung der Trägheitsmomente $I$ der beiden Objekte unter Annahme der theoretischen + Fallbeschleunigung.} +\end{enumerate} + + diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/content/theorie.tex b/exercises-toolbox/8-all/report-example/loesung/v16516/content/theorie.tex new file mode 100644 index 00000000..0ef332cf --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/content/theorie.tex @@ -0,0 +1,80 @@ +\section{Theorie} +\label{sec:Theorie} + + + +Wie in der Abbildung \autoref{fig:experimental-setup} veranschaulicht, beginnen die Objekte +in einer Höhe $h$ auf der schiefen Ebene in vollkommener Ruhe. + + +\begin{figure} + \centering + \begin{tikzpicture}[scale=3] + \draw (0,0) -- (3,0) --node[below, near end]{$l$} (0,1) -- cycle; + \draw (0.25,1.19)node[below]{$m$} circle (0.25cm); + \draw[->] (0.25,1.19) -- (0.90, 0.94) node[above] {\small$\vec{v}$}; + \draw[|-|] (-0.15,0.95) -- node[left]{$h$} (-0.15, 0); + \draw[dashed,opacity=0.65] (0.94,0.96) circle (0.25cm); + \draw[dashed,opacity=0.40] (1.75,0.68) circle (0.25cm); + \draw[dashed,opacity=0.25] (3.,0.26) circle (0.25cm); + \draw[->] (0.25, 1.03) arc (270:50:0.16) node[below]{\small$\omega$}; + \end{tikzpicture} + \caption{Schematische Darstellung des Versuchsaufbaus. Das runde Objekt (Kugel oder Zylinder) wird in der Höhe $h$ + auf eine schiefe Ebene gelegt, sodass es aus der Ruhe herabrollt. Die Bewegung ist beschleunigt, sodass sowohl + die Geschwindigkeit $\vec{v}(t)$ sowie die Winkelgeschwindigkeit $\omega(t)$ nicht konstant sind.} + \label{fig:experimental-setup} +\end{figure} + + + +Zwischen Ebene und Objekten wirkt eine nicht zu vernachlässigende Reibung, wodurch die +Objekte nach dem loslassen in Rotation versetzt werden, also tatsächlich herabrollen. +Thermische Reibungsverluste werden jedoch vernächlässigt, sodass Energieerhaltung +angenommen werden kann. Nach dieser gilt + +\begin{align*} +E^\text{pot}_\text{i} &= E^\text{kin}_\text{f} + E^\text{rot}_\text{f} \\ +mgh &= \frac{m}{2}v^2 + \frac{I}{2}\omega^2 \quad\big|\,\omega = \frac{v}{r} \\ +mgh &= \frac{m}{2}v^2 + \frac{I}{2}\frac{v^2}{r^2}\quad\big|\, :mgh \\ +1 &= \frac{v^2}{2gh} \left(1 + \frac{I}{mr^2} \right)\\ + \intertext{aus der Kinematik~\cite{kuypers2016klassische} ist bekannt, dass die Endgeschwindigkeit einer +beschleunigten Bewegung (in der Zeit $t$, entlang einer Strecke $l$) $v = \frac{2l}{t}$ ist. +Es gilt also} +1 &= \left(\frac{2l}{t}\right)^2 \frac{1}{2gh} \left(1 + \frac{I}{mr^2} \right)\quad\big|\, \cdot t^2 \\ +\addtocounter{equation}{1} +t^2 &= \frac{2l^2}{gh} \left(1 + \frac{I}{mr^2} \right)\label{eq:tsquared}\tag{\theequation} +\end{align*} + +Aus \eqref{eq:tsquared} ergeben sich dann die jeweiligen Ausgleichsfunktionen für beide Versuchsteile. + +Für die Bestimmung der Trägheitsmomente wird nur noch die Quadratwurzel von \eqref{eq:tsquared} +berechnet und ein Startzeit als Parameter hinzugefügt, + +\begin{equation} +t(h) = \sqrt{\frac{2l^2}{gh} \left(1 + \frac{I}{mr^2} \right)} + t_0. +\label{eq:fit-function-I} +\end{equation} + +Dabei sind das Trägheitsmoment $I$ und die Startzeit $t_0$ die Parameter für die Ausgleichsrechnung. +Die notwendigen physikalischen Größen der Objekte sind in \autoref{sec:Auswertung} angegeben. + +Für die Bestimmung der Gravitationsbeschleunigung $g$ unter Annahme der theoretischen Trägheitsmomente +für Kugel $I_\text{K}$ und Hohlzylinder $I_\text{Z}$ +\begin{align} + I_{\text{K}} = \frac{2}{5}mr_{\text{K}}^2 && I_{\text{Z}} = \frac{m}{2}(r_{\text{Z},\text{innen}}^2 + r_{\text{Z},\text{außen}}^2), +\end{align} +ergeben sich die folgenden Ausgleichsfunktionen + +\begin{align} +t_\text{K}(h) &= \sqrt{\frac{2l^2}{gh} \left(\frac{7}{5}\right)} + t_0 +\label{eq:fit-function-g-ball} +% +\intertext{und} +% +t_\text{Z}(h) &= \sqrt{\frac{l^2}{gh} \left(3 + \left(\frac{r_{\text{Z},\text{innen}}}{r_{\text{Z},\text{außen}}}\right)^2 \right)} + t_0. +\label{eq:fit-function-g-cylinder} +\end{align} +Dabei sind in diesen Gleichungen $g$ und $t_0$ die Ausgleichsparameter. + + + diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/curve_fit.py b/exercises-toolbox/8-all/report-example/loesung/v16516/curve_fit.py new file mode 100644 index 00000000..2da5e3dc --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/curve_fit.py @@ -0,0 +1,29 @@ +import numpy as np +import scipy.optimize +import uncertainties as unc +import uncertainties.unumpy as unp + + +def ucurve_fit(f, x, y, **kwargs): + """ + Uncertainties wrapper around curve_fit + y can be a uarray with uncertainties + and the parameters are returned as uncertainties.correlated_values + """ + if np.any(unp.std_devs(y) == 0): + sigma = None + abs_sigma = False + else: + sigma = unp.std_devs(y) + abs_sigma = True + + popt, pcov = scipy.optimize.curve_fit( + f, + x, + unp.nominal_values(y), + sigma=sigma, + absolute_sigma=abs_sigma, + **kwargs, + ) + + return unc.correlated_values(popt, pcov) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Bahn.txt b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Bahn.txt new file mode 100644 index 00000000..cc6a4720 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l,sigma_l +80,0.5 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..91bc58b6 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Frames_Kugel.txt @@ -0,0 +1,21 @@ +# h,sigma_h,Fi,sigma_Fi,Ff,sigma_Ff +4.5,0.5,436,1,492,1 +4.5,0.5,555,1,610,1 +4.5,0.5,672,1,729,1 +10,0.5,95,1,130,1 +10,0.5,199,1,235,1 +10,0.5,303,1,338,1 +15,0.5,91,1,119,1 +15,0.5,201,1,229,1 +15,0.5,335,1,362,1 +20,0.5,232,1,256,1 +20,0.5,323,1,347,1 +20,0.5,397,1,421,1 +25,0.5,153,1,174,1 +25,0.5,239,1,260,1 +25,0.5,322,1,343,1 +30,0.5,219,1,238,1 +30,0.5,319,1,338,1 +30,0.5,391,1,412,1 +# Messreihe: Kugel +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..2321d313 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Frames_Zylinder.txt @@ -0,0 +1,22 @@ +# h,sigma_h,Fi,sigma_Fi,Ff,sigma_Ff +4.5,0.5,1018,1,1083,1 +4.5,0.5,1189,1,1248,1 +4.5,0.5,1340,1,1404,1 +10,0.5,596,1,636,1 +10,0.5,762,1,801,1 +10,0.5,882,1,921,1 +15,0.5,574,1,605,1 +15,0.5,766,1,798,1 +15,0.5,863,1,896,1 +20,0.5,679,1,707,1 +20,0.5,810,1,838,1 +20,0.5,930,1,959,1 +25,0.5,650,1,674,1 +25,0.5,892,1,917,1 +25,0.5,804,1,827,1 +30,0.5,642,1,664,1 +30,0.5,739,1,760,1 +30,0.5,900,1,922,1 + +# Messreihe: Zylinder +# Höhe(h/cm), Startframe(Fi/1), Endframe(Ff/1) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Kamera.txt b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Kamera.txt new file mode 100644 index 00000000..add88808 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps,sigma_fps +30,0 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Kugel.txt b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Kugel.txt new file mode 100644 index 00000000..48b54cb9 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Kugel.txt @@ -0,0 +1,5 @@ +#m,sigma_m,U,sigma_U +216,1,30.5,0.1 + +# Messdaten der Kugel: Vollkugel +# Umfang (U/cm), Masse (m/g) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Zylinder.txt b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Zylinder.txt new file mode 100644 index 00000000..d9d19ddf --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/data/Messwerte_Zylinder.txt @@ -0,0 +1,5 @@ +#m,sigma_m,U,sigma_U,d,sigma_d +186,1,24.3,0.1,3,1 + +# Messdaten des Zylinders: Hohlzylinder mit Boden aber ohne Deckel +# Umfang (U/cm), Masse (m/g), Wanddicke (Differenz zwischen Innen- und Außenradius) (d/mm) diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/latex_formatting.py b/exercises-toolbox/8-all/report-example/loesung/v16516/latex_formatting.py new file mode 100644 index 00000000..61069449 --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/latex_formatting.py @@ -0,0 +1,23 @@ +import numpy as np +from uncertainties.unumpy import ( + std_devs as stds, +) + +def make_qty(num, unit, exp="", figures=None, formatting=None): + """Format an uncertainties ufloat as a \qty quantity""" + if np.any(stds([num])): + if figures is None: + figures = "" + x = f"{num:.{figures:}uf}".replace("/", "") + else: + x = f"{num:.{figures:}f}" + if exp and not str(exp).startswith('e'): + exp = 'e' + str(exp) + if formatting: + return rf"\qty[{formatting}]{{{x}{exp}}}{{{unit}}}" + + return rf"\qty{{{x}{exp}}}{{{unit}}}" + + + + diff --git a/exercises-toolbox/8-all/report-example/loesung/v16516/v16516.tex b/exercises-toolbox/8-all/report-example/loesung/v16516/v16516.tex new file mode 100644 index 00000000..0cc9914b --- /dev/null +++ b/exercises-toolbox/8-all/report-example/loesung/v16516/v16516.tex @@ -0,0 +1,26 @@ +\input{header.tex} +\usepackage{tikz} + +\subject{V16516} +\title{Die schiefe Ebene} +\date{% + Durchführung: 29.09.2023 + \hspace{3em} + Abgabe: 23.09.2024 +} + +\begin{document} + +\maketitle +\thispagestyle{empty} +\tableofcontents +\newpage + +\input{content/theorie.tex} +\input{content/durchfuehrung.tex} +\input{content/auswertung.tex} +\input{content/diskussion.tex} + +\printbibliography{} + +\end{document}