Commit ce06cd71 authored by Brose, Jens's avatar Brose, Jens
Browse files

Initial commit

parents
.ipynb_checkpoints
*~
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"collapsed": false
},
"source": [
"# Übungsaufgabe zur Monte-Carlo-Methode"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Wir betrachten die Ladungen $q_1$ und $q_2$, welche einen Abstand $r$ zueinander\n",
"haben. Es sei bekannt, dass die verwendeten Messgeräte normalverteilte Messpunkte in Bezug auf den Datenpunkt mit der\n",
"gegebenen Unsicherheit bestimmen.\n",
"\n",
"Gegeben sei:\n",
"\\begin{align*}\n",
"q_1 & = 1 \\cdot 10^{-6}~\\text{C} \\\\\n",
"q_2 & = 2 \\cdot 10^{-5}~\\text{C} \\\\\n",
"r & = 0.1~\\text{m}\n",
"\\end{align*}\n",
"\n",
"Angenommen, alle Messergebnisse wurden mit einer Unsicherheit von $1\\%$ ermittelt. Simulieren Sie aus diesen Daten je $N = 1000000$ Werte für jede Messgröße und schätzen Sie darüber die Coulombkraft $F_C$ mit ihrer Unsicherheit ab.\n",
"\n",
"Zur Erinnerung:\n",
"\\begin{align*}\n",
"F_C &= k \\cdot \\frac{q_1 \\cdot q_2}{r^2} \\\\\n",
"\\text{mit}~k & = \\frac{1}{4\\pi\\varepsilon_0} =~\\text{const.}\n",
"\\end{align*}\n",
"\n",
"Sie können dafür nach der gegebenen Anleitung vorgehen:"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"0. Import benötigter Module"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"import"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"1. Helferklasse für Simulation erstellen. (Zur Erinnerung: Wir fügen schrittweise neue Methoden hinzu und verwenden\n",
" das Prinzip der Vererbung, um die Methoden schrittweise mitzunehmen.\n",
" a) Konstruktor"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"class MonteCarloStep1:\n",
" \"\"\"\n",
" Helferklasse zur Anwendung der Monte-Carlo-Methode auf ein mehrdimensionales Problem mit normalverteilten Daten\n",
" \"\"\"\n",
"\n",
" def __init__(self, funct, variables: tuple, uncertainties: tuple, samples: int, args: tuple=tuple()):\n",
" \"\"\"\n",
" Berechnung vorbereiten\n",
"\n",
" Parameters:\n",
" ----------\n",
" funct: Funktion, welche auf die generierten Datensätze angewandt werden soll.\n",
" variables: Variablen, auf die die Monte-Carlo-Methode angewendet werden soll\n",
" (in der Reihenfolge, wie funct sie entgegen nimmt).\n",
" uncertainties: Standardabweichung für Variablen (in der gleichen Reihenfolge).\n",
" samples: Anzahl zu generierender Datenpunkte je Datensatz.\n",
" args: Tupel mit weiteren Parametern für funct.\n",
" \"\"\"\n",
" if len(variables) != len(uncertainties):\n",
" raise ValueError(\"Arrays Variablen und Unsicherheiten müssen die gleiche Länge haben.\")\n",
" if type(samples) != int:\n",
" raise TypeError(\"Samples muss eine ganze Zahl sein.\")\n",
" if samples < 1:\n",
" raise ValueError(\"Samples muss positiv sein.\")\n",
" self._callee = funct\n",
" self._variables = variables\n",
" self._uncertainties = uncertainties\n",
" self._samples = samples\n",
" self._callee_args = args\n",
" # Zwischenspeicher für berechnete Funktionswerte, um diese nicht mehrfach neu berechnen zu müssen.\n",
" self._randomized_function = None"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"1. b) Variablen normalverteilen. Iterieren Sie hierzu über die Liste mit Variablen und wenden Sie eine\n",
" Normalverteilungsfunktion darauf an."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"class MonteCarloStep2(MonteCarloStep1):\n",
"\n",
" def _randomize_vars(self):\n",
" \"\"\"\n",
" Alle bekannten Variablen normalverteilen\n",
"\n",
" Returns:\n",
" Tupel von Numpy-Arrays mit generierten Datensätzen für jede Variable\n",
" \"\"\"\n",
" # Hier folgt Ihr Code\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"1. c) Funktionswerte für jeden Datenpunkt bestimmen. O.b.d.A. können Sie jeweils die $i$-ten Elemente aus den Arrays\n",
" mit den generierten Datensätzen verwenden, um das $i$-te Element des Funktionswertarrays zu berechnen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"class MonteCarloStep3(MonteCarloStep2):\n",
"\n",
" def randomized_function(self):\n",
" \"\"\"\n",
" Berechne normalverteilte Funktionswerte\n",
"\n",
" Returns:\n",
" Normalverteilte Funktionswerte als Numpy-Array\n",
" \"\"\"\n",
" # Hier folgt Ihr Code. Berücksichtigen Sie die Existenz von self._callee_args!\n",
"\n",
" # Speichern Sie vor der Rückgabe das Array in self._randomized_function, damit es nicht häufiger als nötig\n",
" # neu berechnet werden muss.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"1. d) Statistische Auswertung der generierten Funktionswerte. Bestimmen Sie hier den Mittelwert und die\n",
" Standardabweichung der soeben generierten Funktionswerte. Überlegen Sie sich eine geeignete Textausgabe der\n",
" Parameter."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"class MonteCarloStep4(MonteCarloStep3):\n",
"\n",
" def _as_stat(self):\n",
" \"\"\"\n",
" Berechne statistische Eigenschaften der berechneten Funktionswerte\n",
"\n",
" Returns:\n",
" --------\n",
" Mittelwert und Standardabweichung\n",
" \"\"\"\n",
" # Falls self.randomized_function noch nicht aufgerufen wurde Funktionswerte generieren und speichern\n",
" if self._randomized_function is None:\n",
" self._randomized_function = self.randomized_function()\n",
" # Hier folgt Ihr Code. Beachten Sie, dass die generierten Funktionswerte den Freiheitsgrad 1 haben.\n",
"\n",
" def __str__(self):\n",
" \"\"\"\n",
" Darstellung der Ergebnisse als str\n",
"\n",
" Returns:\n",
" --------\n",
" Bleibt Ihnen überlassen.\n",
" \"\"\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"1. e) Vorbereitung der grafischen Auswertung. Um die Details der Verteilung sichtbar zu machen, soll noch ein Histogramm\n",
" der Funktionswerte sowie die Kurve der approximierten Normalverteilung angezeigt werden. Bereiten Sie die Ausgabe\n",
" vor, indem Sie das Histogramm über die Funktionswerte berechnen. Berechnen Sie weiterhin eine Normalverteilung für\n",
" die Intervallgrenzen aus `_as_histogram` und die statistischen Parameter aus `_as_stat`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"class MonteCarloStep5(MonteCarloStep4):\n",
"\n",
" def _as_histogram(self, bin_count):\n",
" \"\"\"\n",
" Berechne die Häufigkeitsverteilung\n",
"\n",
" Parameters:\n",
" ----------\n",
" bin_count: Anzahl zu verwendender Intervalle\n",
"\n",
" Returns:\n",
" --------\n",
" Intervallmitten und die zugehörigen relativen Häufigkeiten\n",
" \"\"\"\n",
" # Falls self.randomized_function noch nicht aufgerufen wurde Funktionswerte generieren und speichern\n",
" if self._randomized_function is None:\n",
" self._randomized_function = self.randomized_function()\n",
" # Hier folgt Ihr Code.\n",
"\n",
"\n",
" def _as_normal_approximation(self, bin_count):\n",
" \"\"\"\n",
" Berechne eine (kontinuierliche) Normalverteilung\n",
"\n",
" Parameters:\n",
" ----------\n",
" bin_count: Anzahl zu verwendender Intervalle\n",
"\n",
" Returns:\n",
" --------\n",
" Intervallmitten und berechnete Werte der Normalverteilung\n",
" \"\"\"\n",
" # Bestimme Intervallmitten\n",
" bins = self._as_histogram(bin_count)[0]\n",
" # Hier folgt Ihr Code.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"1. f) Grafische Ausgabe."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"class MonteCarlo(MonteCarloStep5):\n",
"\n",
" def plot(self, pl, bin_count=75):\n",
" \"\"\"\n",
" Stelle das Histogramm und die Normalverteilung dar, welche aus den gegebenen Parametern bestimmt wurde.\n",
"\n",
" Parameters:\n",
" ----------\n",
" pl: PyPlot-Umgebung, zu welcher das Diagramm hinzugefügt werden soll\n",
" bin_count: Anzahl zu verwendender Intervalle\n",
"\n",
" Returns:\n",
" --------\n",
" Nichts, aber fügt die Diagramme zur gegebenen PyPlot-Umgebung hinzu\n",
" \"\"\"\n",
" if self._randomized_function is None:\n",
" self._randomized_function = self.randomized_function()\n",
" histogram = self._as_histogram(bin_count)\n",
" # Die Breite der Streifen im Diagramm wurde experimentell ermittelt.\n",
" pl.bar(*histogram, width=0.45 / len(histogram[0]) * histogram[0].ptp())\n",
" pl.plot(*self._as_normal_approximation(bin_count), color=\"red\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Wir rufen nun zusammenfassend die Referenzdokumentation unserer Implementierung auf. Sie enthält alle nach außen\n",
"sichtbaren Methoden der `MonteCarlo`-Klasse"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"help(MonteCarlo)"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Der damit gegebenen Anleitung folgend können wir jetzt ein Objekt erstellen, welches unser Problem repräsentiert:\n",
"\n",
"2. Funktion für die Berechnung der Coulombkraft schreiben"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"def coulomb_force(q1, q2, r, eps_r=1):\n",
" \"\"\"\n",
" Berechne die Coulomb-Kraft zwischen zwei elektrischen Ladungen unter Berücksichtigung der relativen Permittivität\n",
"\n",
" Parameters:\n",
" ----------\n",
" q1: Erste Ladung\n",
" q2: Zweite Ladung\n",
" r: Abstand zwischen den Ladungen\n",
" eps_r: Relative Permittivität (default 1)\n",
"\n",
" Returns:\n",
" --------\n",
" Coulomb-Kraft\n",
" \"\"\"\n",
" # Hier folgt Ihr Code.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"3. Variablen und Unsicherheiten festlegen"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"q1_val =\n",
"q2_val =\n",
"r_val =\n",
"# relative Unsicherheit als Gleitkommazahl\n",
"d_rel =\n",
"\n",
"# Variablenreihenfolge beachten!\n",
"mc_vars = (q1_val, q2_val, r_val)\n",
"mc_uncertainties = (x * d_rel for x in mc_vars)"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"4. `MonteCarlo`-Klasse instanziieren und Ergebnisse darstellen"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"# Samples\n",
"N = 1000000\n",
"\n",
"# Plot einrichten\n",
"import matplotlib.pyplot as plt\n",
"plt.figure(figsize=(16, 8))\n",
"plt.title(\"Monte-Carlo-Methode\")\n",
"mc = MonteCarlo(coulomb_force, mc_vars, mc_uncertainties, N)\n",
"# Ausgabe der berechneten Verteilparameter, falls so definiert\n",
"print(\"F = ({}) N\".format(mc))\n",
"# Darstellung\n",
"mc.plot(plt)\n",
"plt.xlabel(\"$F_C~/$ N\")\n",
"plt.ylabel(\"relative Häufigkeit\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Referenz: $F_{C,MC} = (17.98 \\pm 0.44)~\\text{N}$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"%run -i exercises/statistics/ex3_sol"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": false,
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Sie können dieses Dokument unter `File -> Download as` exportieren, um es als zukünftige Referenz\n",
"aufzubewahren. Der Server speichert die Daten mindestens bis zum Ende des Kurses."
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Kursmaterial nur für den universitätsinternen Gebrauch.\n",
"\n",
"Konzeption: [Konstantin Köhring](https://www.galaxy102.de)\n",
"Betreuung: [Dr. Jens Brose](https://tu-dresden.de/mn/physik/die-fakultaet/it-service/jens-brose)\n",
"\n",
"Technische Universität Dresden\n",
"01062 Dresden\n",
"\n",
"Tel.: +49 (0) 351 463-32104"
]
}
],
"metadata": {
"hide_input": false,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.6"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 0
}
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"collapsed": false
},
"source": [
"# Übungsaufgaben zur Numerischen Differentiation"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"## Apollo 13\n",
"\n",
"Die Mondlandefähre der [Apollo 13-Mission](https://de.wikipedia.org/wiki/Apollo_13) funkte beim Rückstart von der\n",
"Mondoberfläche im Sekundentakt die aktuellen Höhenwerte bis zum Erreichen der stabilen Mondumlaufbahn zur Leitzentrale\n",
"nach Houston."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"
}
},
"outputs": [],
"source": [
"%run -i exercises/nummet/ex2\n",
"print(h_t)\n",
"print(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Implementieren Sie die Methode der direkten Berechnung der zweiten Ableitung $\\frac{\\text{d}^2y}{\\text{d}x^2}$ `diff2`.\n",
"Die Funktion soll zwei `numpy.ndarray` $x$ und $y$ entgegennehmen und ein gleich langes `numpy.ndarray` mit der zweiten\n",
"Ableitung zurückgeben. Berechnen Sie damit die Beschleunigung `a` als zweite Ableitung der Höhe `h_t` nach der Zeit `t`.\n",
"\n",
"Hinweise:\n",
"* Sie dürfen von konstanten Intervalllängen ausgehen.\n",
"* Vermeiden Sie die Verwendung von Schleifen! Schauen Sie sich bei Bedarf den Abschnitt zu _Slices_ im Kapitel über Listen\n",
" an. Überlegen Sie sich, welche Indizes oder Index-Bereiche Sie für die einzelnen Berechnungen benötigen. Python unterstützt\n",
" negative Listen-Indizes.\n",
"* Wegen der Differenzbildung bei der numerischen Differentiation erhält man bei dieser Methode zwei Werte weniger,\n",
" als Eingabedaten zur Verfügung stehen. Sollten Sie eine Abhängikeit zur Ableitungsvariable herstellen wollen,\n",
" so werden von dem Array der Ableitungsvariablen der erste und der letzte Wert nicht verwendet. (hier nicht nötig)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%% python\n"