Vorlesung 1

Jede quantitative Beschreibung von Vorgängen, nicht nur im Bereich der Physik, benutzt mathematische Zusammenhänge, um das zu beschreibende System zu verstehen. Oft sind diese mathematischen Gleichungen in Form von Bewegungsgleichungen formuliert, deren Lösungen man dann zu bestimmen und analysieren hat. Für einfache physikalische Probleme ist eine solche Lösung auf analytisch mathematischem Weg möglich, jedoch je komplexer (bzw. je realitäts-näher) das zu untersuchende Problem wird, desto komplizierter wird auch dessen Lösung und oft ist es dann auf analytischem Weg nicht mehr möglich eine zusammenhängende mathematische Lösungsgleichung zu finden. Der Computer kann einem bei solchen Problemen in vielschichtiger Weise helfen und in dieser Vorlesung sollen die Studierenden lernen, wie man dem Computer das Problem erklärt, sodass er die numerische Lösung bestimmen kann. Für die Programmierung benötigt man einerseits das Vokabular einer gängigen objektorientierten Programmiersprache (z.B. C++) und andererseits eine auf Algorithmen basierende gründende Vorgehensweise, die die zugrundeliegenden physikalischen Gleichungen numerisch, in einem iterativen Prozess löst, um diese dann grafisch darstellen und analysieren zu können.

Nach einem kurzen Überblick in die Inhalte der gesamten Vorlesung werden die Grundlagen des Betriebssystems Linux behandelt und einige der aktuellen Programmiersprachen kurz vorgestellt. In der Vorlesung wird der Schwerpunkt auf der Programmiersprache C++ liegen und für die Visualisierung der berechneten Daten wird die Skriptsprache Python benutzt. Zusätzlich werden die berechneten mathematisch/physikalischen Gleichungen mittels der web-basierten interaktiven Programmierumgebung in Jupyter-Notebook-Dokumenten behandelt und analysiert.

Vorlesung 2

Es geschieht einem theoretischen Physiker leider nur zu oft, dass er ein System beschreiben möchte, welches er auf analytischem, mathematischem Weg nicht lösen kann. Betrachten wir z.B. das einfache physikalische Pendel aus dem Themenbereich der Mechanik (siehe z.B. W.Greiner, Klassische Mechanik I). Die zugrundeliegende Differentialgleichung (DGL) des Problems lautet \[ \begin{equation} \frac{d^2 \phi(t)}{dt^2} = -\frac{g}{l} \cdot \hbox{sin}\left( \phi(t) \right) \quad , \end{equation} \] wobei $g$ die Erdbeschleunigung, $l$ die Länge des Pendels und $\phi(t)$ die zeitliche Entwicklung des Pendelwinkels beschreibt. Ungünstigerweise besitzt diese DGL keine analytisch darstellbare Lösung und gewöhnlich vereinfacht man dann das zu beschreibende System (z.B. durch Approximation zum mathematischen Pendel) und gelangt auf diesem Wege doch zu analytischen Lösungen, deren Verhalten man studieren kann. Vergleicht man die Lösung dann mit der Realität, stimmt diese oft nur unter gewissen Randbedingungen. Nimmt man jedoch Anfangswerte des Pendels, die außerhalb des Gültigkeitsbereiches der approximierten Lösung liegen, weichen die Vorhersagen der Pendelbewegung deutlich von der wirklichen Lösung ab. Stoßen wir z.B. das Pendel mit einem sehr starken "Schubs" aus seiner Ruhelage, so stimmt die analytische Lösung des mathematischen Pendels nicht und das wirkliche Pendel verhält sich vollkommen anders. Die folgenden Animationen entstammen einem Python Jupyter Notebook und sie vergleichen die numerische Lösung des physikalischen Pendels mit der analytischen Lösung des mathematischen Pendels, bei der ein Pendelüberschlag nicht möglich ist.

Anhand dieses Beispiels sollte die Sinnhaftigkeit von numerischen Computersimulationen verdeutlicht werden. Nun muss ich aber die Studierenden dieser Vorlesung an dieser Stelle leider schon auch gleich wieder enttäuschen, denn numerische Simulationen sind vom Grunde her nicht genau und stets mit einem nicht reduzierbarem Fehler behaftet. In dieser zweiten Vorlesung werden die Grundlagen der Programmiersprache C++ behandelt (Datentypen und Variablen, Arithmetik und Operatoren und die Ein- und Ausgabe) und der Zahlenraum ℝ$_C$ in dem der Computer rechnet definiert und die damit verbundene Rechenungenauigkeit verdeutlicht.

Vorlesung 3

In dieser Vorlesung werden wir die wohl wichtigste Form von C++ Anweisungen, die sogenannten Schleifenanweisungen, kennenlernen. Die Schleifenanweisungen stellen einen iterativen Anweisungsprozess dar und können in Form von for-, while- oder do-Anweisung ausgedrückt werden. Möchte man z.B. die natürlichen Zahlen von Null bis 100 im Terminal ausgeben lassen, so kann man dies in einer einfachen Weise mittels einer Schleifenanweisung dem Computer sagen. Die Anwendung von Schleifenanweisung wird danach am Beispiel einer mathematischen Folge und Reihe diskutiert.
Die Visualisierung von Daten, die mittels C++ Programmen erstellt wurden, ist ein wichtiges Teilgebiet eines Programmierers im Bereich der Physik. In dieser Vorlesung werden diverse Python-Skripte und Python Jupyter Notebooks vorgestellt, die zur Visualisierung von Daten und im Bereich der Illustration von mathematisch/physikalischen Gleichungen benutzt werden. Mittels des Python-Moduls "matplotlib" (siehe Matplotlib: Visualization with Python) können auf einem einfachen Weg Bilder and Animationen des zuvor mit C++ simulierten Systems erzeugt werden.

Am Ende der Vorlesung kommen wir nochmals auf den, bereits im Unterkapitel Datentypen und Variablen angesprochenen Zahlenraum des Computers (ℝ$_C$) zurück und diskutieren die zwei wichtigsten Fehlerquellen bei nummerischen Berechnungen (Rundungsfehler und Approximierungsfehler). Der Rundungsfehler ist darin begründet, dass der Zahlenraum des Computers (ℝ$_C$), nur eine relativ kleine Teilmenge der reellen Zahlen benutzt und somit reellwertige Zahlen mit einer unendlichen Anzahl von Nachkommastellen nicht speichern kann. Diese Teilmenge ℝ$_C$ umfasst nur rationale Zahlen und speichert den gebrochenen Teil, der mit Mantisse bezeichnet wird, zusammen mit dem exponentiellen Teil, welchen man Charakteristik nennt als eine binäre Liste von Nullen und Einsen. Die zweite Klasse von nummerischen Fehlern, die Approximierungsfehler werden am Beispiel der approximativen Annäherung an die Kreiszahl $\pi$ mittels der alternierenden Leibniz-Reihe besprochen. Bei dieser Art von Fehlern hat es der Programmierer selbst in der Hand, wie genau er in seinem Programm die Berechnung durchführen möchte (näheres siehe Die Computerarithmetik und der Fehler in numerischen Berechnungen).

Vorlesung 4

Die möglichen integrierten Anweisungsbefehle innerhalb einer Programmiersprache sind die wohl wichtigsten Grundvokabeln, die man als Programmierer kennen muss. In der vorigen Vorlesung hatten wir uns bereits mit den Schleifenanweisungen befasst und in dieser Vorlesung werden wir uns mit den Auswahlanweisungen beschäftigen. Im Speziellen werden die if-Anweisung, die (if-else)-Anweisung und die switch-Anweisung besprochen. Auswahlanweisungen stellen eine Art von Programmverzweigungen dar und sind immer dann anzuwenden, wenn das Programm bei einem gewissen Ereignis etwas Bestimmtes tun soll.
Ein weiteres wichtiges Konzept bei der Erstellung eines C++ Quelltextes ist der Begriff der "Funktion". C++ Funktionen sind ein wichtiges Werkzeug, um den Quelltext eines Programms zu ordnen und wesentliche Algorithmen und zusammenhängende Anweisungsblöcke der main()-Hauptfunktion in einer zusammenhängenden Form auszulagern. Man könnte salopp sagen, dass Funktionen kleine Unterprogramme sind, die definierte Teilprobleme lösen. Im Grunde bedeutet die Definition einer Funktion im Programm nichts Anderes, als eine Code-Block (Anweisungsblock) mit einem Funktionsnamen zu verbinden. In C++ hat das Wort Funktion eine allgemeinere Bedeutung als im Bereich der Mathematik und die in der Mathematik und Physik definierte Funktionen stellen eine echte Teilmenge der C++ Funktionen dar. Wir werden in dieser Vorlesung lediglich eine erste grundsätzliche Einführung in den Themenbereich der C++ Funktionen geben und auf die allgemeinere Verwendung von Funktionen im Laufe der Vorlesung noch genauer eingehen. Gerade in den Unterpunkten, die sich mit der objektorientierten Programmierung befassen, sind Klassen-Funktionen, Konstruktoren und das Überladen von Funktionen ein wichtiges Thema.
Am Ende dieser Vorlesung wenden wir das Erlernte an und besprechen eines der grundlegenden Probleme der numerischen Mathematik: Die Nullstellensuche einer Funktion. Wir nehmen dabei an, dass eine Funktion $f(x)$ im Intervall $[a,b] \in ℝ$ eine Nullstelle hat und berechnen dann diese Nullstelle numerisch, approximativ mittels der Methode der Bisektion und dem Newton-Raphson Algorithmus. Beide Methoden werden in dem Anwendungsbeispiel: Nullstellensuche einer Funktion im Detail besprochen und der zugrundeliegende Algorithmus der Nullstellensuche wird mittels einer Python-Skript Visualisierung verdeutlicht.

Vorlesung 5

Die zugrundeliegenden Gleichungen der Physik sind oft in Form von vektoriellen und matrixwertigen Gleichungen formuliert. Vektoren und Matrizen sind mathematische Konstrukte, die eine Vielzahl von Elementen (Zahlen) in einer gebundenen Form zusammenfassen. Wie deklariert man ein solches zusammengesetztes Konstrukt in einem C++ Programm? An diesem Punkt der Vorlesung wollen wir noch nicht auf das C++ Container Konzept eingehen, welches unter anderem den wichtigen Container vector der Standardbibliothek bereitstellt, sondern wir betrachten uns das schon in alten C-Programmen oft verwendete, integrierte C++ Array Konzept. Ein C++ Array (nicht zu verwechseln mit dem Container array der Standardbibliothek) stellt ein zusammengesetztes Konstrukt von Elementen eines Datentyps dar. Ein Vektor $\vec{v}=\left( 1, 3, 7 \right)$ bestehend aus drei ganzzahligen Elementen kann z.B. mittels des int-Arrays "int v[3] = {1,3,4};" definiert werden. Der Zugriff auf die einzelnen Werte des Arrays erfolgt hierbei durch Angabe seines Indexes, wobei die Elemente von 0 bis 2 indiziert werden (z.B. $v_1=3 \, \rightarrow$ v[1]). Wie wird nun ein solches zusammenhängendes Konstrukt von Zahlen im Hauptspeicher geordnet gespeichert? Da die interne Array-Implementierung der Programmiersprache C++ eng mit dem C++ Zeiger Konzept verknüpft ist, werden wir in dieser Vorlesung zunächst die Begriffe Zeiger, Adresse und Referenz an mehreren Beispielen vorstellen und die eindimensionalen Arrays am Beispiel des Zeichen-Arrays des "HelloWorld" - Programmes zu verdeutlichen (siehe obere Abbildung im linken Frame). Das C++-Zeigerkonzept ist der grundlegende integrierte Sprachmechanismus, um den Zugriff auf den Hauptspeicher des Computers direkt zu ermöglichen. Zusätzlich wird darauf eingegangen, wie man Arrays an C++ Funktionen übergibt.
Das erlernte C++ Array Konzept wird dann an dem Beispiel der Methode der Lagrange Polynome verdeutlicht. Die Lagrange Polynome Methode ist ein wichtiges Teilgebiet der numerischen Mathematik und es befasst sich mit der Problematik ein Polynom vom Grade $n$ ($P_n(x)$) mittels einer gegebenen Menge von ($n+1$) Stützstellenpunkten zu bestimmen. Das Verfahren wird bei einer Vielzahl von numerischen Algorithmen verwendet, bei denen eine vorgegebene Funktion $f(x)$ durch ein Polynom $P_n(x)$, mittels der Angabe der ($n+1$) x-Werte der Stützstellenpunkten ($\vec{x}=\left( x_0, x_1, \, ... \,, x_n \right)$), approximiert wird. Die untere Abbildung im linken Frame veranschaulicht z.B. das Lagrange Polynom $P_6(x)$ dar, welches die Funktion $f(x)=1/x$ mittels der sieben Stützstellen $\vec{x}=\left( 1, 1.5, 2, 2.5, 3, 5, 7 \right)$ approximiert. Die Methode der Lagrange Polynome ist ein wichtiges Hilfsmittel der numerischen Mathematik, jedoch wird sie selten in Programmen verwendet, da es numerisch geeignetere Methoden der Interpolation gibt. Wie wir im nebenstehenden Anwendungsbeispiel sehen werden, unterscheidet sich das approximierte Lagrange Polynom oft erheblich von der wirklichen Funktion und bei einer Verwendung einer großen Anzahl von Stützstellen oszilliert das approximierte Polynom von hohem Grade oft teils erheblich um $f(x)$. Mittels einer stückweisen Polynomapproximation (z.B. die kubische Spline-Interpolation) kann oft eine bessere nummerische Approximation erzielt werden (näheres siehe Vorlesung 9).

Vorlesung 6

Im ersten Teil dieser Vorlesung werden wir uns zunächst mit der Deklaration von mehrdimensionale C++ Arrays befassen. Zwei dimensionale C++ Zahlen-Arrays entsprechen der numerischen Implementierung von zwei dimensionale Matrizen, welche in der Physik eine bedeutende Rolle spielen. Möchten wir z.B. eine $(m \times n)$-Matrix ${\bf \cal A} = (a_{ij})_{i=1,2,...,m \, ; \, j=1,2,...,n}$), bestehend aus Gleitkommazahlen vom Typ double in einem C++ Programm als ein integriertes Array deklarieren, so würden wir die folgende Anweisung in den Quelltext schreiben: \[ \begin{equation} {\bf \cal A} =\left( \begin{array}{cccc} a_{11} & a_{12} & ... & a_{1n}\\ a_{21}& a_{22}& ...&a_{2n} \\ ...& ...& ...& ...\\ a_{m1}& a_{m2}& ...& a_{mn}\\ \end{array} \right) \, \Longrightarrow \, \hbox{Deklaration: double A[m][n];} \end{equation} \] In gleicher Weise wie auch bei eindimensionalen Arrays sind mehrdimensionale C++ Arrays mittels des Konstruktes des Zeigers implementiert und die einzelnen Elemente eines Arrays (z.B. "double A[m][n]") sind im Hauptspeicher in Form von Zeigern/Referenzen geordnet.
Der zweite Teil der Vorlesung befasst sich mit dem Thema der numerischen Differentiation. Die Ableitung (Differentiation) einer Funktion stellt ein fundamentales Konzept der Mathematik dar, welches bei der Formulierung von physikalischen Bewegungsgleichungen essenziell ist. Die mathematische Definition der Ableitung einer Funktion, der sogenannte Differentialquotient, benutzt dabei eine Grenzwert-Formulierung ($h \to 0$), wobei in der numerischen Mathematik hingegen mehrere Differentiationsregeln formuliert werden, die den wirklichen Wert der Ableitung approximieren. Die analytische Herleitung dieser Regeln benutzt die Methode der Lagrange Polynome (siehe Anwendungsbeispiel: Interpolation und Polynomapproximation). Im zweiten Unterpunkt des linken Frames dieser Vorlesung wird die Herleitung der Differentiationsregeln mittels eines Python Jupyter Notebooks behandelt und im dritten Unterpunkt werden die Differentiationsregeln in einem C++ Programm verwendet, um die Ableitung einer Funktion $f(x)$ approximativ zu bestimmen.

Vorlesung 7

Mittels der bisher erlernten Programmierkonzepte können wir bereits viele umfangreiche Berechnungen durchführen und Sie werden auch bald an Ihrem eigenen Programmier-Projekt arbeiten. Als Programmierer eines umfangreichen Programmes kommt man sich manchmal wie ein Schöpfer einer neuen fiktiven, virtuellen Kreatur vor und in dieser Vorlesung werden wir eine ganz neue Art von Herangehensweise bei der Erschaffung eines Programmes erlernen. Mittels eigener, dem Problem angepasster Programmierobjekte ist es durch einen Abstraktionsmechanismus möglich, eine geordnete Struktur in den Ideenreichtum eines C++ Quelltextes bringen. Eine Klasse stellt dabei den Bauplan für das zu konstruierende Objekt bereit und die wirkliche Realisierung des Objektes (die Instanzbildung) findet dann im Hauptprogramm zur Laufzeit statt. Eine Klasse stellt somit eine formale Beschreibung dar, wie das Objekt beschaffen ist, d.h. welche Merkmale (Instanzvariablen bzw. Daten-Member der Klasse) und Verhaltensweisen (Methoden der Klasse bzw. Member-Funktionen) das zu beschreibende Objekt hat. Eine Klasse ist also eine Vorlage, eine abstrakte Idee, die ein Grundgerüst von Eigenschaften und Methoden vorgibt. Die Erzeugung eines Objektes dieser Klasse entspricht der Materialisierung dieser Idee im Programm. Bei der Erzeugung (Materialisierung) des Objektes wird der sogenannte Konstruktor der Klasse aufgerufen, und verlässt das Objekt den Gültigkeitsbereich seines Teilbereiches des Programms, wird es durch den sogenannten Destruktor wieder zerstört. Das Grundgerüst einer Klasse besitzt die folgende Form (siehe untere Box), wobei im Anweisungsblock der Klasse nicht alle der aufgezählten Größen deklariert bzw. definiert werden müssen.

class Klassenname {
    Private Instanzvariablen (Daten-Member)
    
    public:
        Konstruktoren
        Member-Funktionen
        (Destruktor)
}; 

Vorlesung 8

In der vorigen Vorlesung hatten wir das Klassenkonzept kennengelernt und eine Beispielklasse 'Ding' erstellt. Hierbei wurden die messbaren Eigenschaften des Dings (Daten-Member der Klasse) von den Verhaltensweisen des Dings (Member-Funktionen der Klasse) getrennt in der Klasse implementiert. Wie programmiert man die Verhaltensweisen eines Objektes? Das Verhalten eines Objektes unter einem einwirkenden Einfluss stellt eine Art von zeitlichem Verlauf dar. In Abhängigkeit von der jeweiligen Fragestellung und Natur des physikalischen Problems sind zwei generelle Programmzweige von zeitlich veränderlichen Systemen zu identifizieren: Die Agenten-basierte Simulation und Simulationen von physikalischen Bewegungsgleichungen. Im ersten Teil dieser Vorlesung (siehe C++ Container und die vector Klasse der Standardbibliothek) werden wir eine Art von Agenten-basierte Simulation kennenlernen. Die 'Agenten' stellen in diesem Fall die Teilchen in einer Kiste dar, die als Objekte der Klasse 'Ding' erzeugt wurden. Die zeitliche Entwicklung wird hierbei über eine Member-Funktion realisiert.
Im zweiten Teil werden wir dann sehen, wie man eine zeitliche Entwicklung eines Systems unter Verwendung seiner Bewegungsgleichungen simuliert (näheres siehe Differentialgleichungen: Numerische Lösung von Anfangswertproblemen). In dieser und der folgenden Vorlesung werden wir uns den Themenbereich des numerischen Lösens von Differentialgleichungen näher betrachten und mehrere Verfahren zum Lösen von Differentialgleichungen erster Ordnung kennenlernen. Die einzelnen Verfahren werden dann in einem C++ Programm implementiert und miteinander verglichen. Zusätzlich wird in einem Jupyter Notebook gezeigt, wie man mittels Python auch numerisch eine Differentialgleichung lösen kann.

Vorlesung 9

In dieser Vorlesung befassen wir uns zunächst mit dem numerischen Lösen von Systemen gekoppelter Differentialgleichungen und Differentialgleichungen zweiter Ordnung und stellen im darauf folgenden Teil mögliche Programmierprojekte vor, die von den Studierenden bearbeitet werden können. Beim Klicken auf die Überschriften der Projekte gelangen Sie zu einer detaillierteren Beschreibung der einzelnen Projektthemen.

Systeme von gekoppelten Differentialgleichungen und Differentialgleichungen zweiter Ordnung

In der vorigen Vorlesung hatten wir die unterschiedlichen Verfahren zum Lösen von Differentialgleichungen erster Ordnung kennengelernt. Die Bewegungsgleichungen vieler physikalischer Systeme sind jedoch von zweiter Ordnung in der Zeit und in diesem Teilkapitel beschreiben wir die Vorgehensweise wie man solche Differentialgleichungen höherer Ordnung numerisch mittels eines C++ Programmes löst. Um ein Differentialgleichung zweiter Ordnung mittels des Computers lösen zu können, schreibt man zunächst die DGL in ein System von zwei gekoppelten Differentialgleichungen ersten Ordnung um und diese löst man dann mit den Verfahren, die in der vorigen Vorlesung behandelt wurden. In diesem Unterpunkt werden wir uns zunächst mit Systemen von gekoppelten Differentialgleichungen erster Ordnung befassen und dann das numerische Lösen von Differentialgleichungen zweiter Ordnung vorstellen (näheres siehe Systeme von gekoppelten Differentialgleichungen und Differentialgleichungen zweiter Ordnung).

Studentische Projekte

Das Foucaultsche Pendel

Im Jahre 1851 gelang Jean Bernard Léon Foucault ein anschaulicher Beweis der Erdrotation. Aufgrund der, in rotierenden Bezugssystemen auftretenden Coriolisbeschleunigung, dreht sich die Schwingungsebene des Pendels langsam. Dieses Projekt ist ein Anwendungsfall der Newtonschen Mechanik in bewegten Bezugssystemen (siehe z.B. Walter Greiner, 'Klassische Mechanik II' [8. Auflage, 2008, Kapitel I3. Seite 18]) und das zugrundeliegende System von drei gekoppelten Differentialgleichungen zweiter Ordnung gilt es numerisch mittels eines C++ Programmes zu lösen und die berechneten Daten mittels Python zu visualisiern.

Das periodisch angetriebene Pendel

Das Projekt periodisch angetriebenes Pendel ist ein Anwendungsfall aus der klassischen Mechanik (siehe z.B. Walter Greiner, 'Klassische Mechanik II' [8. Auflage, 2008, Kapitel VII27. Seite 496]). Das System besteht aus einem Pendel, auf welches zusätzlich eine äußere Kraft mit periodischer Zeitabhängigkeit wirkt. Außerdem soll das Pendel durch eine geschwindigkeitsabhängige Luftreibung gedämpft sein. Die zugrundeliegende Bewegungsgleichung des periodisch angetriebenen Pendels ist stark nichtlinear und die, nur auf numerischem Weg zu berechnenden Lösungen, zeigen deterministisch chaotische Bewegungen.

Das Doppelpendel

Das Projekt Doppelpendel ist ein Anwendungsfall aus der klassischen Mechanik (siehe untere Animation). Das System besteht aus zwei miteinander verbundenen Pendeln, wobei wir die Luftreibung zunächst vernachlässigen. Die Herleitung der Bewegungsgleichungen des Doppelpendels erfolgt am elegantesten mittels der Euler-Lagrange Gleichungen, bzw. mittels der Hamilton Theorie. Mittels der Lagrange-Gleichungen gelangt man zu zwei gekoppelten Differentialgleichungen zweiter Ordnung, die man dann in ein System von vier gekoppelten DGLs erster Ordnung umschreiben muss um es numerisch lösen zu können. Die zugrundeliegende Bewegungsgleichung des Doppelpendels ist stark nichtlinear, sodass kleine Abänderungen in den Anfangswerten, nach einiger Zeit qualitativ unterschiedliche Bewegungen zur Folge haben (deterministisches Chaos).

Die schwingende Kette

Das Projekt Die schwingende Kette ist ein zentrales Beispiel eines schwingenden Massensystems, ein Problem aus der klassischen Mechanik (siehe Walter Greiner, 'Klassische Mechanik II' [8. Auflage, 2008, Kapitel I7. Seite 76]). Das System besteht aus einem masselosen Faden, der mit $N+1$ Massenpunkten (Dingen, Teilchen, Perlen) besetzt ist. Die $N+1$ 'Perlen' sollen in diesem Projekt als Objekte einer Klasse programmiert werden. Jede Perle besitzt eine ganzzahlige Instanzvariable $n$ (die Nummer der Perle) und die erste ($n=0$) und letzte Perle ($n=N+1$) wird so befestigt, dass sie sich nicht im Raum bewegen können. Die Bewegungsgleichung der schwingenden Kette stellen ein System von $N$ Differentialgleichungen zweiter Ordnung dar. Es sollen die Spezialfälle $N=2$ und $N=3$ mit einem C++ Programm simuliert werden um dann durch Erhöhung der Teilchenzahl den Kontinuums-Grenzwert der schwingenden Saite (siehe Walter Greiner, 'Klassische Mechanik II' [8. Auflage, 2008, Kapitel I8. Seite 88]) approximativ abbilden zu können.

Planetenbewegungen

In diesem Projekt wird die Bewegung eines Körpers in einem gravitativem Zentralkraftfeld untersucht. Die Bewegungsgleichung eines Massenpunktes (Venus, Erde) im Gravitationsfeld der Sonne ist ein oft behandeltes System in der klassischen Mechanik (siehe z.B. Walter Greiner, 'Mechanik Teil 1' [5. Auflage, 1989, Kapitel 26. Seite 266])). Die Bewegungsgleichungen des betrachteten Systems in drei Dimensionen, formuliert mittels der Newtonschen Gravitationstheorie, stellen ein System von drei gekoppelten Differentialgleichungen 2. Ordnung dar, die man dann in ein System von sechs gekoppelten DGLs erster Ordnung umschreiben muss um es numerisch lösen zu können.

Räuber-Beute Simulationen

Das Projekt Räuber Beute Simulation hat Ihren Ursprung im Fachgebiet der Populationsökologie (bzw. Populations-/Evolutionsbiologie). Die Räuber-Beute Gleichung beschreibt den natürlichen Überlebenskampf mehrerer Spezies, die einander auffressen. Die Population der Räuberwesen ernährt sich von der Population der Beutewesen und sinkt die Anzahl der Beutewesen, so erniedrigt sich die Reproduktionsrate der Räuberwesen, da diese Hunger erleiden müssen. Das Projekt besteht aus zwei formell getrennten Simulationen: Eine Agenten-ähnliche Simulation auf individueller Lebewesen Formulierung und eine Simulation, die auf Basis einer analytischen Räuber-Beute Gleichung.

Weitere Links

• Folien der 9.Vorlesung
• Vorlesungsaufzeichnung der 9. Vorlesung (14.06.2022)
• Vorlesungsaufzeichnung der 9. Vorlesung (21.06.2022)
• Übungsblatt Nr.9

Vorlesung 10

In dieser Vorlesung werden wir zunächst die ersten Teilaufgaben eines weiteren Projektes (das Projekt Achterbahn) exemplarisch besprechen. Es wird gezeigt, wie man die Bewegungsgleichungen des betrachteten Systems unter Verwendung der Euler-Lagrange Gleichungen mittels eines Jupyter Notebooks generiert. Das Umschreiben der DGL zweiter Ordnung in ein System von zwei DGLs erster Ordnung und die Implementierung und Lösung der Gleichungen mittels eines C++ Programmes wird ebenfalls beispielhaft vorgeführt. Die weiteren Teilaufgaben des Projektes wurden hingegen noch nicht bearbeitet, sodass Studierende auch dieses Projekt weiter bearbeiten können. Im zweiten Unterpunkt der Vorlesung werden wir auf die Vererbung von Klassenmerkmalen bei abgeleiteten Klassen und auf Klassenhierarchien eingehen.

Beispiel Projekt: Die Achterbahn

Das Projekt Achterbahn ist ein Anwendungsfall aus der klassischen Mechanik. Das Problem ist eine Verallgemeinerung des Problems "Bewegung eines Massenpunktes auf einer Zykloidenbahn" (siehe Aufgabe 15.7: Walter Greiner, 'Klassische Mechanik II' [8. Auflage, 2008, Kapitel V15. Seite 271]). Das System besteht aus zwei Achterbahn-Wagen unterschiedlicher Massen $m_i \, , \,\, i \in [0,1]$, die reibungsfrei auf einer Metallschiene gleiten können. Die Achterbahn hat eine Länge von $l \, [m]$ und besitzt keine Kurven, sodass man den Verlauf der Metallschiene der Achterbahn als eine eindimensionale Funktion $h(x) \, , \,\, x \in [-l/2, l/2]$ beschreiben kann, wobei $h(x)$ die Höhe der Metallschiene der Achterbahn an der Position $x$ in der Einheit Metern beschreibt. Die Herleitung der Bewegungsgleichungen erfolgt am elegantesten mittels der Euler-Lagrange Gleichungen, bzw. mittels der Hamilton Theorie. Die Bewegung eines Wagens wird durch eine Differentialgleichung zweiter Ordnung bestimmt und diese hängt nicht von dem Wert der Masse des Wagens ab. Um diese DGL zweiter Ordnung numerisch lösen zu können, schreibt man sie in ein System von zwei DGLs erster Ordnung um. Die nebenstehende Animation visualisiert die C++ Simulation zweier Wagen, wobei der Verlauf der Metallschiene der Achterbahn durch die Funktion $h(x) = e^{\frac{\sqrt{x^2}}{10}} \cdot \left( \hbox{sin}\left( \frac{x^2}{10} \right) \right)^2$ gegeben ist. Jeder der Achterbahn-Wagen besitzt nun am vorderen und hinterem Bereich eine extrem starke und robuste Metallfeder, die zum Einsatz kommt, wenn sich zwei der Wagen treffen. Es wird dabei angenommen, dass es sich bei einem Zusammenprall der Wagen um einen elastischen Stoß zweier Körper handelt (näheres siehe Beispiel Projekt: Die Achterbahn).

Abgeleitete Klassen, Vererbung von Klassenmerkmalen und Klassenhierarchien

Im zweiten Unterpunkt der Vorlesung werden wir auf die Vererbung von Klassenmerkmalen bei abgeleiteten Klassen eingehen. C++ Klassen stehen häufig in Beziehung zueinander. Man hat beispielsweise eine Oberklasse (z.B. Pendel), und aus dieser leitet sich eine andere Klasse (z.B. mathematisches Pendel, oder physikalisches Pendel) ab. Diese abgeleitete Klasse (auch Subklasse) erbt dann bestimmte Eigenschaften der Daten-Member und Member-Funktionen der Oberklasse 'Pendel' (auch Basisklasse oder Superklasse). Die Superklasse hat dabei oft einen übergeordneten, abstrakten Charakter und es können in ihr virtuelle Funktionen deklariert werden, die in den jeweiligen abgeleiteten Klassen dann definiert werden. In umfangreichen C++ Programmen baut sich somit eine Art von Klassenhierarchie auf und oft werden dabei auch sogenannte Templates eingesetzt, auf die wir erst in der nächsten Vorlesung eingehen werden. Die nebenstehende Abbildung zeigt die Simulation eines physikalischen Pendels mit Stokesschem Reibungsterm. Das zugrundeliegende C++ besitzt eine Superklasse 'Ding', die als eine Schnittstelle der kartesischen Orte und Geschwindigkeiten des Pendels fungiert. Von ihr wurde die Klasse 'Pendel' des physikalischen Pendels abgeleitet (Schnittstellenvererbung) und von dieser die Sub-Subklasse 'Pendel_math' des mathematischen Pendels (harmonischer Oszillator mit Reibung) abgeleitet (Implementierungsvererbung). Näheres siehe Abgeleitete Klassen, Vererbung von Klassenmerkmalen und Klassenhierarchien.

Weitere Links

• Folien der 10.Vorlesung
• Vorlesungsaufzeichnung der 10. Vorlesung (23.06.2022)
• Vorlesungsaufzeichnung der 10. Vorlesung (28.06.2022)

Vorlesung 11

Die bisher behandelten Inhalte fokussierten sich dabei, einerseits auf die C++/Python Grundlagen der objektorientierten Programmierung und andererseits auf die numerischen Algorithmen zum Lösen des betrachteten physikalischen/mathematischen Systems. Mittels der erlernten Konzepte sollte es nun den Studierenden möglich sein, die numerische Lösung eines komplexen physikalischen Problems auf dem Computer zu simulieren. Viele der Arbeitsgruppen am Institut für Theoretische Physik der Goethe-Universität arbeiten an speziellen, nur numerisch lösbaren Teilaspekten der Physik und, die zur Simulation verwendeten hochkomplexen Programme, sind oft in unzähligen Teil-Quelltexten zu einem Programm zusammengefügt. Im ersten Unterpunkt dieser Vorlesung wird den Studierenden gezeigt, wie man zurzeit am Institut an größeren Projekten arbeitet.

Projektstruktur und Dinge die man über C++ wissen sollte

Arbeitet man als Physiker in einer Gruppe an einem großen Simulationsprogramm, dann ist eine geordnete Projektstruktur von Anfang an wichtig. Die Struktur der unzähligen Teilquelltexte und das gemeinsame Arbeiten und Verändern von diesen erfordert eine verteilte Versionsverwaltung der C++ Quelltexte (z.B. die freie Software zur verteilten Versionsverwaltung von Dateien Git). In diesem Unterpunkt wird gezeigt, wie die Projektstruktur eines Großprojektes organisiert wird und wie die Dateistruktur eines komplexen Programms aufgebaut ist.

Klausurvorbereitung und prüfungsrelevante Themen

Im Hinblick auf die anstehende Klausur werden in diesem Unterpunkt die prüfungsrelevanten Inhalte der einzelnen Vorlesungen aufgelistet und Beispielaufgaben und deren Musterlösungen besprochen. Näheres siehe Klausurvorbereitung und prüfungsrelevante Themen.

Weitere Links

• Vorlesungsaufzeichnung der 11. Vorlesung (30.06.2022)
• Vorlesungsaufzeichnung der 11. Vorlesung (05.07.2022)
• Vorlesungsaufzeichnung der 11. Vorlesung (07.07.2022)
• Vorlesungsaufzeichnung der 11/12. Vorlesung (12.07.2022)

Vorlesung 12

In dieser Vorlesung wird zunächst auf das Paradigma der parallelen Programmierung und das Rechnen auf Supercomputern eingegangen. Bei aufwendigen und rechenintensiven großen Programmen ist es oft nötig, die Programme zu parallelisieren; d.h. den Quelltext des Programms so umzuschreiben, dass einzelne, voneinander unabhängige Teil-Tasks gleichzeitig nebeneinander ausgeführt werden können. Im zweiten Punkt werden zwei aktuelle, komplexe Anwendungsbeispiele vorgestellt, bei denen die theoretisch, physikalische Forschung auf Computersimulationen angewiesen ist.

Das Paradigma der parallelen Programmierung und das Rechnen auf Supercomputern

Computersimulationen von realistischen, komplizierten Problemen erfordern sogar auf Supercomputern (Hochleistungs-Großrechenanlagen, bei denen eine große Anzahl von Mehrprozessor-Computern zu einem Computer-Cluster System verbunden sind) oft eine enorme Rechenzeit. Bei der Konzeption der Simulationsprogramme ist es deshalb erforderlich, dass die Rechenleistung des Computers stets voll ausgelastet ist und separate, voneinander unabhängige Teilaufgaben innerhalb der Programme gleichzeitig (parallel) berechnet werden. Das Paradigma der parallelen Programmierung ist die Art und Weise, wie man ein Programm gestaltet, damit die in dem Programm enthaltenen Teilberechnungen (Tasks) möglichst gleichzeitig, nebeneinander berechnet werden können. Diese Nebenläufigkeit der Programmstränge, die gleichzeitige Ausführung mehrerer Tasks, lässt sich in vielen Programmiersprachen (nicht nur C++ und Python) relativ einfach mittels OpenMP (Open Multi-Processing) parallelisieren. Das in der vorigen Vorlesung dargestellte Programm "Eine Kiste voller Pendel" (siehe Vorlesung 11, Unterpunkt Klausurvorbereitung und prüfungsrelevante Themen) wird in diesem Unterpunkt verwendet, um das Prinzip der parallelen Programmierung zu erläutern. Näheres siehe Das Paradigma der parallelen Programmierung und das Rechnen auf Supercomputern.

Anwendungsbeispiele und weiterführende Vorlesungen

Die Anwendungsmöglichkeiten der Programmierung sind vielschichtig und speziell im Bereich der theoretischen Physik, sind viele der aktuellen Forschungsfragen nur mittels aufwendiger Computersimulationen lösbar.

Eines dieser aktuellen Anwendungsfelder ist die numerische relativistische Astrophysik und die numerische allgemeine Relativitätstheorie. Das Einstein Toolkit (ET) ist eine Softwareplattform, mit der man Probleme aus dem Bereich der relativistischen Astrophysik und Gravitationsphysik nummerisch am Computer simulieren kann. Das ET entwickelte sich im Jahre 1998 aus dem Cactus Code und im Laufe der letzten 20 Jahre wurde seine Performance (hocheffiziente OpenMP/MPI Parallelisierung) und Anwendungsbreite ständig verbessert. Mittlerweile kann man mit dem frei zugänglichen ET-Code Kollisionen von schwarzen Löchern und Neutronensternen simulieren. Die nebenstehende Abbildungund zeigt einige Eigenschaften (Dichte, Temperatur, Rotationsprofil und Frame-Dragging) des in einer Neutronenstern-Kollision produzierten hypermassiven Neutronensterns und wurde mit dem ET simuliert und mittels Python visualisiert. Näheres siehe Vorlesung 'Allgemeine Relativitätstheorie mit dem Computer' und F+L-Praktikum am Institut für Theoretische Physik.

Der wissenschaftliche Untersuchungsgegenstand des zweiten aktuellen Anwendungsfeldes der Programmierung ist, im Gegensatz zum ersten, ein der menschlichen Wahrnehmung näheres. Die Spieltheorie ist ein bedeutendes Mittel zum modellhaften Verständnis komplexer sozioökonomischer Entscheidungs-Prozesse. In ihrer herkömmlichen Form werden die handelnden Akteure als rein rational und egoistisch handelnde Individuen aufgefasst (homo oeconomicus) und eine Population bestehend aus einer großen Anzahl von solchen interdependenten Entscheidern kann sich zu einem Dilemma-artigen Zustand entwickeln. Im Gegensatz zur Physik, die die Gesetzmäßigkeiten der leblosen Materie/Energie und deren Wechselwirkungen in Raum und Zeit betrachtet, ist in der evolutionären Spieltheorie das zu erforschende Ding, der Mensch, und wir sind daran interessiert, wie dieser sich bei ökonomischen oder sozial relevanten strategischen Entscheidungen verhält. Viele Wirtschafts- und Sozialwissenschaftler betrachten die Spieltheorie als die formale Sprache der ökonomischen Theorie. Agentenbasierte Computersimulationen von spieltheoretischen Problemen auf komplexen sozio-ökonomischen Netzwerken sind ein interdisziplinäres aktuelles Forschungsfeld; näheres siehe Vorlesung Physik der sozio-ökonomischen Systeme mit dem Computer im kommenden Wintersemester 2022/23.

Weitere Links

• Folien der 12.Vorlesung
• Vorlesungsaufzeichnung der 12. Vorlesung (14.07.2022)