diff --git a/exercises-toolbox/8-all/example-report/Makefile-loesung b/exercises-toolbox/8-all/example-report/Makefile-loesung new file mode 100644 index 00000000..423fc6fb --- /dev/null +++ b/exercises-toolbox/8-all/example-report/Makefile-loesung @@ -0,0 +1,213 @@ +datafilenames = Messwerte_Bahn.txt \ +Messwerte_Frames_Kugel.txt \ +Messwerte_Frames_Zylinder.txt \ +Messwerte_Kamera.txt \ +Messwerte_Kugel.txt \ +Messwerte_Zylinder.txt + +advanced_mpl_filenames = matplotlibrc header-matplotlib.tex + +steps = 01 02 03 04 05 06 07 08 09 10 11 + +### Directories + +# build/example-report-step-{01,...,11}/ +step_dirs = $(foreach step, $(steps),build/example-report-step-$(step)/) + +# build/example-report-step-{01,...,11}/loesung +solution_dirs = $(addsuffix loesung/, $(step_dirs)) + + +# build/example-report-step-{06,...,11}/loesung/v16516/ +report_dirs = $(addsuffix v16516/, $(wordlist 6,11,$(solution_dirs))) + +# build/example-report-step-{01,05}/data/ +step_data_dirs = $(addsuffix data/, $(word 1,$(step_dirs)) $(word 5,$(step_dirs))) + +# build/example-report-step-{01,...,05}/loesung/data/ +solution_data_dirs = $(addsuffix data/, $(wordlist 1,5,$(solution_dirs))) + +# build/example-report-step-{06,...,11}/loesung/v16516/data +report_data_dirs = $(addsuffix data/, $(report_dirs)) + +# all */data dirs +data_dirs = $(solution_data_dirs) $(report_data_dirs) $(step_data_dirs) +data_dirs_without_unc = $(wordlist 1,4,$(data_dirs)) $(word 12,$(data_dirs)) +data_dirs_with_unc = $(wordlist 5,11,$(data_dirs)) $(word 13,$(data_dirs)) + +# build/example-report-step-{09,...,10}/loesung/v16516/graphics/ +graphics_dirs = $(addsuffix v16516/graphics/, $(wordlist 9,10,$(solution_dirs))) $(addsuffix graphics/, $(word 9,$(step_dirs))) + +# solution_dirs containing tex files +solution_dirs_with_tex = $(wordlist 7,11,$(solution_dirs)) +#build/example-report-step-{07,...,11}/loesung/v16516/content/ +content_dirs = $(addsuffix v16516/content/, $(solution_dirs_with_tex)) + +### Taskfiles + +task_files = $(addsuffix aufgabe.txt,$(step_dirs)) + +### Datafiles + +append_datafilenames = $(foreach filename,$(datafilenames),$(addsuffix $(filename), $(1))) + +data_files_without_unc = $(call append_datafilenames,$(data_dirs_without_unc)) +data_files_with_unc = $(call append_datafilenames, $(data_dirs_with_unc)) +data_files = $(data_files_without_unc) $(data_files_with_unc) + +### Python files +solution_python_files = $(addsuffix auswertung.py, $(wordlist 1,5,$(solution_dirs))) +report_python_files = $(addsuffix auswertung.py, $(report_dirs)) +python_files = $(solution_python_files) $(report_python_files) + +### LaTeX Files +header_tex_files=$(addsuffix header.tex, $(solution_dirs_with_tex)) +main_tex_files= $(addsuffix v16516/v16516.tex, $(solution_dirs_with_tex)) +implementation_tex_files=$(addsuffix durchfuehrung.tex, $(content_dirs)) +theory_tex_files=$(addsuffix theorie.tex, $(content_dirs)) +evaluation_tex_files=$(addsuffix auswertung.tex, $(content_dirs)) +discussion_tex_files=$(addsuffix diskussion.tex, $(content_dirs)) + +setup_image_files = $(addsuffix versuchsaufbau.png, $(graphics_dirs)) + +lit_bib_files = $(addsuffix lit.bib, $(wordlist 9,11,$(solution_dirs)) $(word 9,$(step_dirs))) +programms_bib_files = $(addsuffix programme.bib, $(wordlist 9,11,$(solution_dirs)) $(word 9,$(step_dirs))) +bib_files = $(lit_bib_files) $(programms_bib_files) + +matplotlibrc_files= $(addsuffix matplotlibrc, $(wordlist 10,11,$(solution_dirs)) $(word 10,$(step_dirs))) +header_matplotlib_files = $(addsuffix header-matplotlib.tex, $(wordlist 10,11,$(solution_dirs)) $(word 10,$(step_dirs))) + +advanced_mpl_files = $(matplotlibrc_files) $(header_matplotlib_files) + +tex_files = $(header_tex_files) \ + $(main_tex_files) \ + $(implementation_tex_files) \ + $(theory_tex_files) \ + $(evaluation_tex_files) \ + $(discussion_tex_files) \ + $(bib_files) \ + $(advanced_mpl_files) + +### Makefiles +solution_makefile_files = $(addsuffix Makefile-loesung, $(wordlist 2,5,$(solution_dirs))) \ + $(addsuffix v16516/Makefile-loesung, $(wordlist 6,9,$(solution_dirs))) + +target_makefile_files = $(addsuffix v16516/Makefile, $(wordlist 10,11,$(solution_dirs))) +makefile_files = $(solution_makefile_files) $(target_makefile_files) + +python_libs = $(addprefix build/example-report-step-11/loesung/v16516/, curve_fit.py latex_formatting.py) + +run: all + # Run all Makefile-loesung + set -- $(wordlist 1, 5,$(solution_dirs)); \ + for i do\ + make -C $$i -f Makefile-loesung; \ + done + # Run all Makefile-loesung in the additional subdir v16516 + set -- $(addsuffix v16516/, $(wordlist 6, 9,$(solution_dirs))); \ + for i do\ + make -C $$i -f Makefile-loesung; \ + done + # Run the Makefile in the last two steps + set -- $(addsuffix v16516/, $(wordlist 10, 11,$(solution_dirs))); \ + for i do\ + make -C $$i -f Makefile; \ + done + # copy the final report into the first step_dir + cp $(addsuffix v16516/build/v16516.pdf,$(word 11, $(solution_dirs))) $(addsuffix v16516.pdf,$(word 1, $(solution_dirs))) + + +all: $(task_files) \ +$(python_files) \ +$(data_files) \ +$(tex_files) \ +$(setup_image_files) \ +$(makefile_files)\ +$(python_libs) + +$(word 1, $(python_libs)): templates/curve_fit.py | $(report_dirs) + cp $< $@ + +$(word 2, $(python_libs)): templates/latex_formatting.py | $(report_dirs) + cp $< $@ + + +build/example-report-step-%/aufgabe.txt &: $(template_task_files) | $(step_dirs) + cp templates/aufgabe-step-$*.txt build/example-report-step-$*/aufgabe.txt + +copy_file_loop=set -- $(2); for i do cp $(1) $$i; done + +$(solution_makefile_files) &: templates/Makefile-loesung_template | $(solution_dirs) $(report_dirs) + python generate-step-files.py -t $< -s 2 $(addprefix -o=,$(solution_makefile_files)) + +$(target_makefile_files) &: templates/Makefile | $(report_dirs) + $(call copy_file_loop, $<, $(target_makefile_files)) + +$(matplotlibrc_files) &: templates/matplotlibrc | $(solution_dirs) + $(call copy_file_loop, $<,$(matplotlibrc_files)) + +$(programms_bib_files) &: templates/programme.bib | $(solution_dirs) + $(call copy_file_loop, $<, $(programms_bib_files)) + +$(lit_bib_files) &: templates/lit.bib | $(solution_dirs) + $(call copy_file_loop, $<, $(lit_bib_files)) + +$(setup_image_files) &: templates/versuchsaufbau.png | $(graphics_dirs) + $(call copy_file_loop, $<, $(setup_image_files)) + +$(header_matplotlib_files) &: templates/header-matplotlib.tex | $(solution_dirs) + $(call copy_file_loop, $<, $(header_matplotlib_files)) + +$(header_tex_files) &: templates/latex/header_tex_template | $(solution_dirs) + python generate-step-files.py -t $< -s 7 $(addprefix -o=,$(header_tex_files)) + +$(main_tex_files) &: templates/latex/v16516_tex_template | $(content_dirs) + python generate-step-files.py -t $< -s 7 $(addprefix -o=,$(main_tex_files)) + +$(theory_tex_files) &: templates/latex/theorie_tex_template | $(content_dirs) + python generate-step-files.py -t $< -s 7 $(addprefix -o=,$(theory_tex_files)) + +$(implementation_tex_files) &: templates/latex/durchfuehrung_tex_template | $(content_dirs) + python generate-step-files.py -t $< -s 7 $(addprefix -o=,$(implementation_tex_files)) + +$(evaluation_tex_files) &: templates/latex/auswertung_tex_template | $(content_dirs) + python generate-step-files.py -t $< -s 7 $(addprefix -o=,$(evaluation_tex_files)) + +$(discussion_tex_files) &: templates/latex/diskussion_tex_template | $(content_dirs) + python generate-step-files.py -t $< -s 7 $(addprefix -o=,$(discussion_tex_files)) + +$(python_files) &: templates/auswertung_py_template | $(solution_dirs) $(report_dirs) + touch build/example-report-step-01/loesung/auswertung.py + python generate-step-files.py -t templates/auswertung_py_template $(addprefix -o=,$(python_files)) + + +copy_dir_loop=set -- $(2); for i do cp -r $(1) $$i; done +$(data_files_without_unc) &: templates/data_without_uncertainties/* | $(solution_dirs) $(report_dirs) + $(call copy_dir_loop, templates/data_without_uncertainties, $(data_dirs_without_unc)) + +$(data_files_with_unc) &: templates/data_with_uncertainties/* | $(solution_dirs) $(report_dirs) + $(call copy_dir_loop, templates/data_with_uncertainties, $(data_dirs_with_unc)) + +$(content_dirs) &:|$(report_dirs) + mkdir -p $(content_dirs) + +$(graphics_dirs)&: |$(report_dirs) + mkdir -p $(graphics_dirs) + +$(report_dirs)&: | $(solution_dirs) + mkdir -p $(report_dirs) + +$(solution_dirs) &: | $(step_dirs) + mkdir -p $(solution_dirs) + +$(step_dirs): | build + mkdir -p $(step_dirs) + +build: + mkdir -p build + +clean: + rm -r build + +.PHONY: all clean + diff --git a/exercises-toolbox/8-all/example-report/generate-step-files.py b/exercises-toolbox/8-all/example-report/generate-step-files.py new file mode 100644 index 00000000..72fbedf1 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/generate-step-files.py @@ -0,0 +1,151 @@ +import argparse +import re +import sys +from collections import defaultdict +from dataclasses import dataclass +from collections.abc import Iterable + +STEPRANGEREGEX = re.compile(r"(?:#|%)\s*<(\d*)(-(\d*)|)>") + +@dataclass +class Templateline: + linenumber: int + line: str + output_file_indices: Iterable + pattern: str + + def __str__(self): + pattern_length = len(self.pattern) + indicies = f"{self.output_file_indices[0]},...,{self.output_file_indices[-1]}" + # magic number 10: the amount of padding necessary to print a pattern with two two-digit numbers + return f"({self.pattern} → [{indicies}]) {" "*(10-pattern_length)} {self.linenumber:>3} {self.line}" + + +def setup_arg_parser(): + parser = argparse.ArgumentParser( + prog="generate-step-files", + description="Generate multiple (step)files containing lines from a template file", + epilog='') + + parser.add_argument('-v', '--verbose', action='store_true', + help="Get info on parsed args, the step maximum steprange in the template and to be removed lines.") + parser.add_argument('-n', '--dry-run', action='store_true', + help="Print the content of each output file to stdout instead of generating any files.") + # This option allows to use the same step numbering in differnt independent files + parser.add_argument('-s', '--start-step', type=int, default=1, + help="Set the step that should be considered step 1 for this file") + parser.add_argument('-t','--template_filepath', dest='template_filepath', required=True, + help="Filepath to the template file.") + parser.add_argument('-o', '--output_filepaths', dest='output_filepaths', action="append", required=True, + help="Filepaths to the output files (you need to use one Option -o for each file). Hint: use -o=file{1,2,3} for example, to generate the multiple options.)") + return parser + +def parse_lines_and_stepranges(lines, start_step, end_step): + template_lines = [] + removed_lines = [] + for i,l in enumerate(lines, start=1): + found = STEPRANGEREGEX.search(l) + + # a line containing no pattern will not be saved to any output file, hence 'removed' + if found is None: + removed_lines.append(Templateline(i,l, [], "")) + continue + groups = found.groups() + + try: + lower_step_limit = int(groups[0]) + except ValueError: + raise ValueError(f"The pattern ({found.group()}) in line {i} of the template file has not starting step.") + + # Since the end_step is calculated from the number of output files given + # the lower index has to be changed to be less then the upper index + lower_index = lower_step_limit - start_step + if lower_index < 0: + raise ValueError(f"The given star_step {start_step} is higher then the lower limit in the pattern '{found.group()}' in line {i} of the template file.") + + # The dash and second number can be omitted: + # e.g. <4> is equivalent to <4-4> + if (not groups[1]) and (groups[2] is None): + # To include anything the upper index has to be increased by 1 + step_limits = (lower_index, lower_index + 1) + + # If the second number is omitted but the dash is not, the upper limit is the last step: + # e.g. <4-> is equivalent to <4-10> if 10 output files are generated + elif not groups[2]: + # the number of files given is used for the upper index (it is already 1 greater then the highest possible index) + upper_index = end_step + step_limits = (lower_index, upper_index) + + # both numbers are present in the pattern + else: + upper_step_limit = int(groups[2]) + upper_index = upper_step_limit - start_step + 1 + + step_limits = (lower_index, upper_index) + + num_files_with_current_line = (step_limits[1] - step_limits[0]) + if num_files_with_current_line > end_step: + raise ValueError(f"The number of given output files is {end_step}," + f" but line {i} of the template file is expected to appear in {num_files_with_current_line} output files (pattern: {found.group()}).") + + # remove the steprange pattern and spaces between line content and pattern + line_content = STEPRANGEREGEX.sub("", l).rstrip() + template_lines.append(Templateline(i, line_content, list(range(*step_limits)), found.group())) + + return template_lines, removed_lines + + +def split_stepfile_lines(template_lines, output_filepaths): + + lines_per_stepfile = defaultdict(list) + for line in template_lines: + for step in line.output_file_indices: + lines_per_stepfile[output_filepaths[step]].append(line) + + return lines_per_stepfile + + +def main(): + parser = setup_arg_parser() + args = parser.parse_args() + + template_filepath = args.template_filepath + output_filepaths = args.output_filepaths + + + if args.verbose: + print("Input:") + print(' '.join(sys.argv)) + print("Parsed:") + print(f" - template file: {template_filepath}") + print(f" - output files: {output_filepaths}") + print(f" - start step: {args.start_step}") + + + with open(template_filepath) as fh: + template_lines = fh.readlines() + + template_lines, removed_lines = parse_lines_and_stepranges(template_lines, args.start_step, len(output_filepaths)) + + lines_per_stepfiles = split_stepfile_lines(template_lines, output_filepaths) + + if args.verbose: + print("Removed lines:") + print(f"{'\n'.join(str(rl) for rl in removed_lines)}") + print(f"Found steps: {lines_per_stepfiles.keys()}") + + + if args.dry_run: + for stepfile, lines in lines_per_stepfiles.items(): + print(f"\nOutput file '{stepfile}' with index ({output_filepaths.index(stepfile)}) would contain these lines from the template file:") + print(f"pattern → indicies{" "*9}ln line") + print(f"{"\n".join(str(l) for l in lines)}") + return + + + for stepfile, lines in lines_per_stepfiles.items(): + with open(stepfile, "w") as fh: + fh.write("\n".join(l.line for l in lines).strip()) + +if __name__ == "__main__": + main() diff --git a/exercises-toolbox/8-all/example-report/templates/Makefile b/exercises-toolbox/8-all/example-report/templates/Makefile new file mode 100644 index 00000000..f110c642 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/Makefile @@ -0,0 +1,33 @@ +all: build/v16516.pdf + +# hier Python-Skripte: +build/plot-I_kugel.pdf build/plot-I_zylinder.pdf build/plot-g_kugel.pdf build/plot-g_zylinder.pdf: auswertung.py ../matplotlibrc ../header-matplotlib.tex | 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 + +# hier weitere Abhängigkeiten für build/vXXX.pdf deklarieren: +build/v16516.pdf: build/plot-I_kugel.pdf build/plot-I_zylinder.pdf build/plot-g_kugel.pdf build/plot-g_zylinder.pdf + +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/example-report/templates/Makefile-loesung_template b/exercises-toolbox/8-all/example-report/templates/Makefile-loesung_template new file mode 100644 index 00000000..63033c54 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/Makefile-loesung_template @@ -0,0 +1,51 @@ +all: auswertung.py # <2-2> + python auswertung.py # <2-2> + +all: plot_kugel.pdf plot_zylinder.pdf # <3-3> + # <3-3> +plot_kugel.pdf plot_zylinder.pdf : auswertung.py # <3-3> + python auswertung.py # <3-3> + +clean: # <3-3> + rm plot_kugel.pdf plot_zylinder.pdf # <3-3> + +all: plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf # <4-6> + # <4-6> +plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf: auswertung.py # <4-6> + python auswertung.py # <4-6> + +clean: # <4-6> + rm plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf # <4-6> + +all: v16516.pdf plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf # <7-8> + # <7-8> +v16516.pdf: FORCE # <7-8> + latexmk --lualatex --interaction=nonstopmode --halt-on-error v16516.tex # <7-8> + # <7-8> +plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf: auswertung.py # <7-8> + python auswertung.py # <7-8> + +all: v16516.pdf # <9-9> + # <9-9> +v16516.pdf: plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf # <9-9> + # <9-9> +v16516.pdf: FORCE # <9-9> + TEXINPUTS=..: BIBINPUTS=..: latexmk --lualatex --interaction=nonstopmode --halt-on-error v16516.tex # <9-9> + # <9-9> +plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf: auswertung.py # <9-9> + python auswertung.py # <9-9> + + # <7-9> +FORCE: # <7-9> + # <7-9> +clean: # <7-9> + rm v16516.pdf v16516.aux v16516.log v16516.fdb_latexmk v16516.fls v16516.toc \ # <7-9> + plot-I_kugel.pdf plot-I_zylinder.pdf plot-g_kugel.pdf plot-g_zylinder.pdf # <7-9> + + # <2-> +.PHONY: all clean # <2-> + + + + + diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-01.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-01.txt new file mode 100644 index 00000000..b74d6388 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-01.txt @@ -0,0 +1,41 @@ +# Beispiel Protokoll + +Einleitung: +Wie der Name der Aufgabe schon verspricht, werdet ihr im Zuge dieser Aufgabenreihe ein vollständiges +und realistisches Versuchsprotokoll erstellen. Diesem Ziel werdet ihr Aufgabe für Aufgabe etwas +näher kommen können, indem ihr jeweils ein Thema des Workshops pro Aufgabe integriert. + +Diese Aufgabenreihe hat 11 Schritte: +01) Erstellen eines neuen Ordners für das Protokoll +02) Daten mit numpy einlesen und verarbeiten +03) Daten und Funktionen mit Matplotlib plotten +04) Ausgleichsrechnung mit scipy durchführen und plotten +05) Unsicherheiten mit uncertainties in die Auswertung integrieren +06) Ein git-Repository erstellen +07) Struktur des LaTeX-Dokuments erstellen +08) Mathematik im LaTeX-Dokument ergänzen +09) Ergänzen von Bildern, Tabellen, einem Literaturverzeichnis und Referenzen +10) TeX und Matplotlib Einstellungen und Makefile hinzufügen +11) Noch etwas mehr Automatisierung + +Um zu wissen, wo es hingeht, findet ihr auch in diesem Ordner schon das vollständige Protokoll zum Ansehen. +Außerdem könnt ihr aus diesem die Texte kopieren, damit ihr diese nicht vollständig abtippen müsst. + +Der Ordner loesung ist immer auf dem Stand auf dem euer Ordner nach Bearbeitung der +Aufgabe sein sollte. + + +Aufgabe: +Es geht zunächst nur um das Erstellen des Ordners in dem ihr diese Aufgabe immer weiter ergänzt. + +1) Erstellt (z.B. in einem Ordner unter ~/Documents) einen neuen Ordner mit dem Namen v16516. + Oder nutzt unsere Protokollvorlage: https://github.com/pep-dortmund/toolbox-workshop-protocol-template + In dieser Vorlage sind einige der nächsten Schritt bereits getan, lasst euch davon nicht verwirren. + +2) Kopiert den Ordner data aus diesem Aufgabenordner in den Ordner v16516. + +3) Erstellt in dem Ordner v16516 eine leere Pythondatei 'auswertung.py'. + + + + diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-02.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-02.txt new file mode 100644 index 00000000..253cb9c1 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-02.txt @@ -0,0 +1,20 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + +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/8-all/example-report/templates/aufgabe-step-03.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-03.txt new file mode 100644 index 00000000..29814ce7 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-03.txt @@ -0,0 +1,24 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + +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). + Als Wert für g könnt ihr 9.81 m/s² 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/8-all/example-report/templates/aufgabe-step-04.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-04.txt new file mode 100644 index 00000000..ed0d4197 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-04.txt @@ -0,0 +1,33 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + +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 m/s² 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 theoretische Wert 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/8-all/example-report/templates/aufgabe-step-05.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-05.txt new file mode 100644 index 00000000..399d9bbf --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-05.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 in den Unterordnern des Ordners 'example-report'. + +Aufgabe: +Mit den Informationen zu uncertainties könnt ihr jetzt den Umgang mit Messunsicherheiten +in die Auswertung aufnehmen. Die Messdaten im Ordner 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 verwenden zu können. 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/8-all/example-report/templates/aufgabe-step-06.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-06.txt new file mode 100644 index 00000000..df6af2b6 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-06.txt @@ -0,0 +1,34 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + +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. +Die ersten zwei Schritte könnt ihr überspringen, falls ihr keinen Github-Account anlegen wollt. + +1) Erstellt euch einen Github-Account und einen ssh-key für die Authentifikation (siehe git-Foliensatz). + +2) Erstellt unter eurem Github-Account ein neues Repository 'Beispiel-Praktikum'. +Das Repository könnt ihr nach Abschluss dieser Aufgabenreihe auch wieder löschen. +Readme und Lizenz (MIT) könnt ihr trotzdem mit anlegen, um gute Angewohnheiten einzuüben. + +3) Mit Github: Klont das Repository an einen Ort eurer Wahl (z.B. ~/Documents/Uni/Toolbox). + +Ohne Github: Erstellt an einem Ort eurer Wahl (z.B. ~/Documents/Uni/Toolbox) einen neuen Ordner 'Beispiel-Praktikum'. Navigiert mit dem Terminal in den Ordner 'Beispiel-Praktikum' und initialisiert in diesem ein Git-Repository. + +4) Kopiert den Ordner v16516, in dem ihr bisher diese Aufgabenreihe bearbeitet habt, in den neuen Ordner 'Beispiel-Praktikum' + +5) Erstellt in dem neuen Ordner 'Beispiel-Praktikum' eine neue Datei mit dem Namen '.gitignore'. + Schreibt in die erste Zeile dieser neuen Datei '*.pdf', damit git alle pdf-Dateien ignoriert. + Verschafft euch einen Überblick über die Dateien im git-Repository (git status) + und fügt dem Repository alle notwendigen Dateien hinzu (git add, git commit). + + Mit Github: Ladet die Änderungen auf Github hoch. + +6) Mit Github (Optional): Ihr könntet die nächsten Schritte in dieser Aufgabenreihe im Team machen + (z.B. abwechselnd) und so noch etwas Erfahrung im gemeinsamen Umgang mit git und Github sammeln. + + + diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-07.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-07.txt new file mode 100644 index 00000000..d262aed7 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-07.txt @@ -0,0 +1,36 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + + +Aufgabe: +Die Auswertung mit python ist nun erst einmal abgeschlossen. Nun wenden wir uns +dem LaTeX-Dokument zu: + +1) Erstellt im Ordner v16516 den folgenden Ordner und die folgenden Dateien. + Ordner: + - content + Dateien: + - v16516.tex + - content/durchfuehrung.tex + - content/theorie.tex + - content/auswertung.tex + - content/diskussion.tex + +2) Erstellt in dem Git-Respository (das euren Ordner v16516) enthält + eine Datei header.tex + +3) Ergänzt die zu diesem Zeitpunkt notwendigen Pakete in der Datei header.tex. + (Ihr könnt diese Datei auch aus dem Ordner loesung kopieren, aber ändert die Information zu den Autoren am Ende der Datei.) + + +4) Verwendet den Befehl \input, um die anderen tex-Dateien in die Datei v16516.tex einzufügen. + +5) Ergänzt die Überschriften für die Abschnitte in den jeweiligen tex-Dateien im Ordner content. + +6) Im Ordner loesung/v16516 findet ihr die Datei v16516.pdf. Ergänzt die übrigen Texte aus dieser Datei, + sodass euer aktuelles Protokoll genauso aussieht wie die Lösung. + +7) Nicht vergessen: Haltet euren Fortschritt mit git nach. diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-08.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-08.txt new file mode 100644 index 00000000..2d429a46 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-08.txt @@ -0,0 +1,19 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + +Aufgaben: + +1) Je nachdem welche header.tex ihr verwendet kann es nötig sein, diese um weiter Pakete zu ergänzen. +Schaut z.B. im Ordner loesung nach. + +2) Ergänzt alle mathematischen Gleichungen und Symbole. Dafür könnt ihr das finale Protokoll aus Schritt 1 + oder die Lösung für diese Aufgabe in loesung/v16516/v16516.pdf als Vorlage nehmen. + +3) Im Ordner loesung/v16516 findet ihr die Datei v16516.pdf. Ergänzt die übrigen Texte aus dieser Datei, + sodass euer aktuelles Protokoll genauso aussieht wie die Lösung. + +4) Nicht vergessen: Haltet euren Fortschritt mit git nach. + diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-09.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-09.txt new file mode 100644 index 00000000..c87f3336 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-09.txt @@ -0,0 +1,29 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + + +Aufgaben: + +1) Je nachdem welche header.tex ihr verwendet kann es nötig sein, diese um weiter Pakete zu ergänzen. +Schaut z.B. im Ordner loesung nach. + +2) Fügt eurem Order v16516 den Ordner graphics mit der enthaltenen Bilddatei hinzu. + Ergänzt das Bild für den Versuchsaufbau im Protokoll. + +3) Ergänzt die beiden Messwert-Tabellen. + +4) Fügt eurem Git-Repository die bib-Dateien lit.bib und programme.bib hinzu und ladet diese + in header.tex falls noch nicht geschehen. + +6) Ergänzt die Referenzen auf die drei Quellen. + +7) Schaut im finalen Protokoll nach welche Objekte Referenziert werden und ergänzt entsprechende + \label und Referenzen mit \autoref und \eqref + +8) Im Ordner loesung/v16516 findet ihr die Datei v16516.pdf. Ergänzt die übrigen Texte aus dieser Datei, + sodass euer aktuelles Protokoll genauso aussieht wie die Lösung. + +9) Nicht vergessen: Haltet euren Fortschritt mit git nach. diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-10.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-10.txt new file mode 100644 index 00000000..7b2f4072 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-10.txt @@ -0,0 +1,23 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + + +Aufgaben: +1) Fügt eurem Git-Repository die Dateien matplotlibrc und header-matplotlib.tex hinzu. + +2) Fügt eurem Ordner v16516 ein Makefile hinzu. Und ergänzt die notwendigen Regeln für dieses Protokoll. + (Versucht es erst selbst bevor ihr in die Lösung schaut, ihr könnt euch dabei an den Folien orientieren.) + +3) Ändert die Datei auswertung.py so ab, dass die Plots in einem Unterordner build erstellt werden. + +4) Ändert die Stellen im Protokoll an denen die Bilddateien geladen werden ebenfalls so ab, + das diese Dateien jetzt im Ordner build/ gesucht werden. + +5) Im Ordner loesung/v16516 findet ihr die Datei v16516.pdf. Ergänzt die übrigen Texte aus dieser Datei, + sodass euer aktuelles Protokoll genauso aussieht wie die Lösung. + +6) Nicht vergessen: Haltet euren Fortschritt mit git nach. + diff --git a/exercises-toolbox/8-all/example-report/templates/aufgabe-step-11.txt b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-11.txt new file mode 100644 index 00000000..3b674474 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/aufgabe-step-11.txt @@ -0,0 +1,36 @@ +# 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 in den Unterordnern des Ordners 'example-report'. + +Aufgabe: + +Die Änderung von Schritt 10 zu diesem sind etwas fortgeschrittener. Es ist bei weitem nicht notwendig, +diese von Tag Eins an im Praktikum zu verwenden. Die Änderungen sind aber nicht nur sinnvoll für die +gute wissenschaftliche Praxis (weniger manuelle Eingaben) sondern sogar etwas entlastend (weniger +manuelle Eingaben). + +Folgendes wird in diesem letzten Schritt ergänzt. Ihr könnt es selbst probieren oder einfach +den Ordner loesung ansehen, um einen Überblick zu bekommen. + +1) Python-Code der regelmäßig wiederverwendet wird lässt sich in eine Datei auslagern. + Dies wurde mit zwei Funktionen aus anderen Übungen getan: ucurve_fit und make_qty. + Diese liegen jetzt jeweils in einer zusätzlichen Pythondatei im Ordner v16516 + und werden in auswertung.py importiert. + +2) ucurve_fit vereinfacht den Umgang von curve_fit mit Unsicherheiten. + +3) make_qty hilft dabei berechnete Werte, als siunitx \qty zu formatieren. + Dies wird vor allem dafür verwendet berechnete Werte direkt in eine Datei + im build-Ordner zu schreiben. Diese Dateien können dann mit \input direkt + im LaTeX-Protokoll importiert werden, dadurch ist weniger manuelles Abtippen nötig + und das Protokoll wird reproduzierbarer. + Auch die Fit-Parameter werden auf diese Weise exportiert. + +4) Die Erstellung von Tabellen wurde halb automatisiert. Auch hier müssen die + Messwerte jetzt nicht mehr in das LaTeX-Tabellenformat abgetippt werden. + Die Spalteneinstellungen müssen jedoch weiterhin für jede Tabelle vorgenommen werden. + Als letzte Aufgabe dieser Reihe (deren Lösung beliebig komplex werden kann): + Wie könnte man die Tabellen noch weiter automatisieren? + diff --git a/exercises-toolbox/8-all/example-report/templates/auswertung_py_template b/exercises-toolbox/8-all/example-report/templates/auswertung_py_template new file mode 100644 index 00000000..110704e9 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/auswertung_py_template @@ -0,0 +1,711 @@ +# Erklärung: # <2-2> +# Importiere numpy unter dem Namen np # <2-2> +import numpy as np # <2-> + # <2-> +# Erklärung: # <3-3> +# Importiere matplotlib.pyplot unter dem Namen plt # <3-3> +import matplotlib.pyplot as plt # <3-> + # <2-> + # <2-> +# Erklärung: # <4-4> +# Importiere curve_fit aus scipy.optimize # <4-4> +from scipy.optimize import curve_fit # <4-> +from scipy.constants import physical_constants # <4-> + # <2-> + # <2-> +# Erklärung: # <5-> +# Importiere uncertainties unter dem Namen unc # <5-> +# Importiere uncertainties.unumpy unter dem Namen unp # <5-> +# Importiere der Funktionen nominal_values und std_devs # <5-> +# aus uncertainties.unumpy, unter den kürzeren Namen # <5-> +# noms respektive stds # <5-> +import uncertainties as unc # <5-> +import uncertainties.unumpy as unp # <5-> +from uncertainties.unumpy import (nominal_values as noms, std_devs as stds) # <5-> + # <2-> +from curve_fit import ucurve_fit # <11-> +from latex_formatting import make_qty # <11-> + # <11-> +# Erklärung: # <2-2> +# Die Daten liegen im Ordner 'data'. Um die Dateien einlesen # <2-2> +# zu können, reicht es deswegen nicht den Dateinamen anzugeben, # <2-2> +# es muss der gesamte Pfad ('Orderabfolge') angegeben werden: # <2-2> +# # <2-> +# Für die Datei: Messwerte_Bahn.txt also data/Messwerte_Bahn.txt # <2-2> +# # <2-2> +# Der Name der Variable in der die eingelesenen Werte gespeichert werden # <2-2> +# ist frei wählbar, es bietet sich bei 'langen' Skripten an (im Gegensatz zur Mathematik) # <2-2> +# nicht nur einbuchstabige Abkürzungen zu verwenden, um nicht die Übersicht zu verlieren. # <2-2> +# Also beispielsweise track_length statt L. Ein Kommentar zur erklären sollte aber drin sein. # <2-2> +# # <2-2> +# Es bietet sich an die Daten direkt beim Einlesen in eine sinnvolle Einheit umzuwandeln # <2-2> +# (falls nötig) und diese mit einem Kommentar zu vermerken # <2-2> + # <2-2> + # <2-2> +# Erklärung: # <5-> +# Die Dateien im Ordner data enthalten jetzt auch Spalten mit den Unsicherheiten # <5-> +# für die meisten Messwerte. # <5-> +# Beim Importieren der Daten muss beachtet werden, dass: # <5-> +# (1) Messgröße und Unsicherheit jeweils eine eigene Variablennamen brauchen. # <5-> +# Auch hier ist eine konsistente Benennung sinnvoll # <5-> +# z.B. l (Messwerte) und l_unc (zugehörige Unsicherheiten) # <5-> +# # <5-> +# (2) die Unsicherheitbehafteten Messwerte noch erstellt werden müssen, # <5-> +# entweder durch unc.ufloat oder durch das unp.uarray # <5-> + # <2-> + # <2-> +# Länge der schiefen Ebene # <2-> +l = np.genfromtxt("data/Messwerte_Bahn.txt", delimiter=",")/100 # m # <2-4> +l, l_unc = np.genfromtxt("data/Messwerte_Bahn.txt", delimiter=",", unpack=True)/100 # m # <5-> +l = unc.ufloat(l, l_unc) # <5-> + # <2-> +# Framerate der Kamera # <2-4> +# Framerate der Kamera (hat keine Unsicherheit, fps_unc = 0) # <5-> +fps = np.genfromtxt("data/Messwerte_Kamera.txt", delimiter=",") # 1/s # <2-4> +fps, fps_unc = np.genfromtxt("data/Messwerte_Kamera.txt", delimiter=",", unpack=True) # 1/s # <5-> + # <2-> +# Erklärung: # <2-2> +# Die Daten aus Dateien mit mehreren spalten muss man in einer extra Zeile skalieren # <2-2> +# Masse und Umfang der Kugel # <2-> +m_b, u_b = np.genfromtxt("data/Messwerte_Kugel.txt", delimiter=",", unpack=True) # <2-4> +m_b, m_b_unc, u_b, u_b_unc = np.genfromtxt("data/Messwerte_Kugel.txt", delimiter=",", unpack=True) # <5-> +m_b = m_b/1000 # kg # <2-4> +u_b = u_b/100 # m # <2-4> +m_b = unc.ufloat(m_b,m_b_unc)/1000 # kg # <5-> +u_b = unc.ufloat(u_b,m_b_unc)/100 # m # <5-> + # <2-> +# Messreihe: Starthöhe und Startframe und Endframe (Kugel) # <2-> +h_b, Fi_b, Ff_b = np.genfromtxt("data/Messwerte_Frames_Kugel.txt", delimiter=",", unpack=True) # <2-4> +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) # <5-> +h_b = h_b/100 # m # <2-4> +h_b = unp.uarray(h_b, h_b_unc)/100 # m # <5-> +Fi_b = unp.uarray(Fi_b, Fi_b_unc) # <5-> +Ff_b = unp.uarray(Ff_b, Ff_b_unc) # <5-> + # <2-> + # <2-> +# Masse und Umfang des Zylinders # <2-> +m_c, u_c, d_c = np.genfromtxt("data/Messwerte_Zylinder.txt", delimiter=",", unpack=True) # <2-4> +m_c, m_c_unc, u_c, u_c_unc, d_c, d_c_unc = np.genfromtxt("data/Messwerte_Zylinder.txt", delimiter=",", unpack=True) # <5-> +m_c = m_c/1000 # kg # <2-4> +u_c = u_c/100 # m # <2-4> +d_c = d_c/100 # m # <2-4> +m_c = unc.ufloat(m_c, m_c_unc)/1000 # kg # <5-> +u_c = unc.ufloat(u_c, u_c_unc)/100 # m # <5-> +d_c = unc.ufloat(d_c, d_c_unc)/100 # m # <5-> + # <2-> +# Messreihe: Starthöhe und Startframe und Endframe (Zylinder) # <2-> +h_c, Fi_c, Ff_c = np.genfromtxt("data/Messwerte_Frames_Zylinder.txt", delimiter=",", unpack=True) # <2-4> +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) # <5-> +h_c = h_c/100 # m # <2-4> +h_c = unp.uarray(h_c, h_c_unc)/100 # m # <5-> +Fi_c = unp.uarray(Fi_c, Fi_c_unc) # <5-> +Ff_c = unp.uarray(Ff_c, Ff_c_unc) # <5-> + # <2-> +# Erklärung: # <2-2> +# Ein gewisses Maß an Struktur in der Benennung von Variablen hilft bei der Orientierung, # <2-2> +# gerade in der Zusammenarbeit mit euren jeweiligen Partnern. # <2-2> +# Man muss es aber auch nicht übertreiben. Gerade ein Sprachenmix aus deutsch und englisch # <2-2> +# ist nicht besonders tragisch: z.B. steht m_b für mass_ball aber u_b für umfang_ball, # <2-2> +# aber das p_b für perimeter_ball würde mir persönlich nicht so klar werden. # <2-2> + # <2-> +# Erklärung: # <2-2> +# Auch die einzelnen "Arbeitsschritte" der Auswertung sollten in einem # <2-2> +# kurzen Kommentar erklärt werden. # <2-2> +# Erklärung: # <2-2> +# Die folgenden Berechnungen funktionieren alle weiterhin, nur jetzt mit automatischer Fehlerrechnung # <5-> + # <2-> + # <2-> +# Berechnung der benötigten Größen: Radius und Trägheitsmoment # <2-> + # <2-> +# Radius der Kugel # <2-> +r_b = u_b/(2*np.pi) # <2-> + # <2-> +# Äußerer Radius des Zylinders # <2-> +ro_c = u_c/(2*np.pi) # <2-> + # <2-> +# Innerer Radius des Zylinders # <2-> +ri_c = ro_c - d_c # <2-> + # <2-> + # <2-> +# Trägheitsmoment der Kugel # <2-> +I_b = 2/5 * m_b * r_b**2 # <2-> + # <2-> +# Trägheitsmoment des Zylinders # <2-> +I_c = 1/2 * m_c * (ro_c**2 + ri_c**2) # <2-> + # <2-> +print("Trägheitsmoment (Kugel)") # <2-> +print(I_b) # <2-> + # <2-> +print("Trägheitsmoment (Zylinder)") # <2-> +print(I_c) # <2-> + # <2-> + # <2-> +# Berechnung der Rollzeiten aus den Messwerten der Frames und Framerate # <2-> +t_b = (Ff_b - Fi_b)/fps # <2-> +t_c = (Ff_c - Fi_c)/fps # <2-> + # <2-> +# Berechnung des Mittelwerts für die Zeitdauer t für jede (dreifach gemessene) Höhe # <2-> + # <2-> +# Erklärung: # <2-2> +# Es ist ein neuer Name (t_b_mean) notwendig, wenn die alten Werte in t_b # <2-2> +# noch verfügbar bleiben sollen # <2-2> +# # <2-2> +# Hieran sieht man (schon im Kleinen) die Nützlichkeit der numpy arrays # <2-2> +# und der möglichen Manipulationen: # <2-2> +# reshape(-1,3): # <2-2> +# Im array t_b liegen die zu mittelnden Werte immer genau hintereinander # <2-2> +# durch reshape(-1,3) wird aus t_b ein 2D array erzeugt, das in jeder # <2-2> +# Zeile 3 Spalten hat. Das bedeutet: Nach jeweils 3 Werten in t_b wird eine neue # <2-2> +# Zeile begonnen, damit sind in jeder Zeile genau die Werte die gemittelt werden sollen. # <2-2> +# Die -1 als Anzahl der Zeilen ist gibt numpy die Anweisung, diese Anzahl # <2-2> +# selbst zu berechnen. # <2-2> +# # <2-2> +# mean(axis=1): # <2-2> +# Bei einem 2D array bezeichnet axis=0 die Zeilen und axis=1 die Spalten. # <2-2> +# Berechnet den Mittelwert "entlang der axis 1", d.h. die axis 1 ist die "Dimension" # <2-2> +# des arrays, über die summiert wird (die danach nur noch einen Wert enthält). # <2-2> +# Da jede Zeile genau die drei Werte enthält, die zu mitteln sind, enthält jede # <2-2> +# Zeile danach genau den jeweiligen Mittelwert. # <2-2> + # <2-> +t_b_mean = t_b.reshape(-1,3).mean(axis=1) # <2-> + # <2-> +# Erklärung: # <2-2> +# Das Array h_b enthält jede Höhe dreifach, auch die Auswahl # <2-2> +# der einzelnen Höhen kann durch array Manipulation geschehen. # <2-2> +# # <2-2> +# Die Benennung der Variable (h_b_mean) wurde so gewählt, # <2-2> +# dass diese zur zugehörigen Variable für die Zeitdauern passt # <2-2> +# # <2-2> +# reshape(-1, 3): # <2-2> +# analog zur Manipulation von t_b # <2-2> +# [:,0] # <2-2> +# Aus jeder Zeile (= erster Index ist ':') wird die 'nullte' Spalte (= zweiter Index ist '0') # <2-2> +# ausgewählt, d.h. in jeder Zeile bleibt genau eine Höhe erhalten. # <2-2> + # <2-> +h_b_mean = h_b.reshape(-1,3)[:,0] # <2-> + # <2-> +# Erklärung: # <2-2> +# analog für die andere Messreihe # <2-2> + # <2-> +t_c_mean = t_c.reshape(-1,3).mean(axis=1) # <2-> +h_c_mean = h_c.reshape(-1,3)[:,0] # <2-> + # <2-> +# Ausgabe verarbeiteten der Messwerte # <2-> + # <2-> +print("Messwerte (Kugel)") # <2-> +print("alle Zeiten") # <2-> +print(t_b) # <2-> +print("alle Höhen") # <2-> +print(h_b) # <2-> +print("Höhe") # <2-> +print(h_b_mean) # <2-> +print("gemittlelte Zeit") # <2-> +print(t_b_mean) # <2-> +print("\n") # <2-> + # <2-> + # <2-> +print("Messwerte (Zylinder)") # <2-> +print("alle Höhen") # <2-> +print(h_c) # <2-> +print("alle Zeiten") # <2-> +print(t_c) # <2-> +print("Höhe") # <2-> +print(h_c_mean) # <2-> +print("gemittlelte Zeit") # <2-> +print(t_c_mean) # <2-> +print("\n") # <2-> + # <2-> +# Erklärung: # <11-> +# Alle Ergebnisse die dieses Python-Script berechnet sollten # <11-> +# für eine noch umfangreichere Automatisierung nicht mehr # <11-> +# per Hand in das Protokoll geschrieben werden. # <11-> +# Neben der Automatisierung verhindert dies auch Fehler # <11-> +# beim Abtippen oder durch vergessene Aktualisierungen, # <11-> +# falls sich die Werte im Verlauf der Bearbeitungszeit # <11-> +# nocheinmal ändern. # <11-> +# # <11-> +# Die Ausgabe der Werte aufs Terminal erspart das nachschauen # <11-> +# in den Dateien. Es ist aber zu empfehlen, die Speicherung # <11-> +# in die Dateien unter der Ausgabe zu machen, um Veränderungen # <11-> +# der Werte zwischen Ausgabe aufs Terminal und Speichern vorzubeugen. # <11-> +# nocheinmal ändern. # <11-> +# Ausgenommen davon die Tabellen, weil der Code recht viel Platz einnimmt, # <11-> +# werden diese am Ende der Datei exportiert. # <11-> +# # <11-> + # <11-> +g = physical_constants["standard acceleration of gravity"][0] # <11-> +with open("build/theoretical-g.tex", "w") as f: # <11-> + f.write(make_qty(g,r"\meter\per\second\squared", figures=2, formatting="per-mode=reciprocal")) # <11-> + # <11-> +with open("build/framerate.tex", "w") as f: # <11-> + f.write(make_qty(fps, r"\per\second", figures=0, formatting="per-mode=reciprocal")) # <11-> + # <11-> +with open("build/theoretical-I_ball.tex", "w") as f: # <11-> + f.write(make_qty(I_b*10000,r"\kilo\gram\centi\meter\squared")) # change units: kg cm² # <11-> + # <11-> +with open("build/theoretical-I_cylinder.tex", "w") as f: # <11-> + f.write(make_qty(I_c*10000,r"\kilo\gram\centi\meter\squared"))# change units: kg cm² # <11-> + # <11-> +with open("build/tracklength.tex", "w") as f: # <11-> + f.write(make_qty(l,r"\meter")) # <11-> + # <11-> +with open("build/mass_ball.tex", "w") as f: # <11-> + f.write(make_qty(m_b,r"\kilo\gram")) # <11-> + # <11-> +with open("build/mass_cylinder.tex", "w") as f: # <11-> + f.write(make_qty(m_b,r"\kilo\gram")) # <11-> + # <11-> +with open("build/radius_ball.tex", "w") as f: # <11-> + f.write(make_qty(r_b, r"\meter")) # <11-> + # <11-> +with open("build/radius-inner_cylinder.tex", "w") as f: # <11-> + f.write(make_qty(ri_c,r"\meter")) # <11-> + # <11-> +with open("build/radius-outer_cylinder.tex", "w") as f: # <11-> + f.write(make_qty(ro_c,r"\meter")) # <11-> + # <11-> +# Erstelle Plots der Messwerte t_._mean und h_._mean # <3-> + # <2-> +# Erklärung: # <3-3> +# Funktionen für die Funktionsgleichungen der Theorie-Funktionen # <3-3> +# # <3-3> +# In Funktionen können Variablen verwendet werden, die außerhalb (global) definiert wurden # <3-3> +# wie hier: l, ri_c und ro_c # <3-3> +# Solche globalen Variablen können bei größeren Skripten/Programmen zu einem Problem werden # <3-3> +# es ist also zumindest Vorsicht geboten # <3-3> + # <2-> +def theory_t_ball(h): # <3-3> + return np.sqrt(7/5 * 1/h * 2* l**2/9.81) # <3-3> + # <2-> +def theory_t_cylinder(h): # <3-3> + return np.sqrt((3 + ri_c**2/ro_c**2) * l**2/9.81 * 1/h) # <3-3> + # <2-> +# Erklärung: # <4-4> +# Umwandeln der Theorie-Funktion zu einer Fit-Funktion: # <4-4> +# Die Funktion erhält ein zusätzliches Argument für jeden Fitparameter, hier: g und t0 # <4-4> +# diese müssen auch in der Funktion verwendet werden. # <4-4> +# # <4-4> +# Namen sind wie immer beliebig und es gibt nicht "den einen richtigen Namen", # <4-4> +# aber es bietet sich wie immer an sprechende Namen zu verwenden, hier z.B. # <4-4> +# "fit_g_ball" als Abkürzung für "Fitfunktion für den Parameter g aus den Messwerten für die Kugel" # <4-4> + # <2-> +def fit_g_ball(h, g, t0): # <4-4> + return np.sqrt(7/5 * 1/h * 2* l**2/g) + t0 # <4-4> + # <2-> +def fit_g_cylinder(h, g, t0): # <4-4> + return np.sqrt((3 + ri_c**2/ro_c**2) * l**2/g * 1/h) + t0 # <4-4> + # <2-> + # <2-> +# Erklärung: # <5-> +# Nur für die Erstellung der Plots und Fits ändert sich etwas: # <5-> +# Weder scipy noch matplotlib können direkt mit den unsicherheitbehafteten # <5-> +# Messwerten umgehen. # <5-> +# Folgendes muss dafür geändert werden: # <5-> +# # <5-> +# (1) in der Fitfunktion müssen mit der Funktion noms() # <5-> +# # <5-> +# die Unsicherheiten von Konstanten entfernt werden # <5-> +# # <5-> +# (2) mit Unsicherheiten der unabhängigen Variable kann curve_fit nicht umgehen, # <5-> +# diese müssen mit noms() entfernt werden. # <5-> +# # <5-> +# (3) die Werte und Unsicherheiten der abhängigen Variable (gemessene Funktionswerte) # <5-> +# müssen getrennt übergeben werden: noms() und stds() # <5-> +# # <5-> +# (4) die Darstellung der Messwerte im Plot wird durch errorbar() ersetzt, # <5-> +# um die Unsicherheiten anzeigen zu können # <5-> +# # <5-> +# In der Aufgabe 3-curve_fit muss eine Funktion ucurve_fit geschrieben werden, # <5-> +# die die scipy Funktion curve_fit verwendet, die aber den Umgang mit den # <5-> +# Unsicherheiten abstrahiert, sodass man das nicht jedes Mal aufs neue machen muss. # <5-> + # <2-> +def fit_g_ball(h, g, t0): # <5-> + return np.sqrt(7/5 * 1/h * 2* noms(l)**2/g) + t0 # <5-> + # <2-> +def fit_g_cylinder(h, g, t0): # <5-> + return np.sqrt((3 + noms(ri_c**2/ro_c**2)) * noms(l)**2/g * 1/h) + t0 # <5-> + # <2-> + # <2-> + # <2-> +# Erklärung: # <4-4> +# Hier ist Vorsicht geboten, da die Fit-Funktion und Messwerte zusammen passen müssen # <4-4> +# an solchen Stellen zahlt sich eine konsistente Benennung aus. # <4-4> +# Berechnung der Fitparameter für die Kugel # <4-> + # <2-> +params, covariance_matrix = curve_fit(fit_g_ball, h_b_mean, t_b_mean) # <4-4> +params, covariance_matrix = curve_fit(fit_g_ball, noms(h_b_mean), noms(t_b_mean), sigma=stds(t_b_mean)) # <5-10> +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) # <4-10> + # <11-> +# Erklärung: # <11-> +# Wir verwenden hier den 'Wrapper' für curve_fit, aus Aufgabe 5-uncertainties/3-curve_fit, # <11-> +# um die Arbeit mit unsicherheitbehafteten Werten für Fits wiederverwendbar auszulagern. # <11-> +params = ucurve_fit(fit_g_ball, noms(h_b_mean), t_b_mean) # <11-> + # <11-> +# Erklärung: # <4-4> +# Ansehnliche Ausgabe der Parameter aufs Terminal # <4-4> +print("Fitparameter (Kugel)") # <4-> +for name, value, uncertainty in zip("gt", params, param_uncertainties): # <5-10> + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") # <4-10> +for name, param in zip("gt", params): # <11-> + print(f"{name} = {param.n:8.3f} ± {param.s:.3f}") # <11-> +print("\n") # <4-10> + # <2-> +# exporting fit parameters # <11-> +parameter_g, parameter_t0 = params # <11-> + # <11-> +with open("build/parameter-g_kugel.tex", "w") as f: # <11-> + f.write(make_qty(parameter_g, r"\meter\per\second\squared")) # <11-> + # <11-> +with open("build/parameter-t0-g_kugel.tex", "w") as f: # <11-> + f.write(make_qty(parameter_t0, r"\second")) # <11-> + # <11-> +# Erklärung: # <3-3> +# Die Werte für h die im Plot der Theorie-Funktionen verwendet werden, damit diese # <3-3> +# auch tatsächlich aussieht wie eine differenzierbare Funktion. # <3-3> +# Der Bereich in dem diese Werte liegen entspricht, aber dem der Messwerte ca. [0.03, 0.33] # <3-3> +h_plot = np.linspace(0.03, 0.33, 205) # <3-> + # <2-> + # <2-> +# Fit Parameter für den Zylinder # <4-4> +# Fitparameter für den Zylinder # <5-> + # <2-> + # <2-> +# Erklärung: # <3-3> +# Erstellen einer figure mit einem subplot darin (1 Zeile x 1 Spalte an subplots) # <3-3> +fig, ax = plt.subplots(1, 1, layout="constrained") # <3-> + # <2-> + # <2-> +# Erklärung: # <3-3> +# Einstellung der Achsenbeschriftungen # <3-3> +ax.set_xlabel("$h$ / m") # <3-> +ax.set_ylabel("$t$ / s") # <3-> + # <2-> + # <2-> + # <2-> +# Erklärung: # <3-3> +# Darstellen der Messwerte mit Legendeneintrag # <3-3> +ax.plot(h_b_mean, t_b_mean, "k+", label="Daten: Kugel") # <3-4> +ax.errorbar(noms(h_b_mean), noms(t_b_mean), yerr=stds(t_b_mean), fmt="k+", label="Daten: Kugel") # <5-> + # <2-> +# Erklärung: # <4-4> +# Theorie-Funktion durch Fit-Funktion mit Fit-Parametern ersetzen # <4-4> +ax.plot(h_plot, theory_t_ball(h_plot), label="Theorie") # <3-3> +ax.plot(h_plot, fit_g_ball(h_plot, *params), label="Fit") # <4-10> +ax.plot(h_plot, fit_g_ball(h_plot, *noms(params)), label="Fit") # <11-> +ax.legend() # <3-> +fig.savefig("plot_kugel.pdf") # <3-3> +fig.savefig("plot-g_kugel.pdf") # <4-9> +fig.savefig("build/plot-g_kugel.pdf") # <10-> + # <2-> + # <2-> +# Erklärung: # <4-4> +# Analog für die Messreihe des Zylinders # <4-4> +# Achtung! Copy-and-paste ist natürlich gängige Praxis, # <4-4> +# aber alle Variablen müssen angepasst werden. # <4-4> + # <2-> +# Berechnung der Fitparameter für den Zylinder # <4-> +params, covariance_matrix = curve_fit(fit_g_cylinder, h_c_mean, t_c_mean) # <4-4> +params, covariance_matrix = curve_fit(fit_g_cylinder, noms(h_c_mean), noms(t_c_mean), sigma=stds(t_c_mean)) # <5-10> +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) # <4-10> + # <2-> +params = ucurve_fit(fit_g_cylinder, noms(h_c_mean), t_c_mean) # <11-> + # <2-> +print("Fitparameter (Zylinder)") # <4-> +for name, value, uncertainty in zip("gt", params, param_uncertainties): # <4-10> + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") # <4-10> +for name, param in zip("gt", params): # <11-> + print(f"{name} = {param.n:8.3f} ± {param.s:.3f}") # <11-> +print("\n") # <4-> + # <2-> + # exporting fit parameters # <11-> +parameter_g, parameter_t0 = params # <11-> + # <11-> +with open("build/parameter-g_zylinder.tex", "w") as f: # <11-> + f.write(make_qty(parameter_g, r"\meter\per\second\squared")) # <11-> + # <11-> +with open("build/parameter-t0-g_zylinder.tex", "w") as f: # <11-> + f.write(make_qty(parameter_t0, r"\second")) # <11-> + # <2-> +fig, ax = plt.subplots(1, 1, layout="constrained") # <3-> + # <2-> +ax.set_xlabel("$h$ / m") # <3-> +ax.set_ylabel("$t$ / s") # <3-> + # <2-> + # <2-> +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Zylinder") # <3-4> +ax.errorbar(noms(h_c_mean), noms(t_c_mean), yerr=stds(t_c_mean), fmt="k+", label="Daten: Zylinder") # <5-> +ax.plot(h_plot, theory_t_cylinder(h_plot), label="Theorie") # <3-3> +ax.plot(h_plot, fit_g_cylinder(h_plot, *params), label="Fit") # <4-10> +ax.plot(h_plot, fit_g_cylinder(h_plot, *noms(params)), label="Fit") # <11-> +ax.legend() # <3-> +fig.savefig("plot_zylinder.pdf") # <3-3> +fig.savefig("plot-g_zylinder.pdf") # <4-9> +fig.savefig("build/plot-g_zylinder.pdf") # <10-> + # <2-> + # <2-> +# Erklärung: # <4-4> +# Verwenden der physikalischen Konstanten aus scipy # <4-4> +# hier: g # <4-4> +# physical_constants enthält 3er-tuple, der erste Eintrag # <4-4> +# der tuple ist der Wert der Konstante, deswegen [0] # <4-4> + # <2-> + # <2-> +def fit_I_ball(h, I, t0): # <4-> + g = physical_constants["standard acceleration of gravity"][0] # <4-> + return np.sqrt(2/g * 1/h * l**2 * (1 + I/(m_b * r_b**2)) ) + t0 # <4-4> + return np.sqrt(2/g * 1/h * noms(l)**2 * (1 + I/(noms(m_b * r_b)**2)) ) + t0 # <5-> + # <2-> + # <2-> +def fit_I_cylinder(h, I, t0): # <4-> + g = physical_constants["standard acceleration of gravity"][0] # <4-> + return np.sqrt(2/g * 1/h * l**2 * (1 + I/(m_c * ro_c**2) )) + t0 # <4-4> + return np.sqrt(2/g * 1/h * noms(l)**2 * (1 + I/(noms(m_c * ro_c**2)) )) + t0 # <5-> + # <2-> +# Erklärung: # <4-4> +# Durch den Fit wird diese Warnung auf das Terminal ausgegeben: # <4-4> +# .../v16515/auswertung.py:197: RuntimeWarning: invalid value encountered in sqrt # <4-4> +# return np.sqrt(2/g * 1/h * l**2 * (1 + I/(m_c * ro_c**2) )) + t0 # <4-4> +# # <4-4> +# Diese bedeutet, dass während des Fits negative Werte für I 'ausprobiert' wurden, # <4-4> +# von denen die Wurzel nicht berechnet werden konnte. # <4-4> +# Man kann das verhindern, in dem man die Parameter auf den physikalisch möglichen # <4-4> +# Bereich einschränkt. Dies tut man mit dem zusätzlichen Parameter bounds für curve_fit, # <4-4> +# hier müsste # <4-4> +# bounds=([0,-np.inf],[+np.inf,+np.inf]) # <4-4> +# als zusätzliches Argument für curve_fit ergänzt werden. # <4-4> +# bounds gibt den minimalen und den maximalen Wert für alle Parameter an, # <4-4> +# und zwar zuerst alle Minima und dann alle Maxima, # <4-4> +# in diesem konkreten Beispiel steht bounds also für: 0 < I < +np.inf und -np.inf < t0 < +np.inf # <4-4> + # <2-> + # <2-> +# Berechnung der Fitparameter für die Kugel # <4-> +params, covariance_matrix = curve_fit(fit_I_ball, h_b_mean, t_b_mean) # <4-4> +params, covariance_matrix = curve_fit(fit_I_ball, noms(h_b_mean), noms(t_b_mean), sigma=stds(t_b_mean)) # <5-10> +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) # <4-10> + # <2-> +params = ucurve_fit(fit_I_ball, noms(h_b_mean), t_b_mean, bounds=([0,-np.inf],[+np.inf,+np.inf])) # <11-> + # <2-> +print("Fitparameter (Kugel)") # <4-> +for name, value, uncertainty in zip("It", params, param_uncertainties): # <4-10> +for name, param in zip("It", params): # <11-> + # in kg*m² sehr klein, umwandlung zu kg*cm² # <4-> + if name == "I": # <4-> + value *= 10000 # <4-10> + uncertainty *= 10000 # <4-10> + param *= 10000 # <11-> + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") # <4-10> + print(f"{name} = {param.n:8.3f} ± {param.s:.3f}") # <11-> +print("\n") # <4-> + + # exporting fit parameters # <11-> +parameter_I, parameter_t0 = params # <11-> + # <11-> +with open("build/parameter-I_kugel.tex", "w") as f: # <11-> + # in kg*m² sehr klein, umwandlung zu kg*cm² # <11-> + f.write(make_qty(parameter_I*10000, r"\kilo\gram\centi\meter\squared")) # <11-> + # <11-> +with open("build/parameter-t0-I_kugel.tex", "w") as f: # <11-> + f.write(make_qty(parameter_t0, r"\second")) # <11-> + # <11-> + # <2-> # <2-> +fig, ax = plt.subplots(1, 1, layout="constrained") # <4-> + # <2-> +ax.set_xlabel("$h$ / m") # <4-> +ax.set_ylabel("$t$ / s") # <4-> + # <2-> + # <2-> +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Kugel") # <4-4> +ax.errorbar(noms(h_b_mean), noms(t_b_mean), yerr=stds(t_b_mean), fmt="k+", label="Daten: Kugel") # <5-> +ax.plot(h_plot, fit_I_ball(h_plot, *params), label="Fit") # <4-10> +ax.plot(h_plot, fit_I_ball(h_plot, *noms(params)), label="Fit") # <11-> +ax.legend() # <4-> +fig.savefig("plot-I_kugel.pdf") # <4-9> +fig.savefig("build/plot-I_kugel.pdf") # <10-11> + # <2-> + # <2-> +# Berechnung der Fitparameter für den Zylinder # <4-> +params, covariance_matrix = curve_fit(fit_I_cylinder, h_c_mean, t_c_mean) # <4-4> +params, covariance_matrix = curve_fit(fit_I_cylinder, noms(h_c_mean), noms(t_c_mean), sigma=stds(t_c_mean)) # <5-10> +param_uncertainties = np.sqrt(np.diag(covariance_matrix)) # <4-10> + # <2-> +params = ucurve_fit(fit_I_cylinder, noms(h_c_mean), t_c_mean, bounds=([0,-np.inf],[+np.inf,+np.inf])) # <11-> + # <2-> +print("Fitparameter (Zylinder)") # <4-10> +for name, value, uncertainty in zip("It", params, param_uncertainties): # <4-10> +for name, param in zip("It", params): # <11-> + # in kg*m² sehr klein, umwandlung zu kg*cm² # <4-> + if name == "I": # <4-> + value *= 10000 # <4-10> + uncertainty *= 10000 # <4-10> + param *= 10000 # <11-> + print(f"{name} = {value:8.3f} ± {uncertainty:.3f}") # <4-10> + print(f"{name} = {param.n:8.3f} ± {param.s:.3f}") # <11-> +print("\n") # <4-> + # <2-> +# exporting fit parameters # <11-> +parameter_I, parameter_t0 = params # <11-> + # <11-> +with open("build/parameter-I_zylinder.tex", "w") as f: # <11-> + # in kg*m² sehr klein, umwandlung zu kg*cm² # <11-> + f.write(make_qty(parameter_I*10000, r"\kilo\gram\centi\meter\squared")) # <11-> + # <11-> +with open("build/parameter-t0-I_zylinder.tex", "w") as f: # <11-> + f.write(make_qty(parameter_t0, r"\second")) # <11-> + # <2-> + # <2-> +fig, ax = plt.subplots(1, 1, layout="constrained") # <4-> + # <2-> +ax.set_xlabel("$h$ / m") # <4-> +ax.set_ylabel("$t$ / s") # <4-> + # <2-> + # <2-> +ax.plot(h_c_mean, t_c_mean, "k+", label="Daten: Zylinder") # <4-4> +ax.errorbar(noms(h_c_mean), noms(t_c_mean), yerr=stds(t_c_mean), fmt="k+", label="Daten: Zylinder") # <5-> +ax.plot(h_plot, fit_I_cylinder(h_plot, *params), label="Fit") # <4-10> +ax.plot(h_plot, fit_I_cylinder(h_plot, *noms(params)), label="Fit") # <11-> +ax.legend() # <4-> +fig.savefig("plot-I_zylinder.pdf") # <4-9> +fig.savefig("build/plot-I_zylinder.pdf") # <10-> + +# writing latex tables # <11-> +# first: writing all measured values not just the averages # <11-> +# heights_ball, durations_ball, durations_cylinder # <11-> +# have not been reduced to 6 values each # <11-> + # <11-> +# Erklärung: # <11-> +# Die Erstellung der Tabellen wird hier nicht zu 100% automatisiert, aber # <11-> +# zumindest das abtippen der Werte ist hiermit nicht mehr nötig. # <11-> +# Das ist auch bei Weitem nicht nur ein Ausdruck von Faulheit, # <11-> +# sondern wieder ein wichtiger Schritt zu guter wissenschaftlicher # <11-> +# Praxis: Messwerte per Hand abtippen ist fehleranfällig und nur # <11-> +# mäßig reproduzierbar. # <11-> +# Es steht euch frei das noch etwas mehr zu automatisieren. # <11-> +# # <11-> +# Jede Tabelle besteht aus drei Teilen, dem # <11-> +# i) table_header: Beginn der Latexumgebung tblr und alle Spalten/Zeileneinstellungen # <11-> +# sowie die Kopfzeilen der Tabelle # <11-> +# # <11-> +# iii) table_footer: \bottomrule und das Ende der Latexumgebung tblr # <11-> +# # <11-> +# ii) row_template: Ein string mit Format angaben für die Werte in jeder Spalte, # <11-> +# (die Formatangaben stimmen nur hinter dem . mit denen für tblr überein # <11-> +# z.B. Spalte 2: table-format=4.0 aber {1.n: 0.0f}) # <11-> +# Die Zahl am Anfang der Formatangabe legt die Reihenfolge fest, # <11-> +# das .n bzw. .s bezeichnet bei unsicherheitbehafteten Werten die # <11-> +# nominalen Werte respektive die Standardabweichung. # <11-> +# .n und .s Formatangaben mit der selben Zahl davor sollten immer aufeinander folgen. # <11-> +# # <11-> +# Die drei Teile werden dann in einer Datei zusammen gesetzt: # <11-> +# Zuerst wird der table_header in die Datei geschrieben # <11-> +# dann werden die Daten, mit Hilfe einer for-loop über alle Spalten # <11-> +# (beachtet die Verwendung von zip) und dem row_template, # <11-> +# Zeile für Zeile in die Datei geschrieben. # <11-> +# Danach muss mit f.write('\n') dafür gesorgt werden, dass in der Datei eine # <11-> +# neue Zeile angefangen wird. # <11-> +# Und am Ende wird noch der table_footer in die Datei geschrieben. # <11-> +# # <11-> + # <11-> +table_header = r""" # <11-> + \begin{tblr}{ # <11-> + colspec = { # <11-> + S[table-format=1.3] # <11-> + S[table-format=4.0] # <11-> + S[table-format=1.0] # <11-> + S[table-format=4.0] # <11-> + S[table-format=1.0] # <11-> + S[table-format=1.3] # <11-> + S[table-format=1.3] # <11-> + S[table-format=4.0] # <11-> + S[table-format=1.0] # <11-> + S[table-format=4.0] # <11-> + S[table-format=1.0] # <11-> + S[table-format=1.3] # <11-> + S[table-format=1.3] # <11-> + }, # <11-> + row{1} = {guard}, # <11-> + row{2} = {guard, mode=math}, # <11-> + vline{3,5,7,9,11,13} = {2}{-}{text=\clap{\pm}}, # <11-> + } # <11-> + \toprule # <11-> + & # <11-> + \SetCell[c=6]{c} Messung: Kugel & & & & & & # <11-> + \SetCell[c=6]{c} Messung: Zylinder & & & & & \\ # <11-> + \cmidrule[lr]{2-7}\cmidrule[lr]{8-14} # <11-> + h \mathbin{/} \unit{\meter} &% # <11-> + \SetCell[c=2]{c} F_\text{i} \mathbin{/} 1 & &% # <11-> + \SetCell[c=2]{c} F_\text{f} \mathbin{/} 1 & &% # <11-> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second} & &% # <11-> + \SetCell[c=2]{c} F_\text{i} \mathbin{/} 1 & &% # <11-> + \SetCell[c=2]{c} F_\text{f} \mathbin{/} 1 & &% # <11-> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second}& \\ # <11-> + \midrule # <11-> +""" # <11-> + # <11-> + # <11-> +table_footer = r""" \bottomrule # <11-> + \end{tblr} # <11-> +""" # <11-> + # <11-> + # <11-> +row_template = ( # <11-> + 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} \\" # <11-> +) # <11-> + # <11-> + # <11-> + # <11-> +with open("build/table_all-measurements.tex", "w") as f: # <11-> + f.write(table_header) # <11-> + for row in zip(h_b, Fi_b, Ff_b, t_b, Fi_c, Ff_c, t_c): # <11-> + f.write(row_template.format(*row)) # <11-> + f.write("\n") # <11-> + f.write(table_footer) # <11-> + # <11-> + # <11-> +# second: writing the averaged values and leaving out the frames # <11-> +# heights_ball, durations_ball, durations_cylinder # <11-> +# have not been reduced to 6 values each # <11-> + # <11-> + # <11-> +table_header = r""" # <11-> + \begin{tblr}{ # <11-> + colspec = { # <11-> + S[table-format=1.3] # <11-> + S[table-format=2.3] # <11-> + S[table-format=1.4] # <11-> + S[table-format=3.3] # <11-> + S[table-format=1.5] # <11-> + }, # <11-> + row{1} = {guard}, # <11-> + row{2} = {guard, mode=math}, # <11-> + vline{3,5,7,9} = {2}{-}{text=\clap{\pm}}, # <11-> + } # <11-> + \toprule # <11-> + & # <11-> + \SetCell[c=2]{c} Messung: Kugel & & # <11-> + \SetCell[c=2]{c} Messung: Zylinder &\\ # <11-> + \cmidrule[lr]{2-3}\cmidrule[lr]{4-5} # <11-> + h \mathbin{/} \unit{\meter} &% # <11-> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second} & &% # <11-> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second}& \\ # <11-> + \midrule # <11-> +""" # <11-> + # <11-> + # <11-> +table_footer = r""" \bottomrule # <11-> + \end{tblr} # <11-> +""" # <11-> + # <11-> + # <11-> +row_template = ( # <11-> + r"{0.n:1.3f} & {1.n:1.3f} & {1.s:1.3f} & {2.n:1.3f} & {2.s:1.3f} \\" # <11-> +) # <11-> + # <11-> + # <11-> +with open("build/table_averaged-measurements.tex", "w") as f: # <11-> + f.write(table_header) # <11-> + for row in zip(h_b_mean, t_b_mean, t_c_mean): # <11-> + f.write(row_template.format(*row)) # <11-> + f.write("\n") # <11-> + f.write(table_footer) # <11-> + # <11-> + diff --git a/exercises-toolbox/8-all/example-report/templates/curve_fit.py b/exercises-toolbox/8-all/example-report/templates/curve_fit.py new file mode 100644 index 00000000..2da5e3dc --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/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/example-report/templates/data_with_uncertainties/Messwerte_Bahn.txt b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/Messwerte_Bahn.txt new file mode 100644 index 00000000..cc6a4720 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/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/example-report/templates/data_with_uncertainties/Messwerte_Frames_Kugel.txt b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..91bc58b6 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/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/example-report/templates/data_with_uncertainties/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..2321d313 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/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/example-report/templates/data_with_uncertainties/Messwerte_Kamera.txt b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/Messwerte_Kamera.txt new file mode 100644 index 00000000..add88808 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/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/example-report/templates/data_with_uncertainties/Messwerte_Kugel.txt b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/Messwerte_Kugel.txt new file mode 100644 index 00000000..48b54cb9 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/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/example-report/templates/data_with_uncertainties/Messwerte_Zylinder.txt b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/Messwerte_Zylinder.txt new file mode 100644 index 00000000..d9d19ddf --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_with_uncertainties/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/example-report/templates/data_without_uncertainties/Messwerte_Bahn.txt b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Bahn.txt new file mode 100644 index 00000000..bc860551 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Bahn.txt @@ -0,0 +1,4 @@ +# l +80 +# Länge der Bahn +# cm (l / cm) diff --git a/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Frames_Kugel.txt b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Frames_Kugel.txt new file mode 100644 index 00000000..72cb5208 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/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/8-all/example-report/templates/data_without_uncertainties/Messwerte_Frames_Zylinder.txt b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Frames_Zylinder.txt new file mode 100644 index 00000000..245c87d2 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/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/8-all/example-report/templates/data_without_uncertainties/Messwerte_Kamera.txt b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Kamera.txt new file mode 100644 index 00000000..1b429402 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Kamera.txt @@ -0,0 +1,4 @@ +# fps +30 +# Framerate der Videoaufnahmen +# Frames per second (fps / 1/s) diff --git a/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Kugel.txt b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Kugel.txt new file mode 100644 index 00000000..1dc033ed --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/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/8-all/example-report/templates/data_without_uncertainties/Messwerte_Zylinder.txt b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/Messwerte_Zylinder.txt new file mode 100644 index 00000000..6ba4a540 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/data_without_uncertainties/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/8-all/example-report/templates/header-matplotlib.tex b/exercises-toolbox/8-all/example-report/templates/header-matplotlib.tex new file mode 100644 index 00000000..1d23aac1 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/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/example-report/templates/latex/auswertung_tex_template b/exercises-toolbox/8-all/example-report/templates/latex/auswertung_tex_template new file mode 100644 index 00000000..4bdc78fa --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/latex/auswertung_tex_template @@ -0,0 +1,202 @@ +\section{Auswertung} % <7-> +\label{sec:Auswertung} % <9-> +Die für diesen Versuch relevanten physikalischen Größen für Kugel und Zylinder sind: % <7-> +\begin{align} % <8-> + \label{eq:physical-properties} % <9-> + m_\text{Z} &= \qty{0.1860+-0.0010}{\kilo\gram} & m_\text{K} &= \qty{0.2160+-0.0010}{\kilo\gram}\nonumber\\ % <8-10> + r_{\text{Z},\text{i}} &= \qty{0.0357+-0.0010}{\meter}& r_\text{K} &= \qty{0.04854+-0.00016}{\meter}\\ % <8-10> + r_{\text{Z},\text{a}} &= \qty{0.03867+-0.00016}{\meter} &&\nonumber % <8-10> + m_\text{Z} &= \input{build/mass_ball.tex} & m_\text{K} &= \input{build/mass_ball.tex}\nonumber\\ % <11-> + r_{\text{Z},\text{i}} &= \input{build/radius-inner_cylinder.tex} & r_\text{K} &= \input{build/radius_ball.tex}\\ % <11-> + r_{\text{Z},\text{a}} &= \input{build/radius-outer_cylinder.tex} &&\nonumber % <11-> +\end{align} % <8-> +Berechnet wurde aus diesen Größen das jeweilige, theoretische Trägheitsmoment % <7-> +\begin{align} % <8-> + \label{eq:moments-inertia} % <8-> + I_\text{Z} &= \qty{2.57+-0.07}{\kilo\gram\centi\meter\squared}\quad\text{ und } & I_\text{K} =\qty{2.036+-0.016}{\kilo\gram\centi\meter\squared} % <8-10> + I_\text{Z} &= \input{./build/theoretical-I_cylinder.tex}\quad\text{ und } & I_\text{K} = \input{./build/theoretical-I_ball.tex}. % <11-> +\end{align} % <8-> +Aus den aufgenommenen Videos der Versuche wurden die in \autoref{tab:all-measurements} folgenden Frameindizes extrahiert. % <9-> +Die ebenfalls aufgeführte Zeitdauer $t$ wurde dann jeweils aus der aus dem Startframeindex $F_\text{i}$, % <8-> +dem Endframeindex $F_\text{f}$ und der Kameraframerate $\operatorname{fps}=\qty[per-mode=reciprocal]{30}{\per\second}$ wie folgt % <9-9> +dem Endframeindex $F_\text{f}$ und der Kameraframerate $\operatorname{fps}=\input{build/framerate.tex}$ wie folgt % <11-> +berechnet % <7-> +\begin{equation*} % <8-> + t = (F_\text{f} - F_\text{i})\cdot\operatorname{fps}^{-1} % <8-> +\end{equation*} % <8-> + % <7-> +\begin{table} % <9-> + \centering % <9-> + \caption{Alle aufgenommenen Werte, das heißt mit dreifach wiederholter Messungen je Höhe.} % <9-> + \label{tab:all-measurements} % <9-> + \begin{tblr}{ % <9-10> + colspec = { % <9-10> + S[table-format=1.3] % <9-10> + S[table-format=4.0] % <9-10> + S[table-format=1.0] % <9-10> + S[table-format=4.0] % <9-10> + S[table-format=1.0] % <9-10> + S[table-format=1.3] % <9-10> + S[table-format=1.3] % <9-10> + S[table-format=4.0] % <9-10> + S[table-format=1.0] % <9-10> + S[table-format=4.0] % <9-10> + S[table-format=1.0] % <9-10> + S[table-format=1.3] % <9-10> + S[table-format=1.3] % <9-10> + }, % <9-10> + row{1} = {guard}, % <9-10> + row{2} = {guard, mode=math}, % <9-10> + vline{3,5,7,9,11,13} = {2}{-}{text=\clap{\pm}}, % <9-10> + } % <9-10> + \toprule % <9-10> + & % <9-10> + \SetCell[c=6]{c} Messung: Kugel & & & & & & % <9-10> + \SetCell[c=6]{c} Messung: Zylinder & & & & & \\ % <9-10> + \cmidrule[lr]{2-7}\cmidrule[lr]{8-14} % <9-10> + h \mathbin{/} \unit{\meter} &% % <9-10> + \SetCell[c=2]{c} F_\text{i} \mathbin{/} 1 & &% % <9-10> + \SetCell[c=2]{c} F_\text{f} \mathbin{/} 1 & &% % <9-10> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second} & &% % <9-10> + \SetCell[c=2]{c} F_\text{i} \mathbin{/} 1 & &% % <9-10> + \SetCell[c=2]{c} F_\text{f} \mathbin{/} 1 & &% % <9-10> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second}& \\ % <9-10> + \midrule % <9-10> + 0.045 & 436 & 1 & 492 & 1& 1.867 & 0.047 & 1018 & 1& 1083 & 1& 2.167 & 0.047 \\ % <9-10> + 0.045 & 555 & 1 & 610 & 1& 1.833 & 0.047 & 1189 & 1& 1248 & 1& 1.967 & 0.047 \\ % <9-10> + 0.045 & 672 & 1 & 729 & 1& 1.900 & 0.047 & 1340 & 1& 1404 & 1& 2.133 & 0.047 \\ % <9-10> + 0.100 & 95 & 1 & 130 & 1& 1.167 & 0.047 & 596 & 1& 636 & 1& 1.333 & 0.047 \\ % <9-10> + 0.100 & 199 & 1 & 235 & 1& 1.200 & 0.047 & 762 & 1& 801 & 1& 1.300 & 0.047 \\ % <9-10> + 0.100 & 303 & 1 & 338 & 1& 1.167 & 0.047 & 882 & 1& 921 & 1& 1.300 & 0.047 \\ % <9-10> + 0.150 & 91 & 1 & 119 & 1& 0.933 & 0.047 & 574 & 1& 605 & 1& 1.033 & 0.047 \\ % <9-10> + 0.150 & 201 & 1 & 229 & 1& 0.933 & 0.047 & 766 & 1& 798 & 1& 1.067 & 0.047 \\ % <9-10> + 0.150 & 335 & 1 & 362 & 1& 0.900 & 0.047 & 863 & 1& 896 & 1& 1.100 & 0.047 \\ % <9-10> + 0.200 & 232 & 1 & 256 & 1& 0.800 & 0.047 & 679 & 1& 707 & 1& 0.933 & 0.047 \\ % <9-10> + 0.200 & 323 & 1 & 347 & 1& 0.800 & 0.047 & 810 & 1& 838 & 1& 0.933 & 0.047 \\ % <9-10> + 0.200 & 397 & 1 & 421 & 1& 0.800 & 0.047 & 930 & 1& 959 & 1& 0.967 & 0.047 \\ % <9-10> + 0.250 & 153 & 1 & 174 & 1& 0.700 & 0.047 & 650 & 1& 674 & 1& 0.800 & 0.047 \\ % <9-10> + 0.250 & 239 & 1 & 260 & 1& 0.700 & 0.047 & 892 & 1& 917 & 1& 0.833 & 0.047 \\ % <9-10> + 0.250 & 322 & 1 & 343 & 1& 0.700 & 0.047 & 804 & 1& 827 & 1& 0.767 & 0.047 \\ % <9-10> + 0.300 & 219 & 1 & 238 & 1& 0.633 & 0.047 & 642 & 1& 664 & 1& 0.733 & 0.047 \\ % <9-10> + 0.300 & 319 & 1 & 338 & 1& 0.633 & 0.047 & 739 & 1& 760 & 1& 0.700 & 0.047 \\ % <9-10> + 0.300 & 391 & 1 & 412 & 1& 0.700 & 0.047 & 900 & 1& 922 & 1& 0.733 & 0.047 \\ % <9-10> + \bottomrule % <9-10> + \end{tblr} % <9-10> + \input{build/table_all-measurements.tex} % <11-> +\end{table} % <9-> + % <7-> +Durch Mittelung der Messwerte für die selbe Höhe $h$ ergeben sich die Werte % <9-> +in \autoref{tab:averaged-measurements}. Diese Werte werden für die folgenden % <9-> +Auswertungsschritte verwendet. % <9-> + % <7-> +\begin{table} % <9-> + \centering % <9-> + \caption{Für gleiche Starthöhe $h$ gemittelte Messwerte der Zeit $t$.} % <9-> + \label{tab:averaged-measurements} % <9-> + % <9-> + \begin{tblr}{ % <9-10> + colspec = { % <9-10> + S[table-format=1.3] % <9-10> + S[table-format=2.3] % <9-10> + S[table-format=1.4] % <9-10> + S[table-format=3.3] % <9-10> + S[table-format=1.5] % <9-10> + }, % <9-10> + row{1} = {guard}, % <9-10> + row{2} = {guard, mode=math}, % <9-10> + vline{3,5,7,9} = {2}{-}{text=\clap{\pm}}, % <9-10> + } % <9-10> + \toprule % <9-10> + & % <9-10> + \SetCell[c=2]{c} Messung: Kugel & & % <9-10> + \SetCell[c=2]{c} Messung: Zylinder &\\ % <9-10> + \cmidrule[lr]{2-3}\cmidrule[lr]{4-5} % <9-10> + h \mathbin{/} \unit{\meter} &% % <9-10> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second} & &% % <9-10> + \SetCell[c=2]{c} t \mathbin{/} \unit{\second}& \\ % <9-10> + \midrule % <9-10> + 0.045 & 1.867 & 0.027 & 2.089 & 0.027 \\ % <9-10> + 0.100 & 1.178 & 0.027 & 1.311 & 0.027 \\ % <9-10> + 0.150 & 0.922 & 0.027 & 1.067 & 0.027 \\ % <9-10> + 0.200 & 0.800 & 0.027 & 0.944 & 0.027 \\ % <9-10> + 0.250 & 0.700 & 0.027 & 0.800 & 0.027 \\ % <9-10> + 0.300 & 0.656 & 0.027 & 0.722 & 0.027 \\ % <9-10> + \bottomrule % <9-10> + \end{tblr} % <9-10> + \input{build/table_averaged-measurements.tex} % <11-> +\end{table} % <9-> + % <7-> +\subsection{Bestimmung der Fallbeschleunigung} % <7-> + % <7-> +Für die Bestimmung der Fallbeschleunigung wurden eine Ausgleichsfunktion der Form % <7-> +\eqref{eq:fit-function-g-ball} respektive \eqref{eq:fit-function-g-cylinder} an die Messwerte aus \autoref{tab:averaged-measurements} % <9-> +angepasst. Die Daten und Ausgleichsfunktion sind für die Kugel in \autoref{fig:fit-g-ball} % <9-> +und für den Zylinder in \autoref{fig:fit-g-cylinder} graphisch dargestellt. % <9-> + % <7-> +\begin{figure} % <9-> + \centering % <9-> + \includegraphics{plot-g_kugel.pdf} % <9-> + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für die Kugel, % <9-> + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-g-ball} für die Bestimmung der Fallbeschleunigung $g$. % <9-> + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-g_ball} angegeben.} % <9-> + \label{fig:fit-g-ball} % <9-> +\end{figure} % <9-> + % <9-> +\begin{figure} % <9-> + \centering % <9-> + \includegraphics{plot-g_zylinder.pdf} % <9-> + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für den Zylinder, % <9-> + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-g-cylinder} für die Bestimmung der Fallbeschleunigung $g$. % <9-> + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-g_cylinder} angegeben.} % <9-> + \label{fig:fit-g-cylinder} % <9-> +\end{figure} % <9-> + % <7-> +Die Parameter der Ausgleichsrechnung ergeben sich für die Kugel zu % <7-> +\begin{align} % <8-> + \label{eq:parameters-g_ball} % <8-> + g_\text{K} &= \qty{10.0+-0.5}{\meter\per\second\squared}\quad\text{ und } & t_{0,\text{K}} &= \qty{-0.148+-0.033}{\second} % <8-10> + g_\text{K} &= \input{build/parameter-g_kugel.tex}\quad\text{ und } & t_{0,\text{K}} &= \input{build/parameter-t0-g_kugel.tex} % <11-> +\intertext{und für den Zylinder} % <8-> + \label{eq:parameters-g_cylinder} % <8-> + g_\text{Z} &= \qty{11.2+-0.5}{\meter\per\second\squared}\quad\text{ und } & t_{0,\text{Z}} &= \qty{-0.135+-0.033}{\second}. % <8-10> + g_\text{Z} &= \input{build/parameter-g_zylinder.tex}\quad\text{ und } & t_{0,\text{Z}} &= \input{build/parameter-t0-g_zylinder.tex}. % <11-> +\end{align} % <8-> + % <7-> +\subsection{Bestimmung der Trägheitsmomente von Kugel und Zylinder} % <7-> + % <7-> +Für die bestimmung der Fallbeschleunigung wurden eine Ausgleichsfunktion der Form % <7-> +\eqref{eq:fit-function-I} an die Messwerte aus \autoref{tab:averaged-measurements} % <9-> +angepasst. Die Daten und Ausgleichsfunktion sind für die Kugel in \autoref{fig:fit-I-ball} % <9-> +und für den Zylinder in \autoref{fig:fit-I-cylinder} graphisch dargestellt. % <9-> + % <7-> +\begin{figure} % <9-> + \centering % <9-> + \includegraphics{plot-I_kugel.pdf} % <9-> + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für den Kugel, % <9-> + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-I} für die Bestimmung des Trägheitsmoments $I_\text{K}$. % <9-> + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-I_ball} angegeben.} % <9-> + \label{fig:fit-I-ball} % <9-> +\end{figure} % <9-> + % <7-> + % <7-> +\begin{figure} % <9-> + \centering % <9-> + \includegraphics{plot-I_zylinder.pdf} % <9-> + \caption{Dargestellt sind die für je eine Höhe gemittelten Messwerte aus \autoref{tab:averaged-measurements} für den Zylinder, % <9-> + zusammen mit einer Ausgleichsfunktion der Form \eqref{eq:fit-function-I} für die Bestimmung des Trägheitsmoments $I_\text{Z}$. % <9-> + Die Parameter der Ausgleichsrechnung sind in \eqref{eq:parameters-I_cylinder} angegeben.} % <9-> + \label{fig:fit-I-cylinder} % <9-> +\end{figure} % <9-> + % <7-> +Die Parameter der Ausgleichsrechnung ergeben sich für die Kugel zu % <7-> +\begin{align} % <8-> + \label{eq:parameters-I_ball} % <8-> + I_\text{K} &= \qty{1.9+-0.4}{\kilo\gram\centi\meter\squared}\quad\text{ und } & t_{0,\text{K}} &= \qty{-0.148+-0.033}{\second} % <8-10> + I_\text{K} &= \input{build/parameter-I_kugel.tex}\quad\text{ und } &t_{0,\text{K}} &= \input{build/parameter-t0-I_kugel.tex} % <11-> + \intertext{und für den Zylinder} % <8-> + \label{eq:parameters-I_cylinder} % <8-> + I_\text{Z} &= \qty{1.90+-0.23}{\kilo\gram\centi\meter\squared}\quad\text{ und }& t_{0,\text{Z}} &= \qty{-0.135+-0.033}{\second}. % <8-10> + I_\text{Z} &= \input{build/parameter-I_zylinder.tex}\quad\text{ und } & t_{0,\text{Z}} &= \input{build/parameter-t0-I_zylinder.tex}. % <11-> +\end{align} % <8-> + + diff --git a/exercises-toolbox/8-all/example-report/templates/latex/diskussion_tex_template b/exercises-toolbox/8-all/example-report/templates/latex/diskussion_tex_template new file mode 100644 index 00000000..b13ac4ab --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/latex/diskussion_tex_template @@ -0,0 +1,44 @@ +\section{Diskussion} % <7-> +\label{sec:Diskussion} % <9-> + % <7-> +TODO: Diskussion fertig machen ;-) % <7-> + % <7-> +Notizen: % <7-> + % <7-> +Bestimmung von g: % <7-> + % <7-> +Fits % <7-> + % <7-> +\autoref{fig:fit-g-ball} % <9-> + % <7-> +\autoref{fig:fit-g-cylinder} % <9-> + % <7-> +passen zu den Messwerten. % <7-> + % <7-> + % <7-> +Die Fit parameter % <7-> +\eqref{eq:parameters-g_ball} % <8-> +\eqref{eq:parameters-g_cylinder} % <8-> + % <7-> +passen zum theoretischen Wert $\qty{9.81}{\meter\per\second\squared}$ % <8-> +passen zum theoretischen Wert \input{theoretical-g.tex} % <11-> +=> TODO: Abweichungen berechnen % <7-> + % <7-> +Die übereinstimmung der Fitparameter t0, weist auf eine systematische Unsicherheit % <7-> +=> TODO: Berechnung des Offsets in Frames % <7-> + % <7-> +Analog für die Bestimmung von I: % <7-> + % <7-> +Fits: % <7-> + % <7-> +\autoref{fig:fit-I-ball} % <9-> + % <7-> +\autoref{fig:fit-I-cylinder} % <9-> + % <7-> +\eqref{eq:parameters-I_ball} % <9-> + % <9-> +\eqref{eq:parameters-I_cylinder} % <9-> + % <9-> +\eqref{eq:moments-inertia} % <9-> + % <7-> +=> TODO: Abweichungen berechnen % <7-> diff --git a/exercises-toolbox/8-all/example-report/templates/latex/durchfuehrung_tex_template b/exercises-toolbox/8-all/example-report/templates/latex/durchfuehrung_tex_template new file mode 100644 index 00000000..44952189 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/latex/durchfuehrung_tex_template @@ -0,0 +1,22 @@ +\section{Durchführung} % <7-> +\label{sec:Durchführung} % <9-> + % <7-> +Wie in der Anleitung~\cite{V16516} beschrieben, wird der Versuch wie folgt durchgeführt. % <9-> + % <9-> +Wie einst von Galileo Galilei \cite[232]{galilei1623} persönlich, wurden im hier beschriebenen Versuch % <9-> +Objekte (eine Kugel und Holzylinder in Form eines Glases) eine schiefe Ebene hinab gerollt. % <9-> + % <9-> +Notiert wird dabei die Starthöhen $h$. Der Prozess des Herabrollens wird mit einer Kamera % <8-> +aufgezeichnet, um aus der Zeit $t$ bis zum erreichen des Endes der schiefen Ebene möglichst genau % <8-> +aus den Einzelbildern (frames) des Films ablesen zu können. % <8-> + % <7-> +Die aufgenommenen Messdaten werden für zwei unabhängige Zwecke verwendet: % <7-> + % <7-> +\begin{enumerate} % <7-> + \item {Bestimmung der Fallbeschleunigung $g$, dafür werden % <7-> + die theoretischen Trägheitsmomente angenommen.} % <7-> + \item {Bestimmung der Trägheitsmomente $I$ der beiden Objekte unter Annahme der theoretischen % <7-> + Fallbeschleunigung.} % <7-> +\end{enumerate} % <7-> + + diff --git a/exercises-toolbox/8-all/example-report/templates/latex/header_tex_template b/exercises-toolbox/8-all/example-report/templates/latex/header_tex_template new file mode 100644 index 00000000..dacf2eae --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/latex/header_tex_template @@ -0,0 +1,139 @@ +\documentclass[ % <7-> + bibliography=totoc, % Literatur im Inhaltsverzeichnis % <9-> + captions=tableheading, % Tabellenüberschriften % <9-> + titlepage=firstiscover, % Titelseite ist Deckblatt % <7-> +]{scrartcl} % <7-> + % <7-> +% Paket float verbessern % <7-> +\usepackage{scrhack} % <9-> + % <7-> +% Warnung, falls nochmal kompiliert werden muss % <7-> +\usepackage[aux]{rerunfilecheck} % <7-> + % <7-> +% unverzichtbare Mathe-Befehle % <7-> +\usepackage{amsmath} % <7-> +% viele Mathe-Symbole % <7-> +\usepackage{amssymb} % <7-> +% Erweiterungen für amsmath % <7-> +\usepackage{mathtools} % <7-> + % <7-> +% Fonteinstellungen % <7-> +\usepackage{fontspec} % <7-> +% Latin Modern Fonts werden automatisch geladen % <7-> +% Alternativ zum Beispiel: % <7-> +%\setromanfont{Libertinus Serif} % <7-> +%\setsansfont{Libertinus Sans} % <7-> +%\setmonofont{Libertinus Mono} % <7-> + % <7-> +% Wenn man andere Schriftarten gesetzt hat, % <7-> +% sollte man das Seiten-Layout neu berechnen lassen % <7-> +\recalctypearea{} % <7-> + % <7-> +% deutsche Spracheinstellungen % <7-> +\usepackage[ngerman]{babel} % <7-> + % <7-> + % <7-> +\usepackage[ % <7-> + math-style=ISO, % ┐ % <7-> + bold-style=ISO, % │ % <7-> + sans-style=italic, % │ ISO-Standard folgen % <7-> + nabla=upright, % │ % <7-> + partial=upright, % │ % <7-> + mathrm=sym, % ┘ % <7-> + warnings-off={ % ┐ % <7-> + mathtools-colon, % │ unnötige Warnungen ausschalten % <7-> + mathtools-overbracket, % │ % <7-> + }, % ┘ % <7-> +]{unicode-math} % <7-> + % <7-> +% traditionelle Fonts für Mathematik % <7-> +\setmathfont{Latin Modern Math} % <7-> +% Alternativ zum Beispiel: % <7-> +%\setmathfont{Libertinus Math} % <7-> + % <7-> +\setmathfont{XITS Math}[range={scr, bfscr}] % <7-> +\setmathfont{XITS Math}[range={cal, bfcal}, StylisticSet=1] % <7-> + % <7-> +% Zahlen und Einheiten % <8-> +\usepackage[ % <8-> + locale=DE, % deutsche Einstellungen % <8-> + separate-uncertainty=true, % immer Unsicherheit mit \pm % <8-> + per-mode=symbol-or-fraction, % / in inline math, fraction in display math % <8-> +]{siunitx} % <8-> + % <7-> +% chemische Formeln % <8-> +\usepackage[ % <8-> + version=4, % <8-> + math-greek=default, % ┐ mit unicode-math zusammenarbeiten % <8-> + text-greek=default, % ┘ % <8-> +]{mhchem} % <8-> + % <7-> +% richtige Anführungszeichen % <7-> +\usepackage[autostyle]{csquotes} % <7-> + % <7-> +% schöne Brüche im Text % <7-> +\usepackage{xfrac} % <8-> + % <7-> +% Standardplatzierung für Floats einstellen % <9-> +\usepackage{float} % <9-> +\floatplacement{figure}{htbp} % <9-> +\floatplacement{table}{htbp} % <9-> + % <7-> +% Floats innerhalb einer Section halten % <9-> +\usepackage[ % <9-> + section, % Floats innerhalb der Section halten % <9-> + below, % unterhalb der Section aber auf der selben Seite ist ok % <9-> +]{placeins} % <9-> + % <7-> +% Seite drehen für breite Tabellen: landscape Umgebung % <9-> +\usepackage{pdflscape} % <9-> + % <7-> +% Captions schöner machen. % <9-> +\usepackage[ % <9-> + labelfont=bf, % Tabelle x: Abbildung y: ist jetzt fett % <9-> + font=small, % Schrift etwas kleiner als Dokument % <9-> + width=0.9\textwidth, % maximale Breite einer Caption schmaler % <9-> +]{caption} % <9-> +% subfigure, subtable, subref % <9-> +\usepackage{subcaption} % <9-> + % <7-> + % <7-> +% Grafiken können eingebunden werden % <7-> +\usepackage{graphicx} % <9-> + % <9-> +% schöne Tabellen % <9-> +\usepackage{tabularray} % <9-> +\UseTblrLibrary{booktabs,siunitx} % <9-> + % <7-> +% Verbesserungen am Schriftbild % <7-> +\usepackage{microtype} % <11-> + % <7-> +% Literaturverzeichnis % <9-> +\usepackage[ % <9-> + backend=biber, % <9-> +]{biblatex} % <9-> +% Quellendatenbank % <9-> +\addbibresource{lit.bib} % <9-> +\addbibresource{programme.bib} % <9-> + % <7-> +% Hyperlinks im Dokument % <7-> +\usepackage[ % <7-> + german, % <7-> + unicode, % Unicode in PDF-Attributen erlauben % <7-> + pdfusetitle, % Titel, Autoren und Datum als PDF-Attribute % <7-> + pdfcreator={}, % ┐ PDF-Attribute säubern % <7-> + pdfproducer={}, % ┘ % <7-> +]{hyperref} % <7-> +% erweiterte Bookmarks im PDF % <7-> +\usepackage{bookmark} % <7-> + % <7-> +% Trennung von Wörtern mit Strichen % <7-> +\usepackage[shortcuts]{extdash} % <7-> + % <7-> +\author{% % <7-> + Joshua Luckey\\% % <7-> + \href{mailto:joshua.luckey@udo.edu}{joshua.luckey@udo.edu}% % <7-> + \and% % <7-> + PeP et al.: Toolbox Workshop\\% % <7-> + \href{mailto:pep-toolbox.physik@lists.tu-dortmund.de}{pep-toolbox.physik@lists.tu-dortmund.de} % <7-> +} % <7-> diff --git a/exercises-toolbox/8-all/example-report/templates/latex/theorie_tex_template b/exercises-toolbox/8-all/example-report/templates/latex/theorie_tex_template new file mode 100644 index 00000000..ade27c4e --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/latex/theorie_tex_template @@ -0,0 +1,74 @@ +\section{Theorie} % <7-> +\label{sec:Theorie} % <9-> + % <7-> +Wie in der Abbildung \autoref{fig:experimental-setup} veranschaulicht, beginnen die Objekte % <9-> +in einer Höhe $h$ auf der schiefen Ebene in vollkommener Ruhe. % <9-> + % <7-> +\begin{figure} % <9-> + \centering % <9-> + \includegraphics[width=0.5\textwidth]{graphics/versuchsaufbau.png} % <9-10> + \begin{tikzpicture}[scale=3] % <11-> + \draw (0,0) -- (3,0) --node[below, near end]{$l$} (0,1) -- cycle; % <11-> + \draw (0.25,1.19)node[below]{$m$} circle (0.25cm); % <11-> + \draw[->] (0.25,1.19) -- (0.90, 0.94) node[above] {\small$\vec{v}$}; % <11-> + \draw[|-|] (-0.15,0.95) -- node[left]{$h$} (-0.15, 0); % <11-> + \draw[dashed,opacity=0.65] (0.94,0.96) circle (0.25cm); % <11-> + \draw[dashed,opacity=0.40] (1.75,0.68) circle (0.25cm); % <11-> + \draw[dashed,opacity=0.25] (3.,0.26) circle (0.25cm); % <11-> + \draw[->] (0.25, 1.03) arc (270:50:0.16) node[below]{\small$\omega$}; % <11-> + \end{tikzpicture} % <11-> + \caption{Schematische Darstellung des Versuchsaufbaus. Das runde Objekt (Kugel oder Zylinder) wird in der Höhe $h$ % <9-> + auf eine schiefe Ebene gelegt, sodass es aus der Ruhe herabrollt. Die Bewegung ist beschleunigt, sodass sowohl % <9-> + die Geschwindigkeit $\vec{v}(t)$ sowie die Winkelgeschwindigkeit $\omega(t)$ nicht konstant sind.} % <9-> + \label{fig:experimental-setup} % <9-> +\end{figure} % <9-> + % <7-> +Zwischen Ebene und Objekten wirkt eine nicht zu vernachlässigende Reibung, wodurch die % <7-> +Objekte nach dem loslassen in Rotation versetzt werden, also tatsächlich herabrollen. % <7-> +Thermische Reibungsverluste werden jedoch vernächlässigt, sodass Energieerhaltung % <7-> +angenommen werden kann. Nach dieser gilt % <7-> + % <7-> +\begin{align*} % <8-> +E^\text{pot}_\text{i} &= E^\text{kin}_\text{f} + E^\text{rot}_\text{f} \\ % <8-> +mgh &= \frac{m}{2}v^2 + \frac{I}{2}\omega^2 \quad\big|\,\omega = \frac{v}{r} \\ % <8-> +mgh &= \frac{m}{2}v^2 + \frac{I}{2}\frac{v^2}{r^2}\quad\big|\, :mgh \\ % <8-> +1 &= \frac{v^2}{2gh} \left(1 + \frac{I}{mr^2} \right)\\ % <8-> + \intertext{aus der Kinematik~\cite{kuypers2016klassische} ist bekannt, dass die Endgeschwindigkeit einer % <8-> +beschleunigten Bewegung (in der Zeit $t$, entlang einer Strecke $l$) $v = \frac{2l}{t}$ ist. % <8-> +Es gilt also} % <8-> +1 &= \left(\frac{2l}{t}\right)^2 \frac{1}{2gh} \left(1 + \frac{I}{mr^2} \right)\quad\big|\, \cdot t^2 \\ % <8-> +\addtocounter{equation}{1} % <8-> +t^2 &= \frac{2l^2}{gh} \left(1 + \frac{I}{mr^2} \right) % <8-> +\label{eq:tsquared}\tag{\theequation} % <9-> +\end{align*} % <8-> + % <7-> +Aus \eqref{eq:tsquared} ergeben sich dann die jeweiligen Ausgleichsfunktionen für beide Versuchsteile. % <9-> + % <7-> +Für die Bestimmung der Trägheitsmomente wird nur noch die Quadratwurzel von \eqref{eq:tsquared} % <9-> +berechnet und ein Startzeit als Parameter hinzugefügt, % <7-> + % <7-> +\begin{equation} % <8-> +t(h) = \sqrt{\frac{2l^2}{gh} \left(1 + \frac{I}{mr^2} \right)} + t_0. % <8-> +\label{eq:fit-function-I} % <9-> +\end{equation} % <8-> + % <7-> +Dabei sind das Trägheitsmoment $I$ und die Startzeit $t_0$ die Parameter für die Ausgleichsrechnung. % <8-> + % <7-> +Für die Bestimmung der Gravitationsbeschleunigung $g$ unter Annahme der theoretischen Trägheitsmomente % <8-> +für Kugel $I_\text{K}$ und Hohlzylinder $I_\text{Z}$ % <8-> +\begin{align*} % <8-> + I_{\text{K}} = \frac{2}{5}mr_{\text{K}}^2 && I_{\text{Z}} = \frac{m}{2}\left(r_{\text{Z},\text{innen}}^2 + r_{\text{Z},\text{außen}}^2)\right), % <8-> +\end{align*} % <8-> +ergeben sich die folgenden Ausgleichsfunktionen % <7-> + % <7-> +\begin{align} % <8-> +t_\text{K}(h) &= \sqrt{\frac{2l^2}{gh} \left(\frac{7}{5}\right)} + t_0 % <8-> +\label{eq:fit-function-g-ball} % <9-> +% % <8-> +\intertext{und} % <8-> +% % <8-> +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.% <8-> +\label{eq:fit-function-g-cylinder} % <9-> +\end{align} % <8-> +Dabei sind in diesen Gleichungen $g$ und $t_0$ die Ausgleichsparameter. % <8-> + diff --git a/exercises-toolbox/8-all/example-report/templates/latex/v16516_tex_template b/exercises-toolbox/8-all/example-report/templates/latex/v16516_tex_template new file mode 100644 index 00000000..0665e102 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/latex/v16516_tex_template @@ -0,0 +1,27 @@ +\input{../header.tex} % <7-> + +\usepackage{tikz} % <11-> + % <7-> +\subject{V16516} % <7-> +\title{Die schiefe Ebene} % <7-> +\date{% % <7-> + Durchführung: 29.09.2023 % <7-> + \hspace{3em} % <7-> + Abgabe: 04.10.2024 % <7-> +} % <7-> + % <7-> +\begin{document} % <7-> + % <7-> +\maketitle % <7-> +\thispagestyle{empty} % <7-> +\tableofcontents % <7-> +\newpage % <7-> + % <7-> +\input{content/theorie.tex} % <7-> +\input{content/durchfuehrung.tex} % <7-> +\input{content/auswertung.tex} % <7-> +\input{content/diskussion.tex} % <7-> + % <7-> +\printbibliography{} % <9-> + % <9-> +\end{document} % <7-> diff --git a/exercises-toolbox/8-all/example-report/templates/latex_formatting.py b/exercises-toolbox/8-all/example-report/templates/latex_formatting.py new file mode 100644 index 00000000..61069449 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/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/example-report/templates/lit.bib b/exercises-toolbox/8-all/example-report/templates/lit.bib new file mode 100644 index 00000000..f1915e13 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/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/example-report/templates/matplotlibrc b/exercises-toolbox/8-all/example-report/templates/matplotlibrc new file mode 100644 index 00000000..1746ade8 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/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/example-report/templates/output_snapshot.txt b/exercises-toolbox/8-all/example-report/templates/output_snapshot.txt new file mode 100644 index 00000000..e19c03c1 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/output_snapshot.txt @@ -0,0 +1,653 @@ + +Output of 'build/report-example-step-1/loesung//auswertung.py': + +Output of 'build/report-example-step-2/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000203588707139895 +Trägheitsmoment (Zylinder) +0.00014610097410365817 +Messwerte (Kugel) +alle Zeiten +[1.86666667 1.83333333 1.9 1.16666667 1.2 1.16666667 + 0.93333333 0.93333333 0.9 0.8 0.8 0.8 + 0.7 0.7 0.7 0.63333333 0.63333333 0.7 ] +alle Höhen +[0.045 0.045 0.045 0.1 0.1 0.1 0.15 0.15 0.15 0.2 0.2 0.2 + 0.25 0.25 0.25 0.3 0.3 0.3 ] +Höhe +[0.045 0.1 0.15 0.2 0.25 0.3 ] +gemittlelte Zeit +[1.86666667 1.17777778 0.92222222 0.8 0.7 0.65555556] + + +Messwerte (Zylinder) +alle Höhen +[0.045 0.045 0.045 0.1 0.1 0.1 0.15 0.15 0.15 0.2 0.2 0.2 + 0.25 0.25 0.25 0.3 0.3 0.3 ] +alle Zeiten +[2.16666667 1.96666667 2.13333333 1.33333333 1.3 1.3 + 1.03333333 1.06666667 1.1 0.93333333 0.93333333 0.96666667 + 0.8 0.83333333 0.76666667 0.73333333 0.7 0.73333333] +Höhe +[0.045 0.1 0.15 0.2 0.25 0.3 ] +gemittlelte Zeit +[2.08888889 1.31111111 1.06666667 0.94444444 0.8 0.72222222] + + +Output of 'build/report-example-step-3/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000203588707139895 +Trägheitsmoment (Zylinder) +0.00014610097410365817 +Messwerte (Kugel) +alle Zeiten +[1.86666667 1.83333333 1.9 1.16666667 1.2 1.16666667 + 0.93333333 0.93333333 0.9 0.8 0.8 0.8 + 0.7 0.7 0.7 0.63333333 0.63333333 0.7 ] +alle Höhen +[0.045 0.045 0.045 0.1 0.1 0.1 0.15 0.15 0.15 0.2 0.2 0.2 + 0.25 0.25 0.25 0.3 0.3 0.3 ] +Höhe +[0.045 0.1 0.15 0.2 0.25 0.3 ] +gemittlelte Zeit +[1.86666667 1.17777778 0.92222222 0.8 0.7 0.65555556] + + +Messwerte (Zylinder) +alle Höhen +[0.045 0.045 0.045 0.1 0.1 0.1 0.15 0.15 0.15 0.2 0.2 0.2 + 0.25 0.25 0.25 0.3 0.3 0.3 ] +alle Zeiten +[2.16666667 1.96666667 2.13333333 1.33333333 1.3 1.3 + 1.03333333 1.06666667 1.1 0.93333333 0.93333333 0.96666667 + 0.8 0.83333333 0.76666667 0.73333333 0.7 0.73333333] +Höhe +[0.045 0.1 0.15 0.2 0.25 0.3 ] +gemittlelte Zeit +[2.08888889 1.31111111 1.06666667 0.94444444 0.8 0.72222222] + + +Output of 'build/report-example-step-4/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000203588707139895 +Trägheitsmoment (Zylinder) +0.00014610097410365817 +Messwerte (Kugel) +alle Zeiten +[1.86666667 1.83333333 1.9 1.16666667 1.2 1.16666667 + 0.93333333 0.93333333 0.9 0.8 0.8 0.8 + 0.7 0.7 0.7 0.63333333 0.63333333 0.7 ] +alle Höhen +[0.045 0.045 0.045 0.1 0.1 0.1 0.15 0.15 0.15 0.2 0.2 0.2 + 0.25 0.25 0.25 0.3 0.3 0.3 ] +Höhe +[0.045 0.1 0.15 0.2 0.25 0.3 ] +gemittlelte Zeit +[1.86666667 1.17777778 0.92222222 0.8 0.7 0.65555556] + + +Messwerte (Zylinder) +alle Höhen +[0.045 0.045 0.045 0.1 0.1 0.1 0.15 0.15 0.15 0.2 0.2 0.2 + 0.25 0.25 0.25 0.3 0.3 0.3 ] +alle Zeiten +[2.16666667 1.96666667 2.13333333 1.33333333 1.3 1.3 + 1.03333333 1.06666667 1.1 0.93333333 0.93333333 0.96666667 + 0.8 0.83333333 0.76666667 0.73333333 0.7 0.73333333] +Höhe +[0.045 0.1 0.15 0.2 0.25 0.3 ] +gemittlelte Zeit +[2.08888889 1.31111111 1.06666667 0.94444444 0.8 0.72222222] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 1.932 ± 0.304 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + +Output of 'build/report-example-step-5/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000204+/-0.000013 +Trägheitsmoment (Zylinder) +0.000146+/-0.000016 +Messwerte (Kugel) +alle Zeiten +[1.8666666666666667+/-0.04714045207910317 + 1.8333333333333333+/-0.04714045207910317 1.9+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 1.2+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 0.9+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317] +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[1.8666666666666665+/-0.027216552697590865 + 1.1777777777777778+/-0.027216552697590865 + 0.9222222222222222+/-0.027216552697590865 + 0.8000000000000002+/-0.027216552697590865 + 0.6999999999999998+/-0.027216552697590865 + 0.6555555555555556+/-0.027216552697590865] + + +Messwerte (Zylinder) +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +alle Zeiten +[2.1666666666666665+/-0.04714045207910317 + 1.9666666666666666+/-0.04714045207910317 + 2.1333333333333333+/-0.04714045207910317 + 1.3333333333333333+/-0.04714045207910317 1.3+/-0.04714045207910317 + 1.3+/-0.04714045207910317 1.0333333333333334+/-0.04714045207910317 + 1.0666666666666667+/-0.04714045207910317 1.1+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9666666666666667+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8333333333333334+/-0.04714045207910317 + 0.7666666666666667+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[2.0888888888888886+/-0.027216552697590865 + 1.3111111111111111+/-0.027216552697590865 + 1.0666666666666667+/-0.027216552697590865 + 0.9444444444444445+/-0.027216552697590865 + 0.7999999999999999+/-0.027216552697590865 + 0.7222222222222222+/-0.027216552697590865] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 0.417 ± 0.066 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + +Output of 'build/report-example-step-6/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000204+/-0.000013 +Trägheitsmoment (Zylinder) +0.000146+/-0.000016 +Messwerte (Kugel) +alle Zeiten +[1.8666666666666667+/-0.04714045207910317 + 1.8333333333333333+/-0.04714045207910317 1.9+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 1.2+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 0.9+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317] +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[1.8666666666666665+/-0.027216552697590865 + 1.1777777777777778+/-0.027216552697590865 + 0.9222222222222222+/-0.027216552697590865 + 0.8000000000000002+/-0.027216552697590865 + 0.6999999999999998+/-0.027216552697590865 + 0.6555555555555556+/-0.027216552697590865] + + +Messwerte (Zylinder) +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +alle Zeiten +[2.1666666666666665+/-0.04714045207910317 + 1.9666666666666666+/-0.04714045207910317 + 2.1333333333333333+/-0.04714045207910317 + 1.3333333333333333+/-0.04714045207910317 1.3+/-0.04714045207910317 + 1.3+/-0.04714045207910317 1.0333333333333334+/-0.04714045207910317 + 1.0666666666666667+/-0.04714045207910317 1.1+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9666666666666667+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8333333333333334+/-0.04714045207910317 + 0.7666666666666667+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[2.0888888888888886+/-0.027216552697590865 + 1.3111111111111111+/-0.027216552697590865 + 1.0666666666666667+/-0.027216552697590865 + 0.9444444444444445+/-0.027216552697590865 + 0.7999999999999999+/-0.027216552697590865 + 0.7222222222222222+/-0.027216552697590865] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 0.417 ± 0.066 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + +Output of 'build/report-example-step-7/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000204+/-0.000013 +Trägheitsmoment (Zylinder) +0.000146+/-0.000016 +Messwerte (Kugel) +alle Zeiten +[1.8666666666666667+/-0.04714045207910317 + 1.8333333333333333+/-0.04714045207910317 1.9+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 1.2+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 0.9+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317] +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[1.8666666666666665+/-0.027216552697590865 + 1.1777777777777778+/-0.027216552697590865 + 0.9222222222222222+/-0.027216552697590865 + 0.8000000000000002+/-0.027216552697590865 + 0.6999999999999998+/-0.027216552697590865 + 0.6555555555555556+/-0.027216552697590865] + + +Messwerte (Zylinder) +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +alle Zeiten +[2.1666666666666665+/-0.04714045207910317 + 1.9666666666666666+/-0.04714045207910317 + 2.1333333333333333+/-0.04714045207910317 + 1.3333333333333333+/-0.04714045207910317 1.3+/-0.04714045207910317 + 1.3+/-0.04714045207910317 1.0333333333333334+/-0.04714045207910317 + 1.0666666666666667+/-0.04714045207910317 1.1+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9666666666666667+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8333333333333334+/-0.04714045207910317 + 0.7666666666666667+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[2.0888888888888886+/-0.027216552697590865 + 1.3111111111111111+/-0.027216552697590865 + 1.0666666666666667+/-0.027216552697590865 + 0.9444444444444445+/-0.027216552697590865 + 0.7999999999999999+/-0.027216552697590865 + 0.7222222222222222+/-0.027216552697590865] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 0.417 ± 0.066 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + +Output of 'build/report-example-step-8/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000204+/-0.000013 +Trägheitsmoment (Zylinder) +0.000146+/-0.000016 +Messwerte (Kugel) +alle Zeiten +[1.8666666666666667+/-0.04714045207910317 + 1.8333333333333333+/-0.04714045207910317 1.9+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 1.2+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 0.9+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317] +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[1.8666666666666665+/-0.027216552697590865 + 1.1777777777777778+/-0.027216552697590865 + 0.9222222222222222+/-0.027216552697590865 + 0.8000000000000002+/-0.027216552697590865 + 0.6999999999999998+/-0.027216552697590865 + 0.6555555555555556+/-0.027216552697590865] + + +Messwerte (Zylinder) +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +alle Zeiten +[2.1666666666666665+/-0.04714045207910317 + 1.9666666666666666+/-0.04714045207910317 + 2.1333333333333333+/-0.04714045207910317 + 1.3333333333333333+/-0.04714045207910317 1.3+/-0.04714045207910317 + 1.3+/-0.04714045207910317 1.0333333333333334+/-0.04714045207910317 + 1.0666666666666667+/-0.04714045207910317 1.1+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9666666666666667+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8333333333333334+/-0.04714045207910317 + 0.7666666666666667+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[2.0888888888888886+/-0.027216552697590865 + 1.3111111111111111+/-0.027216552697590865 + 1.0666666666666667+/-0.027216552697590865 + 0.9444444444444445+/-0.027216552697590865 + 0.7999999999999999+/-0.027216552697590865 + 0.7222222222222222+/-0.027216552697590865] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 0.417 ± 0.066 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + +Output of 'build/report-example-step-9/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000204+/-0.000013 +Trägheitsmoment (Zylinder) +0.000146+/-0.000016 +Messwerte (Kugel) +alle Zeiten +[1.8666666666666667+/-0.04714045207910317 + 1.8333333333333333+/-0.04714045207910317 1.9+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 1.2+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 0.9+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317] +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[1.8666666666666665+/-0.027216552697590865 + 1.1777777777777778+/-0.027216552697590865 + 0.9222222222222222+/-0.027216552697590865 + 0.8000000000000002+/-0.027216552697590865 + 0.6999999999999998+/-0.027216552697590865 + 0.6555555555555556+/-0.027216552697590865] + + +Messwerte (Zylinder) +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +alle Zeiten +[2.1666666666666665+/-0.04714045207910317 + 1.9666666666666666+/-0.04714045207910317 + 2.1333333333333333+/-0.04714045207910317 + 1.3333333333333333+/-0.04714045207910317 1.3+/-0.04714045207910317 + 1.3+/-0.04714045207910317 1.0333333333333334+/-0.04714045207910317 + 1.0666666666666667+/-0.04714045207910317 1.1+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9666666666666667+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8333333333333334+/-0.04714045207910317 + 0.7666666666666667+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[2.0888888888888886+/-0.027216552697590865 + 1.3111111111111111+/-0.027216552697590865 + 1.0666666666666667+/-0.027216552697590865 + 0.9444444444444445+/-0.027216552697590865 + 0.7999999999999999+/-0.027216552697590865 + 0.7222222222222222+/-0.027216552697590865] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 0.417 ± 0.066 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + +Output of 'build/report-example-step-10/loesung//auswertung.py': + +Trägheitsmoment (Kugel) +0.000204+/-0.000013 +Trägheitsmoment (Zylinder) +0.000146+/-0.000016 +Messwerte (Kugel) +alle Zeiten +[1.8666666666666667+/-0.04714045207910317 + 1.8333333333333333+/-0.04714045207910317 1.9+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 1.2+/-0.04714045207910317 + 1.1666666666666667+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 0.9+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 + 0.6333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317] +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[1.8666666666666665+/-0.027216552697590865 + 1.1777777777777778+/-0.027216552697590865 + 0.9222222222222222+/-0.027216552697590865 + 0.8000000000000002+/-0.027216552697590865 + 0.6999999999999998+/-0.027216552697590865 + 0.6555555555555556+/-0.027216552697590865] + + +Messwerte (Zylinder) +alle Höhen +[0.045+/-0.005 0.045+/-0.005 0.045+/-0.005 0.1+/-0.005 0.1+/-0.005 + 0.1+/-0.005 0.15+/-0.005 0.15+/-0.005 0.15+/-0.005 0.2+/-0.005 + 0.2+/-0.005 0.2+/-0.005 0.25+/-0.005 0.25+/-0.005 0.25+/-0.005 + 0.3+/-0.005 0.3+/-0.005 0.3+/-0.005] +alle Zeiten +[2.1666666666666665+/-0.04714045207910317 + 1.9666666666666666+/-0.04714045207910317 + 2.1333333333333333+/-0.04714045207910317 + 1.3333333333333333+/-0.04714045207910317 1.3+/-0.04714045207910317 + 1.3+/-0.04714045207910317 1.0333333333333334+/-0.04714045207910317 + 1.0666666666666667+/-0.04714045207910317 1.1+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9333333333333333+/-0.04714045207910317 + 0.9666666666666667+/-0.04714045207910317 0.8+/-0.04714045207910317 + 0.8333333333333334+/-0.04714045207910317 + 0.7666666666666667+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317 0.7+/-0.04714045207910317 + 0.7333333333333333+/-0.04714045207910317] +Höhe +[0.045+/-0.005 0.1+/-0.005 0.15+/-0.005 0.2+/-0.005 0.25+/-0.005 + 0.3+/-0.005] +gemittlelte Zeit +[2.0888888888888886+/-0.027216552697590865 + 1.3111111111111111+/-0.027216552697590865 + 1.0666666666666667+/-0.027216552697590865 + 0.9444444444444445+/-0.027216552697590865 + 0.7999999999999999+/-0.027216552697590865 + 0.7222222222222222+/-0.027216552697590865] + + +Fitparameter (Kugel) +g = 9.952 ± 0.431 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +g = 8.892 ± 0.402 +t = -0.135 ± 0.031 + + +Fitparameter (Kugel) +I = 0.417 ± 0.066 +t = -0.148 ± 0.027 + + +Fitparameter (Zylinder) +I = 1.897 ± 0.212 +t = -0.135 ± 0.031 + + diff --git a/exercises-toolbox/8-all/example-report/templates/programme.bib b/exercises-toolbox/8-all/example-report/templates/programme.bib new file mode 100644 index 00000000..efe7aa60 --- /dev/null +++ b/exercises-toolbox/8-all/example-report/templates/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/example-report/templates/versuchsaufbau.png b/exercises-toolbox/8-all/example-report/templates/versuchsaufbau.png new file mode 100644 index 00000000..16dbdf8c Binary files /dev/null and b/exercises-toolbox/8-all/example-report/templates/versuchsaufbau.png differ