kramann.info
© Guido Kramann

Login: Passwort:










Informatik3
1 Vom_struct_zur_Klasse
..1.1 Vom_struct_zur_Klasse
..1.2 struct_Programm
..1.3 Klassen_Programm
..1.4 Offene_Fragen
..1.5 Historie
..1.6 Objektabstraktion
..1.7 OO_Kundenverwaltung
..1.8 Objektfaehigkeiten
..1.9 Formatierung
..1.10 Motivation
..1.11 Uebung1
..1.12 Uebung2
2 UML
..2.1 Volumenberechnung
..2.2 UML_Klassendiagramm
..2.3 Konstruktor
..2.4 Statische_Variable
3 Strings
..3.1 Klassenbibliotheken
..3.2 stringUML
..3.3 Uebung3
4 Initialisierungen
4 bluej
5 Zeiger_und_Arrays
..5.1 Zeiger
..5.2 Zeiger_und_Funktion
..5.3 Uebung4
6 Vererbung
..6.1 MesswerteUML
..6.2 MesswerteProgramm
..6.3 VererbungsProgramm
..6.4 Vector
..6.5 Uebung
7 Modifikatoren
..7.1 public_Vererbung
..7.2 protected_Vererbung
8 Listen_und_Templates
..8.1 Containertypen
....8.1.1 ListeUML
....8.1.2 ListeProgramm
..8.2 Templates
....8.2.1 Listentemplate
....8.2.2 STLvectorTemplate
..8.3 Uebung5
..8.4 Uebung6
..8.5 Uebung7
9 Java
..9.1 Uebung
..9.2 GettingStarted
..9.3 Animation
..9.4 Hybrid
..9.5 Threads
10 Delegation
11 LayoutProjekt
12 Fenster
13 Uebung
14 Zwischenprojekt
..14.1 Befehle
..14.2 Planung
..14.3 JNI
..14.4 JNIumsetzen
..14.5 Anwendungsklasse
..14.6 GUI01
..14.7 GUI02
15 Rasterlayout
..15.1 Bilder_Packages
..15.2 interfaces
..15.3 ArrayList
..15.4 clone
..15.5 Uebung
16 Nuetzliches
..16.1 Threads
..16.2 Animation
..16.3 RungeKutta
..16.4 Loesungsansatz
..16.5 Internetprogrammierung
....16.5.1 Codegenerierung
....16.5.2 PHP_Programmierung
....16.5.3 PHP_OOP
....16.5.4 Java
17 Algorithmen
..17.1 RungeKutta
..17.2 Loesungsansatz
..17.3 Evoopt
..17.4 Uebung12
..17.5 Uebung8_2014
..17.6 Ausdruecke
18 Uebung10
19 UML_ALT
..19.1 Flaechenberechnung
..19.2 UML_Flaechenberechnung
..19.3 Implementierung
..19.4 ListeUML
..19.5 ListenImplementierung
..19.6 Anwendung

16.3 Saalübung - Prozedurales Programm in objektorientierte Form bringen und Euler-Integration durch Newton-Integrationsverfahren ersetzen

  • Folgendes Programm stellt das bekannte Beispiel eines einfachen Simulationsprogramms in C/C++ dar, mit dem ein linearer Einmasse-Schwinger integriert wird:
#include<iostream>
using namespace std;
int main()
{
    double x=1.0;
    double v=0.0;
    double xneu=1.0;
    double vneu=0.0;
    double dt=0.1;
    double t=0.0;
    for(int i=0;i<1000;i++)
    {
        cout<<t<<" "<<x<<" "<<v<<endl;
        vneu = (-x-0.5*v)*dt+v;
        xneu = (       v)*dt+x;
        x = xneu;
        v = vneu;
        t=t+dt;
    }
}

Code 16.3-1: Simulationsprogramm aus der Vorlesung vom 16.12.2009.

  • Wie in der Vorlesung dargestellt wurde, wird hier ein Differentialgelichungssystem numerisch integriert, das einem linearen Schwinger entspricht.
  • Das Verfahren zur Integration ist das so genannte Euler-Verfahren.
  • Das Differentialgleichungssystem wird benutzt, um die aktuelle Steigung an einer Stelle zu bestimmen.
  • Der alte Wert plus die aktuelle Steigung mal Δt ergibt den Wert zum Zeitpunkt t+Δt:

f(t+Δt) = f(t)+ (df(t)/dt)*Δt

  • Da das Differentialgleichungssystem aus zwei Gleichungen besteht, muß das Verfahren auch für beide Gleichungen angewendet werden.
  • Die eine Gleichung liefert die Steigung der Geschwindigkeit an einer bestimmten Stelle [x,v].
  • Die andere Gleichung liefert die Steigung des Weges an einer bestimmten Stelle [x,v]:

dv(x,v)/dt = -x-0.5*v

dx(x,v)/dt = v

  • Diese beiden Gleichungen, die die aktuelle Steigung bestimmen sind das Modell, das simuliert wird.
  • Das ganze andere drum herum ist die numerische Integration, auch Simulation genannt.

Aufgabe 1

  • Wandeln Sie das Programm in eine einfache Java-Anwendung um.
  • Spalten Sie das "prozedurale" Java-Programm in zwei Klassen auf:
  • Die eine Klasse soll das Modell enthalten.
  • Die zweite soll das Integrationsverfahren repräsentieren.
  • Hintergrund: Diese Aufspaltung soll es ermöglichen, auch andere Modelle mit dem Integrationsverfahren zu berechnen, oder dieses Modell mit einem anderen Integrationsverfahren, indem man dann nur jeweils eine der beiden Klassen durch etwas Neues ersetzt.
  • Diese Übung soll die Grundlage für ein Simulationsprogramm mit GUI bilden, mit dem diese Vorlesung abschließen wird.

Hilfestellungen:

  • Modell-Klasse:
  • Die Modellklasse soll lediglich eine Funktion enthalten, die die aktuelle Steigung zurückliefert.
  • Sinnvollerweise liefert sie einen Zeiger auf ein Array, das die beiden Steigungswerte beinhaltet.
  • Übergabeparameter dieser Funktion ist natürlich ein Array, das das aktuelle x und v enthält.
  • Da nicht jedes Modell aus genau zwei Gleichungen besteht, sollte der Übergabeparameter ein Array sein und nicht zwei getrennte double-Werte.
  • Aus dem gleichen Grund macht es Sinn, eine weitere Funktion zu definieren, die die Anzahl der Modellgleichungen zurückgibt.
  • Dies dient dazu, dass der Integrator "weiß", für wieviele Gleichungen der nächste Integrationsschritt ausgeführt werden soll.
  • Integrator-Klasse:
  • Hier bieten sich unterschiedliche Möglichkeiten an.
  • Man könnte alles, was jetzt in der main-Methode passiert, in die Integratorklasse verlegen.
  • Dies ist die aufwändigere Variante.
  • Einfacher wird es, wenn man die Schleife für die Integrationsschritte in der main-Methode beläßt.
  • In diesem Fall führt eine Funktion in dem Integrator-Objekt nur einen Integrationsschritt aus.
  • Beim Erzeugen eines Integrator-Objektes sollte ein Zeiger auf ein Modell übergeben werden, welches dann in der Integrationsfunktion benutzt wird.
  • D.h. es wird ein Modell-Objekt in dem Integrator-Objekt registriert, um zu vereinbaren, für welches Modell die Integrationsschritte durchgeführt werden sollen.
  • Ebenso beim Erzeugen des Integrator-Objektes sollte die Schrittweite Δt vereinbart werden.
  • Die eigentliche Integrationsfunktion führt dann immer nur einen Integrationsschritt durch (ein Schritt in der Schleife der main-Methode).
  • Ihr wird als Übergabeparameter nur der aktuelle Wert für [x(t),v(t)] als double-Array übergeben.
  • Die Funktion liefert dann einen Zeiger auf in double-Array zurück, das [x(t+Δt),v(t+Δt)] enthält.

Vorgehen:

  • Zeichnen Sie zunächst ein UML-Klassendiagramm Ihres Lösungskonzeptes und besprechen es untereinander und nötigenfalls mit Ihrem Dozenten.
  • Setzen Sie dann erst Ihre Idee in ein Java-Programm um.
  • Testen Sie Ihr Programm, indem Sie bei gleichen Anfangsbedingungen und gleicher Schrittweite Δt Ihre Ausgabe mit der des prozeduralen Programms vergleichen.

Aufgabe 2

  • Nachfolgend ist dem Euler-Integrations-Verfahren das wesentlich bessere Runge-Kutta-Integrations-Verfahren gegenüber gestellt.
  • Schreiben Sie eine neue Integratorklasse, die das Runge-Kutta-Verfahren verwendet und testen Sie dieses.
  • Um das Austauschen von Integrator-Klassen und Modellklassen zu vereinfachen, bietet es sich an, Abstrakte Klassen für beide einzuführen. Machen Sie das.
Allgemeines Modell mit Euler-Verfahren integtriert.

Bild 16.3-1: Allgemeines Modell mit Euler-Verfahren integtriert.

Allgemeines Modell mit Runge-Kutta-Verfahren integtriert.

Bild 16.3-2: Allgemeines Modell mit Runge-Kutta-Verfahren integtriert.