Interaktive Strömungssimulation auf Tablet-Computern

Transkript

1 Bachelorarbeit am Lehrstuhl für Angewandte Mathematik und Numerik der Fakultät für Mathematik an der TU Dortmund Interaktive Strömungssimulation auf Tablet-Computern vorgelegt von Niklas Borg und Patrick Westervoß betreut durch Jun.-Prof. Dr. Dominik Göddeke Oktober 2012

2 Inhaltsverzeichnis 1 Einleitung 1 2 Theoretische Grundlagen Die Navier-Stokes Gleichungen Anfangs- und Randbedingungen Projektionsverfahren und die Helmholtz-Hodge-Zerlegung Diskretisierung und numerische Lösung Implementierung Löser Kraft aufprägen Advektion Diffusion Projektion Visualisierung Interaktion Demonstration des Gesamtsystems Tests Validierung Numerische Stabilität Physikalisch richtiges Verhalten Parametertests Viskosität Zeitschrittweite Symmetrietest Validierung der Interaktions-Komponente Physikalisch korrekte Umsetzung Überlagerung einer vorgegebenen Kraft mit einem TouchEvent Zeitmessungen und Tuning Analyse des Lösers Analyse der Visualisierungs-Komponente Analyse der Interaktions-Komponente Zusammenfassung Diskussion und Fazit 54

3 Kapitel 1 Einleitung In dieser Bachelorarbeit stellen wir ein Verfahren zur Strömungssimulation in Form einer App auf Tablet- Computern vor. Aufgrund der massiven Hardwareverbesserung in der letzten Zeit ist es mittlerweile möglich, solche Computer für anspruchsvolle Simulationen zu verwenden. Insbesondere können wir dadurch die Echtzeit und Interaktion auf sehr natürliche Weise realisieren. Das Ziel dieser Arbeit ist es somit, eine neue Hardwarearchitektur inklusive ihrer intuitiven Interaktionsmöglichkeiten auf die Eignung zur physikalisch korrekten numerischen Strömungssimulation zu evaluieren und dabei experimentell zu ergründen, ob und in welchem Rahmen eine Echtzeit-Simulation erreicht werden kann. Dazu betrachten wir ein Fluid, welches sich in dem zweidimensionalen Gebiet Ω = [ 1, 1] 2 R 2 befindet. Als mathematisches Modell verwenden wir die inkompressiblen Navier-Stokes Gleichungen, denen wir uns in Kapitel 2 widmen. Patrick Westervoß erläutert in Abschnitt 2.1 die physikalische Bedeutung dieser Gleichungen und geht in Unterkapitel 2.2 auf Anfangs- und Randbedingungen, die für die Wohlgestelltheit des Problems notwendig sind, ein. Danach überführt er die Gleichungen in Abschnitt 2.3 in eine zur Lösung geeignetere Form. Anschließend entwickelt Niklas Borg in Abschnitt 2.4 ein numerisches Lösungsverfahren und geht zusätzlich auf die Diskretisierung dieses Verfahrens mittels finiter Differenzen ein. In Kapitel 3 präsentieren wir die programmiertechnische Umsetzung des im vorherigen Kapitel vorgestellten Verfahrens, die wir aufgrund ihrer Komplexität gemeinsam durchgeführt haben und gehen auf einige kompliziertere Strukturen ein. Weiterhin stellen wir zwei für die Strömungssimulation auf Tablet- Computern wesentliche Komponenten vor: die Visualisierung des zuvor berechneten Geschwindigkeitsfeldes und die Interaktion eines Anwenders. Hierbei verwenden wir die OpenGL ES 2.0-Bibliothek, die üblicherweise zur Realisierung der beiden Elemente auf Tablet-Computern genutzt wird. In Kapitel 4 führen wir verschiedene Tests durch, um unsere Software auf ihre Richtigkeit zu prüfen. Dazu untersucht Niklas Borg in Abschnitt 4.1 die numerische Stabilität und physikalische Korrektheit unserer Simulation. Damit ist gemeint, dass sich die Simulation nicht verselbstständigt, sich also ein statisches Fluid nicht selbst anregt. Darüber hinaus vergleicht er den gängigen Testfall Driven Cavity, durchgeführt in unserer Simulationsumgebung, mit einer Referenzlösung. In Abschnitt 4.2 führt er zudem einige Parametertests durch, um die Auswirkungen der verschiedenen Variablen unseres Lösers auf die Simulation zu bewerten. Dabei betrachtet er die kinematische Viskosität ν des Fluids, den im Verfahren verwendeten Zeitschritt t und die Anzahl maxiter der durchzuführenden Iterationen im eingesetzten Jacobi-Löser. In Abschnitt 4.3 analysiert Patrick Westervoß die Umsetzung der Anwender-Interaktion anhand zweier verschiedener Testfälle, die sich in ihrer Komplexität unterscheiden. Danach erarbeitet er in Abschnitt 4.4 mit Hilfe von Zeitmessungen der einzelnen Implementierungs-Komponenten potentielle Verbesserungsmöglichkeiten der Software, um zu beurteilen, in wie weit eine Echtzeit-Simulation auf Tablet- Computern erreicht werden kann. Dazu vergleicht und interpretiert er die Laufzeiten des Lösers, der Visualisierungs- sowie der Interaktions-Komponente für verschiedene Gitterschrittweiten h der Diskretisierung. 1

4 KAPITEL 1. EINLEITUNG 2 Zum Schluss fassen wir in Kapitel 5 die wesentlichen Erkenntnisse zusammen. Eine genaue Übersicht über die Aufteilung der Bearbeitung dieser Bachelorarbeit geben wir in Tabelle 1.1. Kapitel bearbeitet von 2.1 Patrick Westervoß 2.2 Patrick Westervoß 2.3 Patrick Westervoß 2.4 Niklas Borg 3 Niklas Borg und Patrick Westervoß 4.1 Niklas Borg 4.2 Niklas Borg 4.3 Patrick Westervoß 4.4 Patrick Westervoß Tabelle 1.1: Aufteilung der Bearbeitung der Bachelorarbeit

5 Kapitel 2 Theoretische Grundlagen Zur Simulation einer Strömung in einem Fluid in einem bestimmten Zeitintervall benötigen wir eine mathematische Beschreibung seines Verhaltens. Ein gutes Modell dafür sind die Navier-Stokes Gleichungen, da sie die für die Darstellung eines Fluids wesentliche Komponente, die Entwicklung der Geschwindigkeit, charakterisieren. Außerdem bilden sie viele physikalische Effekte ab, wie zum Beispiel Turbulenzen und Grenzschichten innerhalb der Strömung. Deshalb wollen wir diese Gleichungen im Folgenden genauer betrachten. Dabei orientieren wir uns an den Ausführungen von [Stam] und [Harris]. Das Ziel des im weiteren Verlauf dieser Arbeit entwickelten Lösungsverfahrens ist die Generierung eines fluidartigen Verhaltens, welches zwar auf den Navier-Stokes Gleichungen basiert, dessen berechnetes Geschwindigkeitsfeld die Gleichungen jedoch nicht exakt erfüllt. Die hier vorgestellte Methode wurde ursprünglich für Computeranimationen entworfen und nicht für Anwendungen aus den Ingenieurswissenschaften, was unser leicht inexaktes Vorgehen zur Fluidsimulation rechtfertigt. 2.1 Die Navier-Stokes Gleichungen Zunächst treffen wir einige in der Fluidsimulation durchaus übliche Annahmen, die auf eine vereinfachte Form der Navier-Stokes Gleichungen führen und trotzdem die Qualität des mathematischen Modells erhalten. Dazu nehmen wir die Dichte ρ des Fluids sowie seine Temperatur θ als konstant bezüglich Ort und Zeit an, wodurch wir die Beschreibung eines inkompressiblen Fluids erhalten. Aufgrund dieser Annahmen müssen wir uns in der Simulation auf sogenannte newtonsche Fluide beschränken. Die Entwicklung eines solchen Fluids in einem zweidimensionalen Gebiet Ω R 2 über einem Zeitintervall I = [0, T ] mit T R + können wir durch die inkompressiblen Navier-Stokes Gleichungen charakterisieren, welche das Fluidverhalten mathematisch beschreiben: u t = (u ) u 1 p + ν u + f (2.1) ρ u = 0 (2.2) Dabei bezeichnen wir mit u = u (x, t) die Geschwindigkeit, mit p = p (x, t) den Druck, mit ν die kinematische Viskosität und mit ρ die Dichte des Fluids. Es ist dabei zu beachten, dass wir in unserer Simulation nur den Druck innerhalb des Fluids berücksichtigen und den Atmosphärendruck vernachlässigen. Durch die Größe f = f (x, t) definieren wir eine externe Kraft im Punkt x Ω zur Zeit t I. Hierbei treffen wir die Konvention, dass die fett gedruckten Ausdrücke vektorwertige Größen, in der Regel Vektorfelder, und die kursiven skalare Größen repräsentieren. Für Details zu den Navier-Stokes Gleichungen und deren Herleitung aus den allgemeinen Erhaltungsgleichungen der Kontinuumsmechanik verweisen wir auf [Anderson]. Im Folgenden wollen wir uns kurz den einzelnen Bestandteilen von Gleichung (2.1) widmen und ihre 3

6 KAPITEL 2. THEORETISCHE GRUNDLAGEN 4 physikalische Bedeutung erläutern, wozu wir einige Begriffe definieren. Advektion Üblicherweise kann ein Fluid Objekte oder andere Substanzen transportieren. In unserem Fall beschränken wir uns lediglich darauf, dass es sich selbst transportiert. Es wird also durch die eigene Geschwindigkeit fortbewegt. Dieses Verhalten nennt sich Advektion und wird durch den Term (u ) u beschrieben, der den konvektiven Transport des Fluids darstellt. Die Berücksichtigung dieses Effektes zieht die Konsequenz nach sich, dass die Navier-Stokes Gleichungen nichtlinear sind. Druck Die Teilchen in einem Fluid werden automatisch fortbewegt. Dies führt dazu, dass sie sich gegenseitig an- und abstoßen. Wird eine Kraft auf das Fluid aufgeprägt, so wird diese ebenfalls durch die Teilchen übertragen. Diese beiden Phänomene führen zu einer Druckentwicklung im Fluid, was letztendlich in einer Beschleunigung der Teilchen resultiert. Der Ausdruck 1 ρ p in Gleichung (2.1) repräsentiert diesen physikalischen Sachverhalt in Abhängigkeit von der Dichte ρ des Fluids und des auf das Fluid wirkenden Drucks p. Diffusion Dieses physikalische Phänomen hängt stark mit der Zähflüssigkeit eines Fluids, welche über seine kinematische Viskosität ν beschrieben wird, zusammen und hat einen großen Einfluss auf das Fluidverhalten. Zur Erläuterung geben wir zunächst eine rein formale Definition der Viskosität (vgl. [Arlt]): Definition (Viskosität) Wir betrachten folgenden Versuchsaufbau: Abbildung 2.1: Versuchsaufbau zur Definition der Viskosität Im unteren Teil von Abbildung 2.1 befindet sich eine feststehende, unbewegliche Wand M und im Abstand z zu dieser eine bewegliche Wand N mit der Oberfläche A. Der Raum zwischen den Wänden ist mit dem zu untersuchenden Fluid gefüllt. Um die Wand N mit der konstanten Geschwindigkeit v parallel zu M zu bewegen, wird die Kraft benötigt, die aus dem Newtonschen Gesetz

7 KAPITEL 2. THEORETISCHE GRUNDLAGEN 5 F = η A dv dz hervorgeht. Somit ist die Kraft F proportional zu der Oberfläche A und dem Geschwindigkeitsgradienten dv dz, welcher der Beschleunigung der beweglichen Wand N entspricht. Der Proportionalitätsfaktor η heißt dynamische Viskosität und ist ein Maß für die Zähflüssigkeit unseres Fluids. Es gilt hierbei: je größer die Viskosität, desto zähflüssiger das Fluid. Zu unterscheiden sind dabei zwei verschiedene Begriffe der Viskosität: Die dynamische Viskosität η und die kinematische Viskosität ν, welche wir in den Navier-Stokes Gleichungen (2.1) und (2.2) benötigen. Wir wollen nun beide Begriffe in Zusammenhang setzen: Sei ρ die Dichte und η die dynamische Viskosität unseres Fluids. Dann ergibt sich die kinematische Viskosität zu ν = η ρ. (2.3) Zähe Flüssigkeiten, also solche mit einer hohen Viskosität, reagieren träger auf Bewegungen als dünnflüssige oder auch Fluide mit kleinerer Viskosität, wie etwa Olivenöl im Vergleich zu Wasser. Dieser Effekt nennt sich Diffusion und geht durch den Term ν u in das mathematische Modell ein, der den diffusiven Transport des Fluids berücksichtigt. Kräfte Wie bei der Beschreibung des Drucks bereits erwähnt, führt das Aufprägen von Kräften zur Beschleunigung der Fluidteilchen. Möglich sind externe Kräfte, also solche, die von außen auf das Fluid wirken, und Körper- beziehungsweise Volumenkräfte, die etwa durch die Erdbeschleunigung hervorgerufen werden. An dieser Stelle sei schon einmal erwähnt, dass die externen Kräfte in der Simulation interaktiv durch den Anwender integriert werden können (vgl. Abschnitt 3.3). Damit das Problem, welches durch die Navier-Stokes Gleichungen formuliert wird, wohlgestellt ist, müssen wir zusätzlich sogenannte Anfangs- und Randbedingungen einführen, auf die wir im folgenden Abschnitt eingehen. 2.2 Anfangs- und Randbedingungen Sowohl die Geschwindigkeit u als auch der Druck p treten in den Navier-Stokes Gleichungen als Unbekannte auf und müssen in jedem Zeitschritt berechnet und aktualisiert werden. Daher müssen wir geeignete Anfangs- und Randbedingungen für beide Größen vorgeben. Die Anfangsbedingung für das Druckfeld ist von Testfall zu Testfall unterschiedlich. So nehmen wir in einem Beispiel den initialen Druck als Null an, womit p 0 in Ω gilt. Andererseits können wir für den Druck sogenannte Druckspitzen vorschreiben, wie wir sie in Kapitel 4.2 setzen. Für das Geschwindigkeitsfeld wählen wir immer u 0 als Anfangsbedingung und erzeugen Dynamik entweder durch externe Kräfte, wie etwa in Abschnitt 4.3.1, oder über Randbedingungen. Im Allgemeinen legen wir als Randbedingung für die Geschwindigkeit die sogenannte no-slip - Bedingung u Ω 0 fest. Wir setzen die Geschwindigkeit am Rand also auf Null, was bedeutet, dass das Fluid am Gebietsrand haften bleibt. Wir können aber auch, wie beim Testfall Driven Cavity beschrieben, an einer Kante des Rechengebiets einen von Null verschiedenen Wert vorschreiben. Wir tragen somit eine Tangentialgeschwindigkeit an und erzeugen mit ihrer Hilfe Dynamik im Fluid (vgl. Abschnitt 4.1.2). Als Randbedingung für den Druck legen wir fest, dass keine Änderung in Normalenrichtung stattfindet,

8 KAPITEL 2. THEORETISCHE GRUNDLAGEN 6 also p n Ω 0 gilt, wobei n den äußeren Normalenvektor von Ω bezeichnet. Die verschiedenen Anfangs- und Randbedingungen sind miteinander und mit der Anwender-Interaktion, der wir uns in Abschnitt 4.3 widmen, kombinierbar. Wir können somit eine Vielzahl von Testfällen konstruieren, von denen wir eine Auswahl in Kapitel 4 präsentieren. 2.3 Projektionsverfahren und die Helmholtz-Hodge-Zerlegung Nachdem wir zuvor alle Komponenten der Navier-Stokes Gleichungen aus physikalischer Sicht betrachtet und Anfangs- sowie Randbedingungen eingeführt haben, wollen wir sie nun in eine zum Lösen geeignetere Form bringen und anschließend ein Vorgehen zur Lösung dieser Gleichungen entwickeln. Dabei ist die Art der Diskretisierung des von Raum- und Zeitvariablen abhängigen Problems entscheidend. Zunächst nehmen wir eine simple Zeitdiskretisierung vor, indem wir das Zeitintervall I = [0, T ] in Teilintervalle zerlegen. Anschließend betrachten wir Gleichung (2.1) innerhalb eines Zeitschritts und diskretisieren die auftretenden Operatoren im Ort (vgl. Kapitel 2.4). Im Folgenden können wir daher die einzelnen Bestandteile dieser Gleichung als zeitunabhängig ansehen, da wir das Lösungsverfahren innerhalb eines Zeitschritts entwickeln. Um die Gleichungen in ein besser zu lösendes System zu überführen, betrachten wir als Hilfsmittel zunächst die sogenannte Helmholtz-Hodge Zerlegung (vgl. [Chorin]). Satz Sei Ω R 2 ein Gebiet mit glattem Rand Ω. Dann kann jedes Vektorfeld w zerlegt werden in die Form w = u + p, wobei u = 0 gilt, das Vektorfeld u also divergenzfrei ist. Außerdem ist u parallel zu Ω, das heißt u n = 0 mit dem äußeren Normalenvektor n von Ω. p bezeichnet ein Skalarfeld. In jedem Zeitschritt müssen wir Gleichung (2.1) lösen, wobei wir gewährleisten müssen, dass Gleichung (2.2) gilt. Wenn wir nun davon ausgehen, durch das Lösen von Gleichung (2.1) ein Geschwindigkeitsfeld w erhalten zu haben, so muss nicht zwangsläufig w = 0 gelten. Dies erreichen wir durch Anwenden von Satz auf das Geschwindigkeitsfeld w. Wir setzen somit am Ende des Zeitschritts das aktualisierte Geschwindigkeitsfeld analog zu obigem Satz als u = w p. Jetzt stellt sich die Frage, wie das Skalarfeld p zu berechnen ist. Wenden wir den Divergenz- Operator auf beide Seiten der Gleichung aus Satz an, so erhalten wir w = } {{ u} + p =0 w = p. (2.4) Setzen wir also die Lösung von Gleichung (2.1) als bekannt voraus, so können wir durch Lösen der Poisson-Gleichung (2.4) den Druck p ermitteln, mit dem wir das Geschwindigkeitsfeld w so modifizieren können, dass es Gleichung (2.2) erfüllt. Als nächstes müssen wir uns damit beschäftigen, wie wir das vorläufige Geschwindigkeitsfeld w berechnen können. Zunächst definieren wir hierzu mit Hilfe von Satz einen linearen Operator P, der ein Vektorfeld w auf seinen divergenzfreien Teil projiziert. Für diesen Operator gilt dann P (w) = P (u) + P ( p) da P linear ist, P (w) = u wegen Satz und (2.5) P (u) = u nach Voraussetzung,

9 KAPITEL 2. THEORETISCHE GRUNDLAGEN 7 woraus insgesamt P ( p) = 0 (2.6) folgt. Anhand von Gleichung (2.5) können wir uns mit dem Schwarzschen Satz (vgl. [Forster]) überlegen, dass P ( ) u t = u t gilt. Der Satz von Schwarz besagt, dass bei einer q-mal stetig partiell differenzierbaren Funktion die ersten q Ableitungen vertauscht werden dürfen. Bei uns gilt nach Voraussetzung u C 2 (Ω) C 1 (I), da die Ausdrücke u und u t in Gleichung (2.1) eine entsprechende Glattheit des Geschwindigkeitsfeldes bezüglich der Variablen (x, t) verlangen. Dabei bezeichnet C k (U l ) den Raum der k-mal stetig partiell differenzierbaren Funktionen über U 2 = Ω R 2 beziehungsweise U 1 = I R mit k, l {1, 2}. Somit folgt: Wenden wir nun den Operator P Gleichung (2.6) aus, so erhalten wir u t u t = ( u) = 0. t auf Gleichung (2.1) an und nutzen seine Linearität und = P ( (u ) u + ν u + f). (2.7) Aus Gleichung (2.7) ergibt sich direkt der von uns verwendete Algorithmus zur Lösung der Navier-Stokes Gleichungen, der sich in vier Schritte gliedert: u (, t) := w 0 Kraft aufprägen w 1 Advektion w 2 Diffusion w 3 Projektion w 4 =: u (, t + 1). (2.8) Wir nehmen an, dass uns das Geschwindigkeitsfeld u zum Zeitpunkt t bekannt ist und setzen w 0 (x) = u (x, t). Pro Zeitschritt lösen wir die Gleichung (2.1) durch sogenanntes Operator-Splitting sukzessiv numerisch. Wie in allen Projektionsmethoden entsteht auch hier durch das Splitting ein numerischer Fehler, wodurch wir Gleichung (2.1) nicht mehr exakt lösen. Leider geht [Stam] in seiner Originalarbeit nicht auf die Ordnung des Verfahrens ein, aufgrund der Struktur des Verfahrens und der Ähnlichkeit zu Chorinschen Projektionsmethoden (vgl. [Anderson]) ist aber nicht von einer hohen Ordnung auszugehen. Schließlich gewährleisten wir durch das Anwenden des oben definierten Projektionsoperators P, dass Gleichung (2.2) erfüllt ist, was anschaulich aus Abbildung 2.2 hervorgeht. Abbildung 2.2: Sukzessive Berechnung der Geschwindigkeit in einem Punkt innerhalb eines Zeitschritts (vgl. [Stam]) Am Ende eines jeden Zeitschritts setzen wir w 0 = w 4. Da wir, wie oben beschrieben, ausgehend von w 0 innerhalb eines Zeitschrittes operieren, hängen die Geschwindigkeitsfelder w k, k {0, 1, 2, 3, 4},

10 KAPITEL 2. THEORETISCHE GRUNDLAGEN 8 während der Berechnung nur von der Ortsvariablen x ab. Das Vektorfeld w 4 entspricht schließlich dem Geschwindigkeitsfeld u zum Zeitpunkt t+ t, also u (x, t + t) mit der Zeitschrittweite t R +. Die Simulation erhalten wir letztendlich durch Iteration der in Schema (2.8) beschriebenen Vorgehensweise über die Zeitschritte. Daraus ergibt sich durch Diskretisierung der auftretenden Operatoren ein numerisches Lösungsverfahren für die Navier-Stokes Gleichungen (2.1) und (2.2), worauf wir im nächsten Abschnitt eingehen. 2.4 Diskretisierung und numerische Lösung Wir erläutern in diesem Abschnitt die in Schema (2.8) angeführten Schritte und stellen Diskretisierungsbeziehungsweise Lösungstechniken vor, um abschließend ein kompaktes Lösungsverfahren der Navier- Stokes Gleichungen aufzustellen. Zur Diskretisierung aller auftretenden Operatoren verwenden wir in dieser Arbeit meist finite Differenzen zweiter Ordnung. Approximationen abweichender Ordnung sind beispielsweise bei der Behandlung von Randbedingungen nötig, auf die wir in Abschnitt näher eingehen. Wie in Abschnitt 2.3 bereits erwähnt, diskretisieren wir das durch die Navier-Stokes Gleichungen (2.1) und (2.2) und Anfangs- sowie Randbedingungen gestellte Problem zuerst in der Zeit und anschließend im Ort. Dazu wählen wir eine äquidistante Zerlegung des Zeitintervalls in L Teilintervalle der Form I = [0, T ] = L l=1 [ t (l 1), t (l)], wobei t (l) = l t und T = L t gilt. Die folgenden Diskretisierungen im Ort führen wir nun jeweils zu einem festen Zeitpunkt t (l) durch, weshalb die auftretenden Größen zeitunabhängig sind. Für unsere Simulation betrachten wir das quadratische Rechengebiet Ω = [ 1, 1] 2 R 2, in dem sich das Fluid befinden soll. Davon ausgehend definieren wir ein diskretes Gebiet Ω h mit Schrittweite h R, die wir sowohl in x- als auch in y-richtung zur Diskretisierung verwenden. Dadurch ergibt sich Ω h als ein Gitter, für das x i,j Ω h die Form x i,j = ( 1 + ih, 1 + jh) hat, wobei i, j {0,..., n 1} gilt und n N die Anzahl der Gitterpunkte pro Zeile beziehungsweise Spalte im Gitter angibt. Im Folgenden betrachten wir nur die Operationen innerhalb eines Zeitschrittes, das heißt im Übergang von t (l) nach t (l) + t. Dazu sei w 0 wie oben als bekanntes Geschwindigkeitsfeld u ( x, t (l)) definiert und w k, k {1, 2, 3, 4} bezeichnet die unterschiedlichen Geschwindigkeitsfelder innerhalb des Zeitschritts. Nach diesen Vorbereitungen widmen wir uns nun Diskretisierungs- und Lösungsmethoden für die einzelnen Bestandteile von Gleichung (2.7) beziehungsweise Schema (2.8). Kraft aufprägen Zuerst kann dem Fluid eine Kraft aufgeprägt werden. Dies geschieht während der Simulation durch den Anwender und soll nur ein Mal pro Zeitschritt erfolgen. Deshalb können wir die Annahme treffen, dass die Kraft über den gesamten Zeitschritt konstant ist. Somit ist eine Berücksichtigung der Kraft zu Beginn eines jeden Zeitschritts ausreichend. Wir berechnen also im ersten Schritt unseres Lösers w 1 = w 0 + tf, (2.9) was eine gute Approximation der Wirkung der Kraft über den Zeitschritt darstellt, da wir ihren Einfluss durch die Multiplikation des Kraftfeldes f mit der Zeitschrittweite t über den ganzen Zeitschritt transportieren.

11 KAPITEL 2. THEORETISCHE GRUNDLAGEN 9 Advektion Um die Advektion des Fluids zu berücksichtigen, fassen wir die Gitterpunkte als die oben beschriebenen Teilchen beziehungsweise Fluidpartikel auf und müssen dann in jedem Zeitschritt die Geschwindigkeit eines solchen Partikels aktualisieren. Eine erste Idee wäre es, hierzu folgende explizite Methode zu betrachten: Die Position r eines Partikels verändert sich mit der Geschwindigkeit, also können wir die Position so weit verschieben, wie sich das Partikel in der Zeit t mit seiner Geschwindigkeit fortbewegt. Also gilt r ( ) t (l) + t = r ( t (l)) ( + tu t (l)), was dem expliziten Eulerverfahren entspricht. Allerdings ist diese Methode instabil für große Zeitschrittweiten. Wir betrachten deshalb die implizite Methode der Charakteristiken, die die Stabilität des Verfahrens impliziert. Zur genaueren Erläuterung dieses Verfahrens verweisen wir auf [Stam] und geben hier nur eine grobe Zusammenfassung. Im Wesentlichen verfolgen wir jeden Punkt x Ω über die Zeit t entlang w 1 zurück. Dadurch entsteht ein Pfad p (x, t) von x zu einem Punkt x 0 = p (x, t), der auch als Stromlinie interpretiert werden kann. Dies wird in Abbildung 2.3 verdeutlicht. Abbildung 2.3: Weg, den ein Fluidpartikel in der Zeit zurücklegt (vgl. [Stam]) Wir setzen dann die neue Geschwindigkeit w 2 im Punkt x als die Geschwindigkeit, die im Punkt x 0 zur vorherigen Zeit vorliegt, also w 2 (x) = w 1 (p (x, t)) = w 1 (x tw 1 (x)). (2.10) Durch das Verwenden der Methode der Charakteristiken liefert unser Vorgehen eine für beliebig große Zeitschrittweiten und Geschwindigkeiten unbedingt stabile numerische Lösung (vgl. [Stam]). Das können wir daran feststellen, dass der maximale Wert des Geschwindigkeitsfeldes in diesem Schritt nie größer als im vorherigen Zeitschritt werden kann, außer wir prägen eine externe Kraft auf. Denn nach Gleichung (2.10) gilt ( ) ( ) ( (l) (l) (2.9) max w 2 max w 1 = max w (l) 0 + tf (l)) ( ) f (l) 0 (l 1) = max w 4, wobei (.) (l) die entsprechende Größe im l-ten Zeitschritt bezeichnet. Es ist f (l) 0, da wir hier keine Anwender-Interaktion berücksichtigen. Für Details zur Implementierung der Methode der Charakteristiken verweisen wir auf Kapitel 3.1.

12 KAPITEL 2. THEORETISCHE GRUNDLAGEN 10 Diffusion Hier betrachten wir eine Gleichung der Form u t = ν u. (2.11) Um diese numerisch zu lösen, diskretisieren wir zunächst den Laplace-Operator mit finiten Differenzen im Ort und wenden dann ein Zeitschrittverfahren an. Die Anwendung von auf das Geschwindigkeitsfeld u erfolgt komponentenweise in x- beziehungsweise y-richtung, weshalb wir vereinfachend die Diskretisierung des Operators angewendet auf ein hinreichend glattes Skalarfeld s betrachten. Wir stellen also die Diskretisierung von s = 2 s + 2 s im R 2 auf. Dann gilt x 2 y 2 ( s) i,j s i+1,j 2s i,j + s i 1,j h 2 + s i,j+1 2s i,j + s i,j 1 h 2 (2.12) mit s i,j := s (x i,j ) und analog ( s) i,j = s (x i,j ) für x i,j Ω h. Betrachten wir das durch Gleichung (2.12) diskretisierte Skalarfeld s in jedem Gitterpunkt, können wir den diskretisierten Laplace- Operator als Matrix auffassen, welche die folgende Gestalt aufweist: 1 h 2 B n I n. I..... n In I n B n 4 1. mit B n = Rn n. (2.13) 1 4 Hierbei bezeichnet I n die Einheitsmatrix der Dimension n n. Wenden wir auf die im Ort diskretisierte Gleichung (2.11) ein explizites Zeitschrittverfahren der Form u (x, t + t) = u (x, t) + ν t u (x, t) (2.14) an, so tritt erneut das Problem der Instabilität für große Zeitschrittweiten t beziehungsweise große kinematische Viskositäten ν auf. Diese Schwierigkeit taucht auf, da die Methode einem expliziten Euler- Verfahren entspricht und daher ähnliche Eigenschaften bezüglich der Stabilität aufweist. Um eine stabile Lösungsmethode zu konstruieren, verwenden wir statt des in Gleichung (2.14) angeführten ein implizites Verfahren, was sich durch Übertragen auf unsere Schreibweise innerhalb eines Zeitschrittes schreiben lässt als (I ν t ) w 3 = w 2, (2.15) wobei I den Identitätsoperator darstellt. Diese Gleichung entspricht einer Poisson-Gleichung für das Geschwindigkeitsfeld w 3. Setzen wir den diskretisierten Laplace-Operator aus Gleichung (2.13) in Gleichung (2.15) ein, so ergibt sich die Darstellung für die Systemmatrix des zu lösenden Gleichungssystems als ν t h 2 B n I n 4 + h2. I..... n In mit B n = 1 I n B n ν t h2 ν t. (2.16) Das daraus resultierende Gleichungssystem müssen wir nun effizient lösen, worauf wir in Kapitel 3.1 eingehen.

13 KAPITEL 2. THEORETISCHE GRUNDLAGEN 11 Projektion Im Projektionsschritt betrachten wir Gleichung (2.4) und erhalten wie im Diffusionsschritt eine Poisson- Gleichung zur Berechnung des Druckfeldes p. Auch hier ergibt sich durch die Diskretisierung von ein dünn besetztes lineares Gleichungssystem mit rechter Seite w 3, welches wir lösen müssen, um als Abschluss unseres Algorithmus die aktualisierte Geschwindigkeit über die Gleichung u (x, t + t) = w 4 = w 3 p (2.17) berechnen zu können. Dazu verwenden wir folgende Diskretisierungen der auftretenden Operatoren: ( s ( s) i,j = x, s ) ( si+1,j s i 1,j y i,j 2h ( ) ( v x ( v) i,j = x + vy v x i+1,j vi 1,j x y 2h i,j, s ) i,j+1 s i,j 1 2h + vy i,j+1 vy i,j 1 2h ) (2.18), (2.19) wobei s erneut ein Skalarfeld und v = (v x, v y ) ein zweidimensionales Vektorfeld mit x- und y-komponente bezeichnet. Analog zu der Schreibweise in Gleichung (2.12) repräsentieren (.) i,j die entsprechenden Größen ausgewertet im Punkt x i,j Ω h. Nun sind wir in der Lage, im nächsten Zeitschritt das Geschwindigkeitsfeld zu berechnen und schließen somit die Diskretisierung der Navier-Stokes Gleichungen (2.1) und (2.2) ab. Dazu fassen wir die wesentlichen Ergebnisse dieses Unterkapitels in algorithmischer Form zusammen. Wir orientieren uns dabei an den in Schema (2.8) angeführten Schritten und erhalten so ein kompaktes numerisches Lösungsverfahren der Navier-Stokes Gleichungen. Algorithmus ( Stable Fluids Lösungsverfahren für die Navier-Stokes Gleichungen nach [Stam]) Sei ein initiales Geschwindigkeitsfeld w 0 (0) (x) = u (x, 0) gegeben. Für l = 1,..., L 1. Kraft aufprägen: w (l) 1 (x) = w (l 1) 0 (x) + tf (l) (x) 2. Advektion: w (l) 2 (x) = w (l) ( 1 x tw (l) 1 (x) ) 3. Diffusion: bestimme w 3 (l) über (I ν t ) w 3 (l) = w 2 (l) 4. Projektion: w 4 (l) = w 3 (l) p (l), wobei sich p (l) ergibt aus p (l) = w 3 (l) 5. Aktualisierung: w 0 (l) (x) = u (x, l t) = w 4 (l) (x) Die Anzahl L + 1 der durchzuführenden Zeitschritte legen wir dadurch fest, wie lange wir die Simulation ausführen. Das Kraftfeld f (l) wird durch den Anwender von außen bestimmt und steht in jedem Zeitschritt aktualisiert zur Verfügung. Die genaue Umsetzung der Schritte in Algorithmus stellen wir in Kapitel 3 vor.

14 Kapitel 3 Implementierung Nachdem wir in Kapitel 2 auf die in unserer Simulation verwendete Theorie bezüglich Modell, Diskretisierung und numerischer Lösung eingegangen sind, wollen wir uns nun ihrer Umsetzung und der Realisierung der Visualisierung und Interaktion auf einem Tablet-Computer widmen. Die Strömungssimulation führen wir auf dem Asus EeePad Transformer TF101, auf dem das Betriebssystem Android installiert ist, in einer App aus. Details zur Hardware des verwendeten Tablet-Computers finden sich in Kapitel 4.4. Der Anwender hat während der Simulation die Möglichkeit, die Strömung eines Fluids durch Berühren des Bildschirms zu beeinflussen. Strömungssimulationen, wie sie etwa bei [Stam] oder [Harris] beschrieben werden, können vom Nutzer durch Interaktion mit der Maus beeinflusst werden, auf einem Tablet-Computer besteht jedoch die Möglichkeit, dies mit einem Finger auf dem Bildschirm durchzuführen. Dadurch wirkt die Simulation für den Betrachter realer. Die Möglichkeit, solche Computer zur Strömungssimulation einzusetzen, wird dadurch eröffnet, dass Tablet-Computer hinsichtlich ihrer Rechenleistung immer leistungsfähiger werden. Bevor wir auf die konkrete Implementierung des in Kapitel 2 vorgestellten Verfahrens eingehen, wollen wir zunächst das Vorgehen bei einer App-Programmierung in der Programmiersprache Java für das Android-Betriebssystem erläutern, wobei wir uns an [Android Developer] orientieren. Zunächst installieren wir eine Software-Entwicklungsumgebung wie etwa Eclipse 1, in der wir die eigentliche Programmierung durchführen. Ergänzend benötigen wir das Android Software Development Kit sowie die Android Development Tools, die wir in die Entwicklungsumgebung einbinden müssen. Anschließend können wir ein neues Android App Project erstellen, welches die App repräsentiert. Dabei werden einige Dateien automatisch erstellt, wie etwa die Manifest-Datei, die eine zentrale Rolle einnimmt, da sie die fundamentalen Charakteristiken der App beschreibt und jede ihrer Komponenten definiert. Die Programmierung einer App unterscheidet sich vor allem dadurch von einer gewöhnlichen Java-Programmierung, als dass zum korrekten Erstellen der App viele spezielle Funktionen vom System verlangt werden, die wir implementieren müssen. Auch die Umsetzung der Visualisierung mit Hilfe der OpenGL ES 2.0- Bibliothek verlangt ein gesondertes Vorgehen: Wir müssen die Visualisierung in eine eigene Klasse auslagern, diese entsprechend kennzeichnen und erneut vom System verlangte Funktionen integrieren. Ähnlich verhält es sich bei der Berücksichtigung der Anwender-Interaktion. Um eine App schließlich auszuführen, bestehen zwei Möglichkeiten: Einerseits können wir die App auf einem externen Android-Gerät starten, zum Beispiel einem Tablet-Computer, andererseits den Emulator nutzen. Dabei handelt es sich um eine sogenannte Android Virtual Device, die auf dem Computer ausgeführt wird, auf dem sich die Entwicklungsumgebung befindet. Die Virtual Device entspricht einem externen Gerät, welches auf dem Computer simuliert wird. Es empfiehlt sich, die App zunächst im Emulator zu testen, da bei eventuellen Programmierfehlern das externe Gerät durch Überhitzung oder ähnliches beschädigt werden kann. Bisher ist es nicht möglich Apps auf dem Emulator zu testen, die sich der Bibliothek OpenGL ES 2.0 zur Darstellung von Grafiken bedienen, wie wir sie für 1 Für nähere Informationen verweisen wir auf 12

15 KAPITEL 3. IMPLEMENTIERUNG 13 die Fluidsimulation nutzen. So können wir nur Apps ausführen, die eine reine Textausgabe verwenden. Dennoch spielt der Emulator eine zentrale Rolle für die Erstellung einer apk-datei, welche dem kompilierten Programm entspricht. Wir müssen diese Datei auf dem Tablet-Computer zur Ausführung der App installieren. Sobald wir eine App über den Emulator starten, wird die zugehörige apk-datei erstellt, die wir via USB-Stick oder auf den Tablet-Computer transferieren und installieren können. Anschließend können wir die App ausführen. Das hier beschriebene Vorgehen zur Entwicklung einer App macht deutlich, dass sich die App-Programmierung in einigen Punkten signifikant von der üblichen Programmierung in Java (oder einer anderen Programmiersprache) unterscheidet, was nicht zuletzt an der Verwendung von externen Geräten wie Smartphones oder Tablet-Computern liegt. Im Folgenden stellen wir unsere Implementierung vor und betrachten ihre wesentlichen Punkte im Detail, welche sich in drei Bereiche gliedern lassen: den Löser, die Visualisierung und die Anwender-Interaktion. Die Größen, die in diesen Bereichen variabel sind, teilen sich in numerische und physikalische Parameter auf: die Gitterschrittweite h, die Zeitschrittweite t, die Anzahl maxiter der im linearen Löser für die Poisson-Probleme durchzuführenden Iterationen auf der einen und die Richtgeschwindigkeit v 0, die für einige Testfälle, die wir in Kapitel 4 untersuchen, relevant ist, sowie die Viskosität ν auf der anderen Seite. Betrachten wir also zuerst den Teil der Implementierung, der das numerische Lösen der Navier-Stokes Gleichungen enthält. 3.1 Löser In Kapitel 2 haben wir die Navier-Stokes Gleichungen hergeleitet und einen Weg beschrieben, wie wir diese numerisch lösen können. Den hierbei entwickelten Algorithmus setzen wir in unserer App in der Funktion velocity um, die uns in jedem Zeitschritt das aktuelle Geschwindigkeits- und Druckfeld liefert. Die Schritte in Algorithmus repräsentieren auch die Gliederung des Quellcodes des Lösers. Alle Berechnungen führen wir dabei mit doppelter Genauigkeit durch. Wie in Abschnitt 2.4 beschrieben, lösen wir die Navier-Stokes Gleichungen (2.1) und (2.2) auf einem diskreten Gebiet Ω h = [ 1, 1] 2, welches sich durch die Wahl einer Gitterschrittweite h R ergibt. Dadurch liegen insgesamt N = ( 1 h + 1) 2 Gitterpunkte vor. In jedem dieser Punkte berechnen wir nun mit Hilfe unseres Algorithmus die Geschwindigkeit in x- und y-richtung. Zur Speicherung der Ergebnisse benötigen wir also Datenarrays der Länge 2N, wobei wir in den ersten N Einträgen die Geschwindigkeit in x- und in den restlichen die in y-richtung speichern. In den Zeitschritten resultiert das anfängliche Geschwindigkeitsfeld aus Randbedingungen und dem aktualisierten Geschwindigkeitsfeld aus dem vorherigen Zeitschritt. Zu Beginn liegt uns das initiale Geschwindigkeitsfeld w 0 des Fluids vor, das sich aus Anfangs- und Randbedingungen ergibt. Ähnlich wie in Kapitel 2 widmen wir uns nun den einzelnen Bestandteilen von Algorithmus und erläutern ihre genaue Umsetzung in unserer Implementierung Kraft aufprägen In einem Zeitschritt prägen wir dem Fluid eine Kraft force auf, was in dem Schritt add force der Funktion velocity geschieht und dem ersten Schritt in Algorithmus entspricht. Das Aufprägen der Kraft realisieren wir, wie in Gleichung (2.9) angeführt, durch ein einfaches Vektorupdate, was in Quellcode 3.1 angeführt ist. Daraus ergibt sich ein neues Geschwindigkeitsfeld w 1, das wir in den weiteren Berechnungen des Zeitschritts betrachten. Quellcode 3.1: Aufprägen der Kraft f o r ( i =0; i < 2N; i ++) w1 [ i ] = w0 [ i ] + d t f o r c e [ i ] ;

16 KAPITEL 3. IMPLEMENTIERUNG 14 Das Aufprägen einer Kraft geschieht durch Berühren des Bildschirms durch den Anwender, was wir in Kapitel 3.3 genauer erläutern. Sollte keine Interaktion vom Anwender ausgehen, ist jeder Eintrag im force-array Null und es wird keine externe Kraft aufgeprägt Advektion Im anschließenden Schritt advect, der den Einfluss der Advektion in die Simulation integriert und dem zweiten Schritt in Algorithmus entspricht, verwenden wir einen Tracer, um ein neues Geschwindigkeitsfeld zu berechnen, wie es in Abbildung 2.3 dargestellt ist. Der Aufbau des Tracers ist nicht trivial, weshalb wir genauer auf seine konkrete Umsetzung eingehen. Das Ziel des Tracers ist es, mit Hilfe von Gleichung (2.10) eine neue Geschwindigkeit aus bereits zuvor berechneten Geschwindigkeiten zu ermitteln. Dazu betrachten wir die aktuelle Geschwindigkeit beispielsweise im Punkt x, und gehen t w 1 (x) im Ort zurück. Wir erhalten einen neuen Punkt X, der jedoch nicht zwingend auf unserem Gitter liegt, was in der Abbildung 3.1 dargestellt ist. Abbildung 3.1: Zweidimensionales Rechengebiet mit Gitterpunkten und Geschwindigkeitsfeld Wie in Gleichung (2.10) beschrieben, wollen wir die Geschwindigkeit im Punkt X als neue Geschwindigkeit des Ausgangspunkts x setzen. Dies ist jedoch nicht möglich, wenn X keinen Punkt unseres Gitters Ω h darstellt. Daher ist es notwendig, die Punkte in unserem Gitter zu bestimmen, welche X umgeben. Diese bezeichnen wir mit P0, P1, P2 und P3. Aus den Geschwindigkeiten in diesen vier Punkten berechnen wir eine Approximation der Geschwindigkeit w 2 im Punkt X. Dazu verwenden wir eine bilineare Interpolation der Werte w 1 (P0), w 1 (P1), w 1 (P2) und w 1 (P3). Wir müssen jedoch beachten, dass wir möglicherweise auf Gitterpunkte zugreifen, die außerhalb unseres Rechengebiets Ω liegen. Dies kann auftreten, wenn die Strecke t w 1 (x) zu groß ist und wir das Gitter verlassen. Wenn wir zur Veranschaulichung Abbildung 3.1 heranziehen, so würde die grüne Strecke außerhalb des Gitters enden. Wir überprüfen daher in jedem Schritt, ob X = x t w 1 (x) noch innerhalb unseres Gitters liegt. Falls dies nicht der Fall ist, setzen wir P0, P1, P2 und P3 als die Ecken des Teilquadrates des Gitters, das den kleinsten Abstand zu dem Punkt X außerhalb des Gitters aufweist Diffusion Der nächste Schritt in Algorithmus ist der Diffusionsschritt, der in der Funktion velocity dem Abschnitt diffuse entspricht. Hier haben wir uns das Ziel gesetzt, das aus Gleichung (2.15) resultierende dünn besetzte Gleichungssystem effizient zu lösen. Zur Vereinfachung der Implementierung lösen wir das System für die x- und y-richtung separat, was durch die komponentenweise Anwendung des

17 KAPITEL 3. IMPLEMENTIERUNG 15 Laplace-Operators auf ein Vektorfeld möglich ist (vgl. Abschnitt 2.4). Wir ziehen daraus den Vorteil, dass wir für beide Systeme den gleichen Quellcode verwenden können. Somit erhalten wir die folgenden zwei Gleichungssysteme der Dimension N N: (I ν t ) w 3 x,y = w 2 x,y (3.1) Um diese Gleichungssysteme hardwareeffizient auf dem gegebenen kartesischen Pixelgitter zu lösen, verwenden wir die sogenannte Stencil-Methode, die wir im Folgenden erläutern. Dazu betrachten wir die Diskretisierung des Laplace-Operators, wie wir sie in Gleichung (2.12) beschreiben. Das Skalarfeld s müssen wir dabei entweder durch w 3 x oder w 3 y ersetzen, je nachdem, welches Gleichungssystem wir lösen wollen. Ein erster Schritt besteht darin, eine allgemeine Rechenvorschrift für die Anwendung des Jacobi-Lösers auf ein lineares Gleichungssystem zu finden. Dazu multiplizieren wir die Matrix (2.16) mit dem unbekannten Lösungsvektor w 3 x,y. Anschließend lösen wir in dem zugehörigen Gleichungssystem zeilenweise nach (w 3 x,y ) i,j auf und skalieren die rechte Seite des Gleichungssystems mit dem entsprechenden Diagonaleintrag. Das Vorgehen für die Berücksichtigung der x- beziehungsweise y-komponenten ist das gleiche, da es sich in beiden Fällen um die gleiche Systemmatrix handelt. So erhalten wir die in Gleichung (3.2) angegebene allgemeine Rechenvorschrift für die Anwendung des Jacobi-Lösers: q (k+1) i,j = q(k) i 1,j + q(k) i+1,j + q(k) i,j 1j + q(k) i,j+1 + αr i,j β (3.2) Wir geben hier die allgemeine Form dieses Lösungsverfahrens in Abhängigkeit der Variablen (q) i,j und (r) i,j an, weil wir es im Diffusions- und im Projektionsschritt anwenden (vgl. Gleichungen (2.4) und (2.11)). Im Diffusionsschritt repräsentiert (q) i,j das Geschwindigkeitsfeld (w x,y 3 ) i,j und (r) i,j die rechte Seite (w x,y 2 ) i,j des Gleichungssystems ausgewertet im Punkt x i,j Ω h. Die Konstanten α, β R hängen vom konkreten Gleichungssystem ab. Im Diffusionsschritt ergeben sie sich zu α = h2 ν t und β = 4 + α. Der Index k {0,..., maxiter} gibt den aktuellen Iterationsschritt im Jacobi-Löser an. Mit der Berechnungsvorschrift (3.2) können wir jedoch nur die aktualisierten Werte für die inneren Gitterpunkte bestimmen, da die Matrix für die Randwerte eine andere Gestalt aufweist. Um diese zu bestimmen, müssen wir die Randbedingungen verwenden. Wir schreiben für die Geschwindigkeit noslip -Randbedingungen vor (vgl. Abschnitt 2.2), was bedeutet, dass (w 3 x,y ) i,j = 0 x i,j Ω h gilt. Mit Hilfe der Stencil-Methode ergibt sich eine Möglichkeit, die auftretenden Gleichungssysteme effizient zu lösen. Da die Koeffizienten α und β der Komponenten des Lösungsvektors bekannt und oftmals sogar gleich sind, müssen wir diese nicht für jeden Eintrag des Vektors explizit speichern. Wir müssen dabei beachten, dass wir dieses Vorgehen nur anwenden können, wenn konstante Koeffizienten vorliegen. Durch die Anwendung der Stencil-Methode sparen wir das Speichern einer ganzen Matrix zur Lösung des Gleichungssystems, was es uns ermöglicht, das Gleichungssystem hardwareeffizient zu lösen Projektion Der abschließende Schritt in Algorithmus aus ist der Projektionsschritt project. Hier müssen wir unter anderem w 3 = w 3 x x + w 3 y y berechnen. Zur Diskretisierung der dabei auftretenden ersten Ableitungen können wir die in Gleichung (2.19) angeführte Approximation nutzen. Die diskretisierte Divergenz des Geschwindigkeitsfeldes w 3 können wir berechnen, da der Wert des Feldes in jedem Gitterpunkt aus dem Diffusionsschritt bekannt ist. Um die Divergenz an den Rändern zu berechnen, bedarf es einseitiger Differenzenquotienten zweiter Ordnung, da wir für den zentralen Differenzenquotienten in Normalenrichtung auf Punkte zugreifen müssten, die außerhalb des Gitters liegen. In den Ecken verwenden wir für beide Terme einseitige Differenzenquotienten. Wir müssen in diesem Schritt des

18 KAPITEL 3. IMPLEMENTIERUNG 16 Algorithmus die Poissongleichung (2.4) für das Druckfeld p mit der durch Gleichung (2.19) berechneten rechten Seite lösen. Durch die Diskretisierung mit finiten Differenzen erhalten wir, wie im Diffusionsschritt, ein lineares Gleichungssystem. Dieses können wir nun mit Hilfe der in Gleichung (3.2) hergeleiteten Stencil-Methode für das Jacobi-Verfahren lösen. Die Konstanten müssen wir dabei als α = h 2 und β = 4 wählen. Auch in diesem Fall können wir so nur die Werte im Inneren des Gitters berechnen. Um Werte an den Rändern zu erhalten, müssen wir die Randbedingungen für den Druck berücksichtigen (vgl. Abschnitt 2.2). Wir gehen in unserem Fall davon aus, dass für den Druck Neumann-Null-Randbedingungen gelten, was bedeutet, dass die Ableitung in Normalenrichtung am Rand verschwindet. Dazu betrachten wir den einseitigen Differenzenquotienten erster Ordnung für die erste Ableitung beispielhaft an einem Punkt des linken Randes (vgl. Abbildung 3.2(b)). Stellen wir ihn nach p i,j um, erhalten wir: p i,j = p i,j p i+1,j h! = 0 p i,j = p i+1,j (3.3) Es ergibt sich, dass wir die Druckwerte am Rand des Gebiets als den Wert des Drucks im nächst inneren Punkt in negativer Normalenrichtung setzen. In den Ecken des Gebiets definieren wir zunächst sowohl die Ableitung in x- als auch in y-richtung als Normalenableitung. Deshalb setzen wir den Druck in den Eckpunkten als Mittel der Druckwerte in den benachbarten Randpunkten. Um den Projektionsschritt abzuschließen, verwenden wir zur Diskretisierung des Druckgradienten p die in Gleichung (2.18) angeführte Diskretisierung. Anschließend können wir p berechnen, indem wir wie bei der Berechnung der Divergenz vorgehen. Aus Gleichung (3.3) folgt, dass wir den Gradienten an den Gebietskanten in Normalenrichtung zu Null setzen können, anstatt ihn über einseitige Differenzenquotienten zu approximieren. In den Ecken schreiben wir sowohl für die Ableitung in x- als auch die in y-richtung Null vor. Nachdem wir uns in diesem Abschnitt mit der Umsetzung von Algorithmus beschäftigt haben, gehen wir in den folgenden Unterkapiteln auf spezielle Elemente der App-Programmierung ein. Dazu betrachten wir zunächst die Visualisierung der Simulation und widmen uns später der Realisierung der Interaktion. 3.2 Visualisierung Die Strömungssimulation, die wir in dieser Arbeit vorstellen, entsteht durch das unterschiedliche Färben von Punkten in unserem diskreten Gitter. Durch die Änderung dieser Färbung in jedem Zeitschritt wird der Eindruck erweckt, dass das Fluid, was sich in dem diskretisierten Rechengebiet befinden soll, strömt. Zur Visualisierung der Simulation benötigen wir somit zwei Komponenten: die Darstellung des Rechengebiets auf dem Bildschirm und die spezielle Färbung der Gitterpunkte gemäß der Geschwindigkeitsbeziehungsweise Druckwerte. Bei der Umsetzung der Visualisierung haben wir uns an [Learn OpenGL ES] und [Android Developer] orientiert. Wir erläutern zunächst, wie wir das zweidimensionale Rechengebiet aufbauen, und gehen anschließend auf das Färben der Gitterpunkte ein. Das Ausgangsobjekt zur Bildung des zweidimensionalen quadratischen Rechengebiets ist ein Dreieck. Setzen wir mehrere rechtwinklige Dreiecke mit Katheten der Länge h R, die der Gitterschrittweite entspricht, passend aneinander, so können wir ein beliebiges Rechengebiet erzeugen. Da wir jedoch nicht das Einheitsquadrat [0, 1] 2, sondern das Quadrat [ 1, 1] 2 als Rechengebiet verwenden, müssen wir uns dem Aufbau dieses Gebiets genauer widmen, da die Kantenlänge des Quadrats Auswirkungen auf die Wahl der Gitterschrittweite h hat. Dazu betrachten wir zunächst Abbildung 3.2, in der wir sowohl das Einheitsquadrat als auch unser Rechengebiet [ 1, 1] 2 darstellen. Schreiben wir für das Einheitsquadrat in Abbildung 3.2(a) die Anzahl n der Stützstellen vor, so ergibt sich als Gitterschrittweite h = 1 n 1. Betrachten wir nun das große Quadrat in Abbildung 3.2(b) mit einer Seitenlänge von

19 KAPITEL 3. IMPLEMENTIERUNG 17 2 und schreiben hier ebenfalls n als Anzahl der Stützstellen vor, so erhalten wir die Schrittweite durch h = 2h = 2 n 1, also eine doppelt so große Schrittweite wie im Fall des Einheitsquadrats. (a) Einheitsquadrat (b) Rechengebiet Abbildung 3.2: Quadrate zum Aufbau des Rechengebiets Da wir in unserer Implementierung aufgrund des mittig auf dem Bildschirm gelegenen Koordinatenursprungs das große Quadrat zur Diskretisierung nutzen, müssen wir auch in allen Teilproblemen eine Schrittweite von h = 2h verwenden. Im Folgenden erläutern wir, wie wir das Gitter auf dem Bildschirm darstellen. Zum Zeichnen nutzen wir eine Standardfunktion von OpenGL ES 2.0, welche die Dreiecke, die zur Visualisierung des Rechengebiets auf dem Bildschirm nötig sind, darstellt. Diese Methode trägt den Namen drawarrays und verlangt neben der Eingabe der Positionsdaten der Gitterpunkte auch die Farbwerte für jeden Punkt, die wir jeweils in einem Array speichern. Um die Positionen der Gitterpunkte zu bestimmen, müssen wir für jeden Punkt eine x-, y- und z-komponente angeben. Die Positionsdaten legen wir im Konstruktor der Klasse fest, da sie nur ein Mal gesetzt werden müssen und sich dann nicht mehr ändern, weil im Laufe der Simulation die Gitterweite nicht variiert. Es genügt, für die Koordinaten der Gitterpunkte nur die ersten beiden Komponenten zu berücksichtigen und die z-koordinate auf Null zu setzen, weil wir uns auf einem zweidimensionalen Gebiet befinden. Abbildung 3.3: Vorgehen der drawarrays-methode für h = 1 3

20 KAPITEL 3. IMPLEMENTIERUNG 18 Die drawarrays-routine zeichnet die Gitterpunkte beziehungsweise die Dreiecke danach in der Reihenfolge, wie sie im Positionsarray auftauchen. Also müssen wir die Daten im Positionsarray so anordnen, dass drei aufeinander folgende Punkte ein Dreieck bilden. Zur Veranschaulichung betrachten wir Abbildung 3.3. Stellen wir die Punkte im Positionsarray ihrer Reihenfolge nach auf dem Bildschirm dar, so geben wir die meisten Knoten des Gitters mehrfach wieder. Die Nummern an den Knoten geben an, in welchem Schritt des Zeichnens der entsprechende Punkt abgebildet wird. Wir können ihnen entnehmen, wie oft ein Gitterpunkt im Laufe des Gitteraufbaus gezeichnet wird. Im oberen rechten Quadrat in Abbildung 3.3 stellen wir das Vorgehen der drawarrays-methode anhand der roten Pfeile dar. Mit Hilfe dieser Zeichenroutine haben wir also die Möglichkeit, jeden Punkt in unserem Gitter durch einen Eckpunkt eines Dreiecks darzustellen. Die eigentliche Simulation des Fluidverhaltens erfolgt, wie oben beschrieben, durch die Farben, die wir den Gitterpunkten zuordnen. Im Gegensatz zum Positionsarray müssen wir die Färbung in jedem Zeitschritt aktualisieren, um die Simulation zu ermöglichen. Diese entsteht schließlich dadurch, dass wir nach jedem Zeitschritt das neu gefärbte Gitter, den neuen Frame, zeichnen. Zur Definition der Farbe eines einzelnen Gitterpunktes benötigen wir dabei vier double-einträge, die den Rot-, Blau und Grünanteil sowie den Transparenzkoeffizienten angeben. Durch die Funktion colourset, die in Quellcode 3.2 angeführt ist, weisen wir dem Wert value im i-ten Gitterpunkt seine entsprechenden Farbwerte zu. Die Größe value repräsentiert dabei die Geschwindigkeit des Fluids oder den Druck, der auf das Fluid wirkt. Die Farbwerte speichern wir danach im Array colour und übertragen diesen anschließend in den globalen Farbvektor Colours, der die Farbe eines jeden Gitterpunktes genau ein Mal enthält. Quellcode 3.2: Codeausschnitt aus der drawgrid-methode f o r ( i =0; i < 4N; i +=4){ c o l o u r S e t ( double value, double [ ] c o l o u r ) ; C o l o u r s [ i ] = c o l o u r [ 0 ] ; C o l o u r s [ i +1] = c o l o u r [ 1 ] ; C o l o u r s [ i +2] = c o l o u r [ 2 ] ; C o l o u r s [ i +3] = c o l o u r [ 3 ] ; } Das Färben der Gitterpunkte erfolgt genau in der gleichen Reihenfolge wie das Zeichnen des Gitters. Wie im Positionsarray müssen wir die Farbdaten im ColourData-Array so anordnen, dass drei aufeinander folgende Punkte ein Dreieck bilden. Es ist möglich, die Gitterpunkte von verschiedenen Seiten unterschiedlich zu färben, da die zugewiesene Färbung immer nur innerhalb eines Dreiecks gilt. In Abbildung 3.3 können wir einen inneren Gitterpunkt von sechs Seiten färben, da er an sechs Dreiecke grenzt. Um eine sinnvolle Färbung des Gitters zu erhalten und Sprünge in dieser zu vermeiden, müssen wir die Gitterpunkte von jeder Seite gleich färben. Dies realisieren wir im Quellcode durch eine for-schleife, in der wir in dem Farbarray ColourData an jede Stelle, die den selben Gitterpunkt repräsentiert, die zugehörigen vier Einträge aus dem Colours-Array schreiben. Um die Gitterpunkte mit einer Farbe zu versehen, die dem Wert der vorliegenden Größe entspricht, verwenden wir eine sogenannte Heat Map. In unserem Fall greifen wir auf ein Spektrum von 19 Farben zurück, wobei blau gefärbte Punkte sehr kleine Geschwindigkeiten beziehungsweise Drücke repräsentieren und rot gefärbte entsprechend große. Die Färbung einer Dreiecksfläche resultiert aus der Interpolation der Farben seiner Eckpunkte. Die Wahl der genauen Übergänge zwischen den einzelnen Farben variiert von Testfall zu Testfall: In Abschnitt 4.2 bedienen wir uns einer nicht-äquidistanten Zerlegung des Farbspektrums und unterscheiden im Bereich der kleinen Drücke genauer, da der Maximaldruck nur für eine sehr kurze Zeitspanne angenommen wird und anschließend lediglich kleine bis mittelgroße Drücke auftreten. In Unterkapitel verwenden wir hingegen eine äquidistante Unterteilung des Farbspektrums. Um dieses Kapitel zur Implementierung abzuschließen, erläutern wir im folgenden Abschnitt die Umsetzung der Interaktion in unserer Software, die den wesentlichen Bestandteil der interaktiven Strömungssimulation ausmacht.

21 KAPITEL 3. IMPLEMENTIERUNG Interaktion Der Schritt, der die Strömungssimulation interaktiv werden lässt, ist das Aufprägen einer Kraft durch das Berühren des Bildschirms durch den Anwender. Zunächst gehen wir darauf ein, wie wir die Fingerposition auf dem Bildschirm in unser Gitter übertragen und erläutern anschließend, wie wir die Kraft ermitteln, die durch die Interaktion auf das simulierte Fluid übertragen wird. Das zentrale Problem, dem wir bei der Anwender-Interaktion gegenüberstehen, ergibt sich aus den verschiedenen Zeichenebenen, die in OpenGL ES 2.0 zur Verfügung stehen, um dreidimensionale Objekte darzustellen. Zur Veranschaulichung betrachten wir Abbildung 3.4. Abbildung 3.4: Visualisierungsraum von OpenGL ES 2.0 (vgl. [SongHo]) Alle Objekte, die wir mit OpenGL ES 2.0 darstellen, speichern wir zuerst im dreidimensionalen Raum der Objekt-Koordinaten. Anschließend projizieren wir diese auf die zweidimensionale Benutzeroberfläche, den Bildschirm, was die Darstellung dreidimensionaler Körper ermöglicht. Wir können uns leicht überlegen, dass die Bildschirmkoordinaten nicht den Objektkoordinaten entsprechen. Die Bildschirmkoordinaten der Fingerposition, die wir zur Realisierung der Simulation registrieren müssen, geben also nicht die Position des Fingers in dem Gitter des Rechengebiets an. Diese benötigen wir jedoch, um an der richtigen Stelle eine Kraft auf das simulierte Fluid aufzuprägen. Wir sind somit auf eine Transformation angewiesen, die die Bildschirmkoordinaten des Fingers, welche wir mittels einer Standardfunktion von OpenGL ES 2.0 leicht auslesen können, auf die entsprechenden Objektkoordinaten abbildet. Eine solche Transformation stellt die Funktion worldcoords dar, bei deren Implementierung wir uns an [Verdia] orientiert haben. Für weiterführende Informationen bezüglich Bildschirm- und Objektkoordinaten verweisen wir auf [SongHo]. Um auf die Anwender-Interaktion reagieren zu können, verwenden wir die Methode ontouchevent, welche von OpenGL ES 2.0 bereitgestellt wird. Dabei handelt es sich um eine sogenannte Callback - Funktion, was bedeutet, dass sie vom System automatisch aufgerufen wird. Dies geschieht genau dann, wenn der Nutzer den Bildschirm berührt. Wie wir in Kapitel 4.4 sehen, erfolgt die Simulation nicht in Echtzeit, was sich vor allem mit der langen Rechenzeit des Lösers erklären lässt. Auf dem von uns verwendeten Gerät steht uns eine CPU mit zwei Kernen beziehungsweise Threads zur Verfügung. Auf dem einen führen wir die Berechnungen aus und auf dem anderen die Visualisierung inklusive der TouchEvent-Abfragen. Aufgrund der oben beschriebenen Verzögerung ist es möglich, mehrere Aufrufe der ontouchevent-routine pro Zeitschritt durchzuführen, also Abfragen nach sogenannten TouchEvents. Wir überprüfen dabei, ob der Anwender den Bildschirm berührt oder nicht. Die Konsequenzen, die dieses Vorgehen auf die Laufzeit der Simulation hat, untersuchen wir in Abschnitt Pro Zeitschritt berücksichtigen wir nur die Ergebnisse des ersten TouchEvents. Die Behandlung von TouchEvents geschieht wie folgt: Sollte der Bildschirm berührt werden, wird die Funktion ontouchevent aufgerufen. Zuerst lesen wir die Position des Fingers in Bildschirm-

22 KAPITEL 3. IMPLEMENTIERUNG 20 koordinaten mit Hilfe der Funktion getx beziehungsweise gety aus. Danach transformieren wir sie in Objektkoordinaten. Aus der Position des Fingers im vorherigen Zeitschritt können wir die Strecke ermitteln, die der Finger von einem Zeitschritt zum nächsten zurückgelegt hat. Daraus ergeben sich dann die Positionsänderungen dx in x- und dy in y-richtung. Hierbei setzen wir nicht voraus, dass die Position in Objektkoordinaten einem Gitterpunkt entspricht. Da wir eine Kraft jedoch nur in einem solchen Gitterpunkt aufprägen können, ermitteln wir den Knoten, der am nächsten zu den Objektkoordinaten der Fingerposition liegt. In diesem Punkt setzen wir dann die Kraft in x-richtung als dx und die in y-richtung als dy, wodurch gewährleistet ist, dass wir bei schnellerer Bewegung des Fingers dem Fluid eine größere Kraft aufprägen. Das Aufprägen der Kraft erfolgt nun durch Änderungen der Einträge im force-array, die zu dem Gitterpunkt gehören, in dem die Kraft angreifen soll. Mit Hilfe von if-abfragen in der ontouchevent-methode stellen wir sicher, dass ein TouchEvent nur dann berücksichtigt wird, wenn die Objektkoordinaten der Fingerposition innerhalb des Rechengebiets liegen. Zur Vorbereitung des nächsten Zeitschritts setzen wir am Ende des Lösers die zuvor veränderten Einträge im force-array wieder zu Null, da eine Kraft nur innerhalb eines Zeitschritts wirken soll. 3.4 Demonstration des Gesamtsystems In den vorherigen Kapiteln haben wir ein Verfahren zur numerischen Lösung der Navier-Stokes Gleichungen hergeleitet und dessen Umsetzung auf Tablet-Computern erläutert. Bevor wir in Kapitel 4 eine genauere Analyse der Implementierung durchführen, wollen wir vorab einen ersten Eindruck der Simulation vermitteln. Dazu stellen wir in Abbildung 3.5 eine Absolutgeschwindigkeitsverteilung im Fluid dar. Die angeführten Bilder sind einem Video entnommen, welches dieser Arbeit beiliegt. (a) initiale Geschwindigkeitsverteilung (b) leicht beeinflusste Strömung (c) schnelle Anwender-Interaktion (d) langsame Anwender-Interaktion Abbildung 3.5: Darstellung des Betrags des Geschwindigkeitsfeldes für verschiedene Interaktionen

23 KAPITEL 3. IMPLEMENTIERUNG 21 Wir betrachten hier das Szenario, in dem an der oberen Kante des Rechengebiets permanent eine von Null verschiedene Geschwindigkeit angetragen ist. In der unteren linken Ecke des Gebiets befindet sich eine Druckspitze. Erläuterungen zu diesen Rand- beziehungsweise Anfangsbedingungen finden sich im folgenden Kapitel. Außerdem erfolgt im Laufe der Ausführung der Simulation eine Interaktion durch einen Anwender. In Abbildung 3.5(a) sehen wir die initiale Verteilung des Geschwindigkeitsfeldes, welches anschließend durch den Anwender leicht gestört wird, was in Abbildung 3.5(b) zu beobachten ist. In Abbildung 3.5(c) erkennen wir die Entwicklung der Geschwindigkeit im Fluid nach einer schnellen, kreisförmigen Interaktion des Anwenders und zuletzt in Abbildung 3.5(d) das Verhalten des Fluids, wenn der Anwender eine langsame Interaktion ausführt. Dabei können wir sehr gut die Strömung erkennen, die durch das Aufprägen der externen Kräfte ausgelöst wird.

24 Kapitel 4 Tests 4.1 Validierung In dem ersten Abschnitt dieses Kapitels untersuchen wir die numerische Stabilität und physikalische Korrektheit unserer Simulation. Wir wollen dies anhand von einfachen Testfällen überprüfen. Zur Untersuchung werden wir sowohl visuelle Darstellungen nutzen, als auch Diagramme von Druck- und/oder Geschwindigkeitsverläufen Numerische Stabilität Wir werden zunächst am einfachsten Testfall Steady überprüfen, ob unsere Implementierung numerisch stabil läuft. Dazu verwenden wir folgende Wahl der Parameter: h = 1 h, ν = , maxiter = 32, t =, v 0 = (4.1) v 0 Als Erstes werden wir nun den Testfall Steady beschreiben und erläutern, warum sich dieser gut zur überprüfung der numerischen Stabilität eignet. Im Testfall Steady setzen wir alle initialen Werte auf Null. Das heißt, in jedem Punkt unseres Gitters herrscht ein Druck von Null, die Geschwindigkeit beträgt Null und auch wirkt nirgends eine initial gesetzte Kraft. Wir haben also eine ruhige Simulationsumgebung gegeben, welche im Folgenden nicht weiter beeinflusst wird, da wir bei diesem Test keine Interaktion durch den Anwender erlauben möchten. Ziel dieses Tests ist es, unsere Simulation über einen längeren Zeitraum zu beobachten und zu untersuchen, ob sich trotz allgemeiner Null-Anfangsbedingung Geschwindigkeiten oder Drücke einstellen, welche nach unserer Auffassung nicht existieren dürften. Da unsere farbige Visualisierung lediglich in 19 Farben unterteilt wurde, könnte es jedoch sein, dass beim Auftreten sehr kleiner Geschwindigkeiten, diese visuell durch das Verwenden unserer Heat Map, nicht in Erscheinung treten. Um diesen Effekt zu kompensieren werden wir die Druck-, beziehungsweise die Geschwindigkeitsvektornorm numerisch untersuchen (vgl. Abbildung 4.1). Wir berechnen somit in jedem Zeitschritt die Norm des Druck- und Geschwindigkeitsvektors und geben den Verlauf über unser Zeitintervall im nachfolgendem Diagramm 4.1 wieder. Deutlich zu erkennen ist, dass sowohl die Norm des Druckvektors, als auch die des Geschwindigkeitsvektors über unser Zeitintervall konstant bei Null bleibt. Es tritt also der intuitive Fall ein, dass unsere Flüssigkeit im Modell bei allgemeinen Null-Anfangsbedinungen auch nach langer Zeit ruhig bleibt und keinerlei Bewegung aufweist. Somit haben wir in unserem ersten Test die Stabilität unseres Verfahren nachgewiesen, können jedoch noch keine Angaben dazu machen, ob sich unsere Software physikalisch richtig verhält (vgl. Abschnitt 4.1.2). 22

25 KAPITEL 4. TESTS 23 1 x 10 4 Geschwindigkeit Druck Vektornorm Zeitschritt Abbildung 4.1: Vektornomen des Druck- und Geschwindigkeitsvektors über mehrere Zeitschritte Physikalisch richtiges Verhalten Wie schon im vorherigen Kapitel erwähnt, werden wir in diesem Abschnitt unsere Software auf die Korrektheit ihrer Lösung untersuchen. Wir werden also herausfinden, ob sich unsere Simulation physikalisch richtig verhält. Um dies zu erzielen, greifen wir auf den gängigen Testfall Driven Cavity zum Testen von Strömungssimulationen zurück. Abbildung 4.2: Konfiguration für den Testfall Driven Cavity Driven Cavity ist ein einfacher Testfall, an dem man jedoch viel über die Richtigkeit unserer Implementierung erfahren kann. Wir wollen zunächst erläutern, welche Testkonfiguration für Driven Cavity gewählt werden muss. Der wichtigste Schritt ist, die richtigen Anfangs- und Randbedingungen vorzu-

26 KAPITEL 4. TESTS 24 schreiben. Ziel bei Driven Cavity ist es, an einer Kante unseres Gitters in tangentialer Richtung mit konstanter Geschwindigkeit v 0 kontinuierlich, das heißt während des gesamten Zeitintervalls, zu strömen, wie in Abbildung 4.2 dargestellt. An allen übrigen Kanten wird über das Zeitintervall hinweg Null vorgeschrieben, sowohl in x- als auch in y- Richtung. In unserem Fall wählen wir die obere Kante und strömen in positive x-richtung. Um zu erreichen, dass wir in jedem Zeitschritt erneut die Geschwindigkeit v 0 an der oberen Kante in x- Richtung und Geschwindigkeit Null an den anderen Kanten aufprägen, müssen wir dies am Ende jedes Zeitschritts in unserem Löser velocity und am Anfang des Tracer (vgl. Kapitel 3.1) erneut setzen, da hier die Randwerte überschrieben werden und wir dies nicht zulassen wollen. In den übrigen Teilen unseres Lösers müssen wir dies nicht tun, da hier lediglich die inneren Gitterpunkte behandelt werden (siehe Kapitel 3.1). Als nächstes legen wir nun unsere Parameter wie folgt fest: h = 1 h, ν = , maxiter = 32, t =, v 0 = (4.2) v 0 Visuell wird die x-komponente der Geschwindigkeit dargestellt und es ergibt sich folgendes initiales Bild (Abbildung 4.3): Abbildung 4.3: Initale Verteilung der x-komponete der Geschwindigkeit Man kann in Abbildung 4.3 deutlich eine Strömung an der oberen Kannte unseres Gitters erkennen, genauso wie wir es vorgegeben haben. An allen übrigen Punkten unseres Gitters beträgt die Geschwindigkeit in x-richtung Null. Wenn wir unsere Simulation über einen längeren Zeitraum laufen lassen, stellen wir fest, dass sich die in Abbildung 4.4 angeführte Verteilung der Geschwindigkeit einstellt und diese sich auch nach weiteren Zeitschritten nicht weiter verändert. Um die Korrektheit unserer Lösung zu verifizieren, vergleichen wir unsere visuelle Darstellung in Abbildung 4.4(a) mit bekannten richtigen Lösungen dieses Testfalls in Abbildung 4.4(b). Es ist gut zu erkennen, dass unsere Darstellung die gleichen Merkmale aufweist wie das Referenzbild 4.4(b). Am oberen Rand stellt sich ein Gebiet ein, welches große Geschwindigkeiten in x-richtung aufweist, da hier die kontinuierliche Geschwindigkeit v 0 eingestellt wird, welche jedoch zur Mitte hin immer weiter abnimmt. Die Form dieses Gebietes ist bei beiden Bildern, bis auf unterschiedliche Färbungen, zurückzuführen auf das Verwenden verschiedener Heat Maps (vgl. Kapitel 3.2), gleich. In unserem Fall wird das Farbspektrum in 19 Farben unterteilt und im Referenzfall in 26 (vgl. Kapitel 3.2 und [CFD Online]). In der Mitte schließlich zieht sich ein nahezu stillstehendes Gebiet, erkennbar durch die dunkelblaue

27 KAPITEL 4. TESTS 25 Färbung, in die obere rechte Ecke. Da es eine sehr große Ähnlichkeit zwischen unserem und dem Referenzbild gibt, können wir erwarten, dass unsere Strömungssimulation richtig implementiert wurde und einer physikalisch realistischen Simulation entspricht. (a) Darstellung des Testfalls Driven Cavity nach vielen Zeitschritten (b) Referenzbild zu Driven Cavity von [CFD Online] Abbildung 4.4: Vergleich unserer Simulation durch ein Referenzbild am Testfall Driven Cavity Wir gehen somit in den folgenden Kapiteln davon aus, dass unsere Software einer physikalisch richtigen Simulation enspricht und numerisch stabil läuft.

28 KAPITEL 4. TESTS Parametertests In diesem Abschnitt wollen wir den Einfluss verschiedener Parameter auf unsere Simulation am Testfall Hubbel (vgl. Abbildung 4.5) untersuchen. Als Erstes wollen wir den Einfluss der Viskosität ν, welches ein Maß für die Zähflüssigkeit unseres zugrunde liegenden Fluids darstellt, untersuchen. Anschließend befassen wir uns mit dem Zeitschritt t, welcher ausschließlich im Tracer (siehe hierzu Ka pitel 3.1) benötigt wird und hier ein Maß für die Genauigkeit darstellt. Als Letztes werden wir den Einfluss der Anzahl der Jacobi-Schritte und damit die Genauigkeitsanforderungen des linearen Lösers (vgl. Kapitel 3.1) untersuchen und anhand der visuellen Darstellung unserer Simulation analysieren, wie genau wir lösen müssen, um Symmetrie zu erreichen. Sollte unser Verfahren, unter der Voraussetzung eines symmetrischen Testfalls, symmetrische Ergebnisse liefern, so können wir von einer sehr guten numerischen Approximation einer realen Lösung sprechen, was in unserem Fall aus einer hohen Genauigkeit des Druck- und Geschwindigkeitsfeldes resultiert. Als Standardkonfiguration wählen wir folgende Werte für die in unserem Modell frei wählbaren Parameter: n = 129, h = 1 128, ν = , v 0 = , t = 1, maxiter = 32 (4.3) (n 1) v In diesem Fall und anders als im vorherigen Testfall Driven Cavity (vgl. Kapitel 4.1.2) benötigen wir v 0 lediglich zur Bestimmung von t, da wir im folgenden keine initiale oder kontinuierliche Geschwindigkeit auftragen wollen. Während jedes Tests wird ausschließlich ein Parameter verändert, um seine Auswirkungen unabhängig von den anderen Größen analysieren zu können. Als Ausgangssituation wählen wir den Testfall Hubbel, den wir als nächstes beschreiben werden: Die initiale Geschwindigkeit und Kraft in jedem Punkt unseres Gitters setzen wir als Null und schreiben für den Druck Werte so vor, dass wir zwei Druckspitzen erhalten (siehe Abbildung 4.5). Dies realisieren wir mit Hilfe der Gaußglockenkurve im Zweidimensionalen (siehe Gleichung (4.4)), da wir so außerhalb der Druckspitzen nahezu Null realisieren können und wir einen stetigen Druckverlauf, sogar C, erzielen: ( ) f(x, y) = exp a (x x 0 ) 2 + a (y y 0 ) 2 + b (4.4) Hierbei ist a ein Verzerrungsfaktor und b der Wert im Glockenmittelpunkt (x 0, y 0 ). Addieren wir nun zwei Glockenkurven mit a = 50, b = 0, x 1 0 = 0.5 und y1 0 = 0.5 beziehungsweise x2 0 = 0.5 und = 0.5, erhalten wir die folgende initiale Druckverteilung: y Abbildung 4.5: Initiale Druckverteilung des Testfalls Hubbel mit zwei Druckspitzen

29 KAPITEL 4. TESTS 27 Da wir die Druckverteilung lediglich anfänglich setzen, fallen im Laufe der Zeit die Druckspitzen zusammen und es entstehen Wellen. Dabei kann man mit Hilfe der Addition mehrerer Gaußkurven beliebig viele Druckspitzen erzeugen Viskosität Die Viskosität ist der einzige freie Parameter unseres Modells zur Simulation von Strömungen, welcher unser betrachetes Fluid beschreibt und daher von entscheidener Bedeutung bei der Untersuchung unserer Implementierung. Im Folgenden wollen wir den Einfluss der kinematischen Viskosität ν auf unsere Simulation untersuchen, indem wir verschiedene Werte für ν vorschreiben und das Fließverhalten und die Druckverläufe unserer Flüssigkeit untersuchen. Dazu betrachten wir die in der Tabelle 4.1 aufgelisteten Stoffe, wobei die Dichte in [ρ] = kg, die dynamische Viskosität in [η] = Ns und die kinematische m 3 m 2 Viskosität in [ν] = m2 s angeben wird: Dichte dynamische Viskosität kinematische Viskosität Quecksilber Wasser bei 20 C Motoröl Olivenöl Tabelle 4.1: Stoffspezifische Größen Zur Untersuchung analysieren wir den Druck im Mittelpunkt unseres Gebiets entlang eines Zeitintervalls für unterschiedliche Werte von ν. Wir wählen den Mittelpunkt unseres Gebiets als Referenzpunkt, da hier durch die Gaußkurven ein Druck von nahezu Null herrscht und wir mit Sicherheit keinen Punkt am Rand betrachten, an dem besondere Randbedingungen gelten und wir dies ausschließen möchten (vgl. Ka pitel 2.2). Zu erwarten ist, dass Fluide mit höherer Viskosität kleinere Druckamplituden entwickeln und die Amplitudenlänge geringer ist als bei Fluiden geringerer Viskosität Motoroel Olivenoel Druck Zeitschritt Abbildung 4.6: Druckverläufe am Gitterpunkt (0, 0) für die Stoffe Olivenöl und Motoröl

30 KAPITEL 4. TESTS 28 Als Erstes vergleichen wir die Flüssigkeiten Olivenöl mit Motoröl aus Tabelle 4.1 und erhalten die in Abbildung 4.6 dargestellten Druckverläufe. Wir können deutlich erkennen, dass der Druckverlauf von Motoröl, welches eine geringere kinematische Viskosität besitzt als Olivenöl, größere Amplituden aufweist als der von Olivenöl. Weiter lässt sich beobachten, dass das Fluid mit der höheren Viskosität, hier Olivenöl, schneller zur Ruhe kommt, nach circa 60 Zeitschritten, wohingegen Motoröl 80 Zeitschritte benötigt. Bei beiden Stoffen zeigt sich außerdem, dass der anfängliche Druck im betrachteten Mittelpunkt am Ende des Zeitintervalls nicht mehr vorliegt. Wir können hier einen Druckanstieg bei beiden Stoffen beobachten. Dies ist darauf zurückzuführen, dass sich das Volumen der Flüssigkeitspitzen des initialen Druckverlaufs über das gesamte Rechengebiet verteilt hat und somit nach dem Zusammenfall der Spitzen an jedem Gitterpunkt ein erhöhter Druck herrscht. Der unterschiedlich starke Druckanstieg lässt sich hier durch die verschiedenen Viskositäten erklären. Wir wollen nun das Fließverhalten der Flüssigkeiten Motoröl und Wasser untersuchen und erhalten die in Abbildung 4.7 dargestellten Druckverläufe: Motoroel Wasser Druck Zeitschritt Abbildung 4.7: Druckverläufe am Gitterpunkt (0, 0) für die Stoffe Motoröl und Wasser Wie schon bei dem zuvor betrachteten Testfall lassen sich auch hier sowohl deutlich größere Amplituden bei dem Stoff der kleineren Viskosität ausmachen, als auch eine längere Lebensdauer der Amplituden. Die Tatsache, dass nach dem Drucktiefpunkt bei etwa Schritten die Kurve von Motoröl eine scheinbar größere Amplitude besitzt als die von Wasser, hat die Ursache darin, dass das neue Nullniveau des Motoröls, das heißt, der sich einstellende Enddruck, oberhalb des von Wasser liegt. Somit ist der Druck zwar ab diesem Zeitschritt größer als der von Wasser, jedoch besitzt die Kurve für den Druckverlauf von Wasser weiterhin eine größere Amplitude. Auch hier lässt sich, wie eben erwähnt, ein unterschiedlich hoher Druck am Ende des Tests feststellen. Als letzten Testfall wollen wir Quecksilber mit Wasser vergleichen und erhalten die in Abbildung 4.8 dargestellten Druckverläufe. In dieser Konfiguration besitzen beide Stoffe sehr kleine Viskositäten (vgl. Tabelle 4.1) und es lassen sich nicht mehr so starke Amplitudenunterschiede erkennen wie bei den Testfällen zuvor. Dies ist darauf zurückzuführen, dass durch die sehr kleinen Viskositäten die Stoffe so flüssig geworden sind, dass sie sich für unser Modell kaum noch unterscheiden. Trotz der geringen Viskositäten verhalten sich die Stoffe passend zu den Tests zuvor. Wir erhalten wieder bei der Flüssigkeit der geringeren Viskosität einen geringern Druck am Ende unseres betrachteten Zeitintervalls und können

31 KAPITEL 4. TESTS 29 hier mehr Oszillationen erkennen Wasser Quecksilber Druck Zeitschritt Abbildung 4.8: Druckverläufe am Gitterpunkt (0, 0) für die Stoffe Wasser und Quecksilber Abschließend halten wir fest, dass die Werte der Viskosität starken Einfluss auf unsere Simulationen haben und sich diese der Realität entsprechend verhält. Wir erhalten bei Stoffen geringerer Viskosität, also Stoffe die weniger zähflüssig sind, größere Druckamplituden, mehr Oszilationen und eine längere Lebensdauer der entstanden Wellen als bei Stoffen höherer Viskosität. Diese erreichen zwar früher einen konstanten Druck, jedoch liegt er oberhalb des von Stoffen geringer Viskosität. Dies liegt daran, dass für unser Modell die kinematische Viskosität ν verwendet wird, also der Quotient aus dynamischer Viskosität η und der Dichte ρ. Es liegt uns also lediglich ein Wert für die Eigenschaften eines Stoffes vor. Somit haben wir, da der Parameter ρ nicht explizit in unserem Modell vorkommt, nicht die Möglichkeit zwischen leichten und schweren Fluiden, das heißt Fluide mit einer geringen Dichte beziehungsweise hoher Dichte, zu unterscheiden. Wir haben beispielsweise in dem Test zwischen Wasser und Quecksilver (vgl. Abbildung 4.8) einen erhöhten Enddruck bei Wasser, als bei Quecksilber. Dies ist jedoch aus den nachfolgenden Gründen physikalisch unrealistisch: Druck ist definiert über Kraft pro Fläche und da in unserem Fall die Kraft ausschließlich aus der eigenen Gewichtskraft des Fluids resultiert und nach dem zweiten Newtonschen Gesetz Kraft gleich Masse mal Beschleunigung ist, können wir also einen proportionalen Zusammenhang zwischen Druck und Masse erkennen, da sowohl die Fläche als auch die Beschleunigung, hier die Erdbeschleunigung, konstant sind. Weiter gilt für die Masse der Zusammenhang Masse gleich Dichte mal Volumen. Wir können also folgende drei Gesetze festhalten: P = F A, F = m g und m = ρ V Schließlich erhalten wir durch ineinander Einsetzen der drei Gesetze: P = ρ g V A Da die Erdbeschleunigung g, die Fläche A auf die die Druckkraft wirkt und unser Volumen V wie oben beschrieben als konstant angenommen werden können, ergibt sich so der proportionale Zusammenhang (4.5)

32 KAPITEL 4. TESTS 30 zwischen dem Druck P und der Dichte ρ. Hieraus folgt jedoch, dass bei Fluiden mit höherer Dichte auch ein höherer Druck am Ende unseres Tests festzustellen sein sollte. Dies ist, wie man anhand von Tabelle 4.1 und Abbildung 4.8 erkennen kann, bei uns nicht der Fall. Unser Modell ist also nicht geeignet, um das Verhalten verschiedener Stoffe genauer zu untersuchen, da hierfür die Anzahl der stoffabhängigen Parameter zu gering ist. Wir können lediglich Einfluss auf das Fließverhalten nehmen, was in unserem Fall auch ausreichend ist Zeitschrittweite In diesem Abschnitt wollen wir den Einfluss des Parameters t auf unsere Simulation untersuchen. Der Parameter t wird im Tracer unseres Lösers (vgl. Kapitel 3.1) benötigt und ist ein Maß für die Genauigkeit des Tracers. Hier nimmt t Einfluss darauf, wie weit wir in der Zeit zurückgreifen um neue Geschwindigkeiten zu berechnen. Das heißt, um so kleiner wir t wählen, um so genauer sollte unsere Lösung berechnet werden. Dies wollen wir nun anhand verschiedener Werte untersuchen. Dazu betrachten wir zuerst unsere allgemeine Form zur Wahl von t: t (h, v 0, a) = h v 0 a mit h als Schrittweite unseres Gitters, a als frei wählbaren Parameter und v 0 = als unsere maximal auftretende Geschwindigkeit. Mit dem Parameter a können wir nun t beliebig groß beziehungsweise klein machen. Als Ausgangskonfiguration für diesen Test wählen wir folgende Werte für die restlichen Parameter: (4.6) n = 257, h = 1, ν = , maxiter = 32 (4.7) 256 Während des Test wird nur a verändert, alle anderen Werte bleiben unverändert. Als Anfangsbedingung wählen wir den Testfall Hubbel mit einer Druckspitze an den Koordinaten (x 0, y 0 ) = (0.25, 0.25) (vgl. Abbildung 4.5 und Gleichung (4.4)). Wir betrachten folgende Wahl von a: a = 1 a = 100 a = 500 a = 1000 a = 2000 t Tabelle 4.2: Wertetabelle für den Parameter t Druck a=1 a=100 a=500 a=1000 a= Zeitschritt Abbildung 4.9: Druckverläufe am Gitterpunkt (0, 0) für verschiedene Werte von t = 1 (n 1) v 0 a

33 KAPITEL 4. TESTS 31 Um die Qualität unserer Lösung zu untersuchen, das heißt den Einfluss von t auf unsere Simulation, wollen wir den Druckverlauf im Mittelpunkt für verschiedene Werte von a über ein bestimmtes Zeitintervall analysieren. Wir erhalten die in Abbildung 4.9 dargestellten Druckverläufe. Wir können deutlich erkennen, dass für kleine Werte von a, also große Werte von t, kein wellenartiges Ausbreiten zu beobachten ist. In diesen Fällen liegt ein nahezu linearer, beziehungsweise ein unglatter Druckverlauf vor. Dies entspricht nicht der Realität und ist für unsere Simulation nicht geeignet. Es stellt sich nun die Frage, ob unser Modell bei diesen Werten von t stabil ist, wie es die Theorie (vgl. Kapitel 2.4) besagt. Hierzu betrachten wir als nächstes die Zweinorm des Druckvektors, um anhand dieser Werte Aussagen zur Stabilität unserer Implementierung treffen zu können. Wir erhalten über ein Zeitintervall betrachtet folgendes Diagramm: a=1 a= Norm Zeitschritt Abbildung 4.10: Normwerte des Druckvektors für verschiedene Werte von t über ein Zeitintervall Die Normwerte in beiden Testfällen zeigen monoton fallendes Verhalten und scheinen gegen zwei feste Werte zu konvergieren. Dies bedeutet, dass unser Verfahren zwar ungenau löst, aber immer noch stabil ist. Somit bestätigt sich in diesem Fall die Theorie, die besagt, dass unser Verfahren für alle Werte von t stabil ist. Betrachten wir nun die übrigen Druckverläufe aus Abbildung 4.9, so können wir anhand der ersten Zeitschritte feststellen, dass für immer kleiner werdende Werte von t ein immer realistisches Verhalten zu beobachten ist. Bei a = 500 besitzt die Druckkurve anfänglich noch einen recht kantigen, stückweise linearen Verlauf, wohingegen die Kurve von a = 2000 glatt wirkt und einer wellenartigen Ausbreitung sehr nahe kommt. Als Nächstes wollen wir untersuchen, wie sich die unterschiedlichen Werte von t auf die visuelle Darstellung auswirken und ob wir unsere Überlegungen, die wir anhand der Normverläufe getroffen haben, untermauern können. Dazu haben wir zu verschiedenen Zeitpunkten Momentaufnahmen gemacht und wollen diese nun näher untersuchen. Unsere Druckverläufe in Abbildung 4.9 zeigen, dass wir bei unterschiedlicher Wahl von t auch unterschiedliche Werte für den maximalen beziehungsweise minimalen Wert der Drücke erhalten. Daher passen wir die Farbwahl in unserer Simulation für jeden Testfall einzeln an, um eine möglichst genaue visuelle Darstellung zu erzielen. Dies erklärt die verschiedene Färbung zwischen den Testfällen. Wir erhalten so die folgenden Aufnahmen:

34 KAPITEL 4. TESTS 32 (a) Initiale Druckverteilung (b) Nach 30 Zeitschritten Abbildung 4.11: Druckverteilungen für a = 1 Wir können in Abbildung 4.11 für a = 1 deutlich erkennen, dass sich nach wenigen Schritte eine sehr unrealistische, nicht mehr kreisförmige Ausbreitung ergibt. Dies spiegelt also Erwartung nach der Analyse der Druckverläufe aus Abbildung 4.9 wider. (a) Initiale Druckverteilung (b) Nach 9 Zeitschritten Abbildung 4.12: Druckverteilungen für a = 100 Auch im Testfall aus Abbildung 4.12 erhalten wir das zu erwartende Ergebniss nach der Analyse des Druckes (vgl. Abbildung 4.9). Die Ausbreitung erfolgt nicht kreisförmig und auch die entstehenden Verwirbelungen entsprechen nicht der Realität, jedoch dem Druckverlauf aus Abbildung 4.9.

35 KAPITEL 4. TESTS 33 (a) Initiale Druckverteilung (b) Nach 8 Zeitschritten Abbildung 4.13: Druckverteilungen für a = 500 In Abbildung 4.13 erkennen wir erstmals eine realische Simulation unserer Strömung. Es entstehen kreisförmige Wellen um die Druckspitze und dies bestätigt erneut unsere anfänglichen Resultate der Analyse der Druckverläufe aus Abbildung 4.9. Ein ähnliches Verhalten zeigt sich bei den zwei verbleibenden Testfällen für a = 1000 und a = 2000, wir verzichten hier auf die Abbildungen. Wir können nun festhalten, dass durch Verändern des Parameters t großer Einfluss auf die Genauigkeit unserer Simulation genommen werden kann. So erhalten wir für große Werte von t ein sehr ungenaues und unrealistisches Simulationsmodell, wohingegen sich bei kleiner werdenden Werten eine realistische Simulationsumgebung ergibt. Als gute Wahl empfiehlt sich t erwünscht ist. h v 0 500, je nachdem welche Genauigkeit Symmetrietest In den bisherigen Parametertests in Kapitel für die kinematische Viskosität ν und Kapitel für den Zeitschritt t haben wir Parameter untersucht, welche lediglich Einfluss auf unsere visuelle Darstellung nehmen, beziehungsweise auf die Genauigkeit unserer Druck- und Geschwindigkeitsfelder. Wir wollen nun den Einfluss des Parameters maxiter, welcher die Anzahl der Jacobi-Schritte zum Lösen unserer Gleichungssysteme angibt, auf unsere Visualisierung analysieren. Der, wie in Kapitel 4.4 untersucht und anders als ν und t, großen Einfluss auf die Laufzeit unseres Lösers nimmt und daher für unser Ziel einer Echtzeit-Strömungssimulation von großer Bedeutung ist. Da unser Löser ausschließlich aus symmetrischen Operatoren, wie Divergenz, Gradient und Tracer besteht, bildet das Lösen der Gleichungssysteme mit dem Jacobi-Verfahren die einzige Möglichkeit, Unsymmetrien durch ungenaues Lösen zu erreichen. Wir wollen somit einen Wert für den Parameter maxiter finden, der uns Symmetrie verspricht und möglichst klein ist, um die Laufzeit unseres Lösers so gering wie möglich zu halten. Dazu betrachten wir erneut unseren Testfall Hubbel (vgl. Abbildung 4.5 und Gleichung (4.4)), dieses Mal jedoch mit vier Druckspitzen, welche wir symmetrisch in unserem Rechengebiet (vgl. Abbildung 3.2(b)) anordnen. Wir wählen hierzu a = 100, b = 1 sowie x 1 0 = 0.5, y1 0 = 0.5, x2 0 = 0.5, y0 2 = 0.5, x3 0 = 0.5, y3 0 = 0.5 und x4 0 = 0.5, y2 0 = 0.5 für unsere Druckspitzenmittelpunkte. Es

36 KAPITEL 4. TESTS 34 stellt sich nachfolgende initiale Druckverteilung ein (vgl. Abbildung 4.14): Abbildung 4.14: Initiale symmetrische Druckverteilung für den Symmetrietestfall mit vier Druckspitzen Wir erhalten eine Druckverteilung, die nicht nur symmetrisch zur x- und y-achse ist, sondern auch symmetrisch zur positiven wie negativen Winkelhalbierenden ist. Ausgehend von verschiedenen Werten für maxiter werden wir nun unsere visuelle Darstellung auf symmetrisches Verhalten untersuchen und unsymmetrisches Verhalten durch Kreise markieren. Die an den Kreisen angebrachten Ziffern sollen verdeutlichen, dass nur Kreise gleicher Nummer miteinander verglichen werden. (a) Druckverteilung nach 16 Zeitschritten (b) Druckverteilung nach 28 Zeitschritten Abbildung 4.15: Druckverteilungen für maxiter = 32 Betrachten wir zuerst unsere Simulation mit maxiter = 32 in Abbildung 4.15, so ergeben sich die dargestellten Druckverteilungen nach einigen Zeitschritten. Der Abbildung 4.15(a) ist zu entnehmen, dass schon sehr früh die Achsensymmetrie verloren geht, gekennzeichnet durch die roten Kreise um die Unsymmetrien. Jedoch verhält es sich anders bei der Symmetrie der positiven Winkelhalbierenden, da diese noch bleibt erhalten. Auch nach 28 Zeitschritten, siehe Abbildung 4.15(b), in der die Achsensymmetrie

37 KAPITEL 4. TESTS 35 nahzu vollständig verschwunden ist, bleibt die Symmetrie zur Winkelhalbierenden erkennbar, gekennzeichnet durch die schwarzen Kreise. Wir wollen überprüfen, ob sich dieses Verhalten auch in den anderen Testfällen wiederfindet. Betrachten wir dazu Abbildungen 4.16(a) und 4.16(b), welche verschiedene Druckverteilungen für maxiter = 48 darstellen: (a) Druckverteilung nach 14 Zeitschritten (b) Druckverteilung nach 28 Zeitschritten Abbildung 4.16: Druckverteilungen für maxiter = 48 Auch hier ist nach wenigen Zeitschritten die Achsensymmetrie verloren, wie in Abbildung 4.16(a) durch die roten Kreise markiert und wie schon in Testfall in Abbildung 4.15 bleibt die Symmetrie zur Diagonalen, welche von ( 1, 1) nach (1, 1) verläuft, auch nach 28 Zeitschritten erhalten. Somit bestätigt sich hier ebenfalls das anfänglich beobachtete Verhalten. Es stellt sich nun die Frage, ab welcher Anzahl der Jacobi-Schritte wir auch Achsensymmetrie erzielen. Um diese Frage zu klären, wollen wir nun weitere Werte von maxiter untersuchen. (a) Druckverteilung nach 16 Zeitschritten (b) Druckverteilung nach 42 Zeitschritten Abbildung 4.17: Druckverteilungen für maxiter = 52

38 KAPITEL 4. TESTS 36 Sei im folgenden Testfall maxiter = 52. Es ergeben sich die in Abbildung 4.17 dargestellten Druckverteilungen. Wir können deutlich erkennen, dass der gleiche Fall auftritt, wie in den bereits beschriebenen Testfällen in Abbildungen 4.15 und Selbst nach vielen Zeitschritten können wir die Symmetrie zur Diagonalen noch erkennen, wohingegen die Achsensymmetrie nur noch in Ansätzen zu erkennen ist. Somit sind wir gezwungen, den Parameter maxiter noch größer zu wählen, um auch Achsensymmetrie zu erreichen, falls dies überhaupt möglich ist. Betrachten wir dazu die Druckverteilungen für maxiter = 56 nach 38 Zeitschritten: Abbildung 4.18: Druckverteilung nach 38 Zeitschritten bei 56 Jacobi-Schritten Wir haben mit maxiter = 56 nun eine Anzahl an Jacobi-Schritten gefunden, mit welcher wir selbst nach vielen Zeitschritten, wie in Abbildung 4.18 dargestellt, nicht nur Symmetrie zur Diagonalen erreichen, sondern auch Achsensymmetrie. Die Frage ist nun jedoch, ob die Diagonalsymmetrie überhaupt durch den Parameter maxiter beeinflusst wird, da wir bei bereits 32 Jacobi-Schritten diese erreicht hatten. Um diese Frage zu klären, werden wir die Druckverteilung für einen kleinen Wert von maxiter analysieren. Es ergibt sich folgende Druckverteilung: (a) Initial (b) Nach 28 Zeitschritten Abbildung 4.19: Druckverteilungen für maxiter = 16

39 KAPITEL 4. TESTS 37 Wir können sehr gut erkennen, dass obwohl jegliche realistische Simulation verloren ist, erkennbar durch kein wellenartiges Ausbreiten, die Diagonalsymmetrie erhalten geblieben ist. Dies bedeutet, dass unser Parameter maxiter lediglich Einfluss auf die Achsensymmetrie hat und die Diagonalsymmetrie hier unbeeinflusst bleibt. Diese Erkenntnis ist sehr überraschend und zeigt uns, dass unsere Implementierung eine sehr gute, physikalisch richtige Simulation liefert, da auch in der Realität in diesem Testfall die Diagonalsymmetrie vorhanden wäre. Wir können also festhalten, dass wir ab einem maxiter Wert von 56 Achsensymmetrie erreichen und die Diagonalsymmetrie durch anderen Faktoren in unserer Implementierung verursacht wird. Es liegt nahe, dass hier der Grund darin liegt, dass die übrigen Funktionen in unserer Software symmetrisch aufgebaut sind. Zum Beispiel das Berechnen der Divergenz, des Gradienten oder die Nutzung des Tracers (vgl. Kapitel 3.1).

40 KAPITEL 4. TESTS Validierung der Interaktions-Komponente In diesem Kapitel wollen wir die Anwender-Interaktion im Hinblick auf ihre physikalische Korrektheit anhand der beiden Testfälle Steady und Hubbel prüfen. Um dies zu beurteilen, stützen wir uns nicht nur auf visuelle Kriterien, sondern auch auf numerische, insbesondere die Normen des Geschwindigkeitsund Druckfeldes Physikalisch korrekte Umsetzung Zunächst betrachten wir den Testfall Steady, bei dem wir das Fluid nur durch Interagieren anregen können, wie wir es in Kapitel 3.3 beschreiben. Für diesen speziellen Testfall gilt, dass das Fluid ohne Anwender-Interaktion ruht. Wir wählen Dirichlet-Nullrandbedingungen für die Geschwindigkeit und setzen sowohl das Geschwindigkeits- als auch das Druckfeld initial zu Null. In der Testkonfiguration verwenden wir die folgenden Parameter: die Gitterschrittweite h = durchzuführenden Iterationen im Jacobi-Löser maxiter = 32 und die Zeitschrittweite t =, die Viskosität ν = , die h 200v 0, wobei wir v 0 = wählen. Bei der Größe v 0 handelt es sich um den Wert, der im Testfall Driven Cavity die Geschwindigkeit an der oberen Gebietskante angibt (vgl. Abschnitt 4.1.2), den wir in allen Testfällen zur Bestimmung des Zeitschritts nutzen. (a) langsame Interaktion (b) schnelle Interaktion (c) abklingendes Geschwindigkeitsfeld (d) sehr schnelle, diagonale Interaktion Abbildung 4.20: Darstellung des Betrags des Geschwindigkeitsfeldes für verschiedene Interaktionen

41 KAPITEL 4. TESTS 39 Im Gegensatz zu den vorherigen Tests stellen wir hier den Betrag des Geschwindigkeitsfeldes in jedem Gitterpunkt dar. Die Resultate einiger Interaktionen finden sich in Abbildung Wir weichen von der Visualisierung in Kapitel und Abschnitt 4.2 ab, da wir so verwirrende Färbungen des Gitters vermeiden. Diese könnten auftreten, da blaue Färbungen nicht betragsmäßig kleine, sondern absolut kleine Geschwindigkeiten darstellen und wir somit die natürliche Wahrnehmung der Strömungsentwicklung nicht wiedergeben würden. Wir können feststellen, dass eine Anwender-Interaktion die visuell korrekten Resultate liefert: Die Geschwindigkeit ändert sich, wenn wir unseren Finger über den Bildschirm bewegen (4.20(a)), und sie wird größer, je schneller wir diese Bewegung ausführen, was wir an der Färbung der Gitterpunkte in Abbildung 4.20(b) erkennen können. Außerdem klingt die Geschwindigkeit ab, sobald wir mit der Interaktion aussetzen, was wir in Abbildung 4.20(c) sehen können. An diesem Verhalten können wir erkennen, dass die Interaktion, die vom Nutzer ausgeführt wird, visuell physikalisch korrekt von der Simulation verarbeitet wird, da wir ein solches Verhalten auch von realen Fluiden erwarten. Diese Beobachtungen wollen wir nun anhand der Normen des Geschwindigkeits- beziehungsweise Druckfeldes, deren Verläufe in Abbildung 4.21 dargestellt sind, verifizieren Norm Zeitschritt (a) Geschwindigkeitsverlauf Norm x Zeitschritt (b) Druckverlauf Abbildung 4.21: Verläufe des Geschwindigkeits- und Druckfeldes bei der oben beschriebenen Interaktion Zur Erstellung der Diagramme in Abbildung 4.21 führen wir zuerst mehrere langsame Bewegungen aus, die wir anschließend wieder abklingen lassen. Zuletzt führen wir schnelle Bewegungen, wie sie sich in

42 KAPITEL 4. TESTS 40 Abbildung 4.20(b) wiederfinden, aus und beenden das Programm, wenn das Rechengebiet wieder eine einheitliche Farbe angenommen hat. Aus dieser Vorgehensweise erklären sich die kleinen Ausschläge innerhalb der ersten 300 Zeitschritte in Abbildung Eine erste Beobachtung ist, dass die beiden Graphen in Abbildung 4.21 das Verhalten aufweisen, welches wir aufgrund der Abbildungen 4.20(a), 4.20(b) und 4.20(c) erwarten: Die Geschwindigkeit und der Druck des Fluids steigen mit zunehmender Geschwindigkeit der Interaktion an und klingen ab, sobald wir keine Kraft mehr aufprägen. Die beiden Kurven in Abbildung 4.21 verlaufen ähnlich, unterscheiden sich aber in zwei wesentlichen Aspekten: auf der einen Seite durch die Größe der angenommenen Werte und auf der anderen Seite durch ihr Abklingverhalten nach dem Hochpunkt in Zeitschritt 340. Bei der Geschwindigkeit (vgl. Abbildung 4.21(a)) stellt sich ein gleichmäßiges Abklingverhalten ein, wobei der Druck, wie wir in Abbildung 4.21(b) sehen können, ein sehr unregelmäßiges Verhalten aufweist. Dies lässt sich dadurch erklären, dass sich der Druck aus der Höhe des Fluids ergibt. Wenn wir uns vorstellen, dass sich das Fluid in einem würfelförmigen Becken befindet, so können wir der Wasseroberfläche eine gewisse Höhe zuordnen. Daraus resultiert der Druck, der in jedem Punkt der Oberfläche herrscht, da unterschiedliche Höhen einen unterschiedlichen Druck aufweisen. Dies folgt aus der Formel für den statischen Druck: Es gilt p = ρgh, wobei p den Druck des Fluids, ρ dessen Dichte, g die Erdbeschleunigung und h die Höhe des Fluids bezeichnet. Wenn wir eine externe Kraft auf die Oberfläche des Fluids aufprägen, die unserem Rechengebiet entspricht, so entstehen Wellen, die den vorherrschenden Druck beeinflussen, da sie lokal die Höhe des Fluids ändern. Deshalb ergibt sich bei gleichmäßig abklingender Geschwindigkeit ein wellenartig abklingender Druck. Die Geschwindigkeit verhält sich nicht wellenartig, da wir sie am Rand zu Null setzen und somit Reflexionen unterdrücken. Diese könnten ein ähnliches Verhalten wie bei der Druckkurve hervorrufen. Der Verlauf der Normen nach den kleinen Ausschlägen verhält sich dabei ähnlich wie der nach dem großen Ausschlag, welchen wir durch schnelle Interaktion hervorrufen. Insgesamt können wir festhalten, dass unsere App auch bei Interaktion ein physikalisch korrektes Verhalten des Fluids simuliert. Das Fluid ist ohne das Aufprägen einer Kraft durch Interaktion statisch, weist jedoch während beziehungsweise nach der Interaktion ein zu erwartendes Verhalten auf Überlagerung einer vorgegebenen Kraft mit einem TouchEvent Nachdem wir in Abschnitt die Anwender-Interaktion anhand des denkbar einfachsten Testfalls untersucht haben, wollen wir sie nun anhand eines etwas komplizierteren untersuchen x 10 3 Druck y Achse x Achse Abbildung 4.22: Druckspitze über dem Rechengebiet Dazu betrachten wir den Testfall aus Kapitel 4.2 mit der Konfiguration der Parameter, die wir in Ab-

43 KAPITEL 4. TESTS 41 schnitt verwendet haben. Zusätzlich geben wir eine Druckspitze in der unteren linken Ecke des Rechengebiets vor, wie es in Abbildung 4.22 dargestellt ist. Wir wollen im Folgenden untersuchen, ob und wie wir die Strömung, welche von der Druckspitze hervorgerufen wird, durch Interaktion stören können. Dazu betrachten wir die Interaktionen, die wir in Abbildung 4.23 sehen. Wir weisen darauf hin, dass wir erneut die Absolutgeschwindigkeiten auf dem Bildschirm anzeigen lassen und nicht den Druck, wie wir es bei der Untersuchung eines ähnlichen Testfalls in Kapitel 4.2 durchführen. (a) initiale Geschwindigkeitsverteilung (b) Störung von oben rechts (c) Störung von unten rechts Abbildung 4.23: Geschwindigkeitsverteilung für verschiedene Interaktionen Neben der initialen Geschwindigkeitsverteilung in Abbildung 4.23(a) können wir in den Abbildungen 4.23(b) und 4.23(c) eine Störung der Strömung duch Anwender-Interaktion ausmachen. Wir beobachten, dass die Geschwindigkeit an den Stellen, an der wir die kreisförmige Ausbreitung der Druckspitze durch das Aufprägen einer externen Kraft stören, sehr klein ist. Dies ist physikalisch korrekt, da wir von außen in den Kreis eindringen und somit der Strömung entgegenwirken. Die Strömungen in der Eintrittsstelle heben sich nahezu auf und es liegt eine sehr geringe Geschwindigkeit vor. In Abbildung 4.23(c) können wir ein Ausbeulen des Strömungskreises erkennen, die dadurch entsteht, dass wir eine Bewegung durch den Kreis von unten rechts nach oben links durchführen. Am oberen linken Rand des Strömungskreises wird die Geschwindigkeit des Fluids durch das Aufprägen der Kraft erhöht. Auch dies entspricht einem physikalisch korrekten Verhalten. Zuletzt wollen wir noch den Einfluss der Interaktion auf das Druckfeld untersuchen. Dazu betrachten wir Abbildung 4.24, in der wir den Druckverlauf im mittleren Gitterpunkt einmal mit und ein-

44 KAPITEL 4. TESTS 42 mal ohne Interaktion darstellen. Im Gegensatz zu den Ausführungen in Abschnitt stellen wir in Abbildung 4.24 nicht die Norm des Druckfeldes, also den Druck in allen Gitterpunkten, sondern den tatsächlichen Wert in einem Gitterpunkt dar x 10 5 mit Interaktion ohne Interaktion Druck Zeitschritt Abbildung 4.24: Druckverlauf im mittleren Gitterpunkt Wir beobachten für den Druck ohne Interaktion einen Verlauf, den wir nach den Untersuchungen in Kapitel 4.2 erwarten. Für den anderen Druckverlauf registrieren wir einen Druckabfall, während wir die Interaktion ausführen, die wir in Abbildung 4.23(b) sehen. Durch das Aufprägen der Kraft reduzieren wir den Druck in dem Punkt, an dem die Kraft angreift. Dies ist ein Verhalten, welches unsere Erwartungen, die wir anhand der Ausführungen in Abschnitt getroffen haben, bestätigt, da sich durch das Kraftaufprägen die Höhe der Fluidoberfläche ändert. Ab dem 15. Zeitschritt weisen beide Kurven in Abbildung 4.24 ein ähnliches Verhalten auf, was darauf hindeutet, dass die Störung der Strömung mit der Zeit wieder ausgeglichen wird. Dieses Phänomen lässt sich auch bei realen Fluiden vermuten, da die Druckspitze zum Zeitpunkt der Störung der Strömung durch Interaktion noch nicht vollständig zusammengefallen ist und sich somit das ungestörte Verhalten wieder einstellen kann. Wir meinen hier, dass ein Teil der Druckspitze immer noch vorhanden ist und die Strömung des Fluids beeinflusst. Dies geschieht nicht in dem Maße wie zu Beginn des Testfalls, aber die Wirkung bleibt dennoch die gleiche. Anhand dieses Testfalls können wir festhalten, dass die Interaktion eines Anwenders physikalisch korrekt in die Simulation einbezogen wird. Hierbei haben wir eine externe, vom Anwender aufgeprägte, Kraft mit einer vorgegebenen überlagert, was in Abschnitt nicht der Fall ist und trotzdem vergleichbare Erkenntnisse liefert. Wir können somit davon ausgehen, dass die Simulation physikalisch korrekte Ergebnisse bezüglich einer Anwender-Interaktion erzielt.

45 KAPITEL 4. TESTS Zeitmessungen und Tuning In diesem Abschnitt wollen wir uns mit den genauen Laufzeiten unserer Simulationsumgebung auseinandersetzen, um darauf aufbauend Verbesserungsmöglichkeiten im Hinblick auf eine Beurteilung bezüglich des Erreichens von Echtzeit-Simulation herauszuarbeiten. Die Zeitmessungen führen wir auf einem Tablet-Computer aus, der über ein Tegra TM -2 System-on-a-Chip mit einer ARM Cortex-A9- CPU, wobei es sich um einen 1.0GHz Dual-Core-Prozessor handelt, und eine speziell für minimalen Energieverbrauch angepasste NVIDIA R GeForce GPU verfügt. Außerdem ist der Tablet-Computer mit einem Hauptspeicher von 1GB und einem Datenspeicher von 16GB ausgestattet (vgl. [Asus]). Die in der Praxis erreichbare Rechenleistung beträgt 0.81 GFlops und die Speicherbandbreite GB/s, gemessen mit [RGBenchMM] für die beiden Standardbenchmarks Multiplikation zweier dicht besetzter Matrizen und STREAM (Updates großer Vektoren wie zum Beispiel das Kopieren eines Vektors oder komponentenweise Addition zweier Vektoren). Der L1-Cache ist je 32kB bezüglich Instruktionen beziehungsweise Daten pro Kern und der L2-Cache, der zwischen den beiden Kernen geteilt ist, 1MB groß (vgl. [NVIDIA]). Zur Analyse der Laufzeiten betrachten wir in diesem Unterkapitel den schon oben angeführten Testfall Driven Cavity, welchen wir auch in Abschnitt verwenden. Wir variieren dabei die Schrittweite des Gitters, indem wir h { 1 } wählen, und untersuchen den Einfluss der unterschiedlichen 64, 1 128, Komponenten auf die Gesamtlaufzeit. Weiterhin betrachten wir für die feste Schrittweite h = die Laufzeitänderungen unterschiedlicher Anzahlen von Iterationen im Jacobi-Löser (vgl. Erläuterungen in Abschnitt 3.1). Dazu wählen wir die verschiedenen Werte von maxiter {16, 32, 64, 128}. Die anderen in unserer Software variablen Größen, also die Viskosität ν, die Zeitschrittweite t und die Geschwindigkeit v 0, die an der oberen Kante in positive x-richtung permanent angesetzt wird, lassen wir unverändert. Tests zur Wahl dieser Parameter, mit Ausnahme der Geschwindigkeit v 0, finden sich in Abschnitt 4.2. Wir untersuchen also die Laufzeiten des kompletten Lösers, seiner Bestandteile, die im Wesentlichen den in Algorithmus aufgeführten Schritten entsprechen, sowie die zur Visualisierung zählenden Funktionen, die wir sowohl als Ganzes als auch in kleinschrittiger Gliederung betrachten. Zusätzlich beurteilen wir noch den Einfluss der Interaktivität, die einen sehr wichtigen Teil unserer Software darstellt. Wir weisen darauf hin, dass wir in der Regel gerundete Durchschnittszeiten angeben, die sich aus den ersten 50 Zeitschritten ergeben. Außerdem müssen wir zur Einordnung der Zeiten berücksichtigen, dass wir die Berechnungen mit doppelter Genauigkeit durchführen. Funktionen, die nur einmal pro Programmaufruf ausgeführt werden, wie zum Beispiel der Konstruktor der Render-Klasse, berücksichtigen wir in den Zeitmessungen nicht, da sie keinen dauerhaften Einfluss auf die Laufzeit der Software haben Analyse des Lösers Zunächst wollen wir uns mit der Analyse des Lösers beschäftigen. Dieser besteht insgesamt aus sechs Vektorupdates, drei Anwendungen des Jacobi-Lösers sowie je einer Anwendung des Tracers, der Divergenz und des Gradienten, was sich wie folgt in unserem Löser wiederfindet: Das Aufprägen der Kraft erfolgt lediglich durch ein Vektorupdate, die Laufzeit im Advektionsschritt wird durch das Ausführen des Tracers dominiert und im Prozess der Diffusion konzentrieren wir uns auf die Laufzeit einer Anwendung des Jacobi-Lösers, obwohl wir diesen zwar im Diffusionsschritt, wie in Kapitel 3.1 beschrieben, zweimal und bei der Projektion erneut verwenden. Dabei handelt es sich allerdings um die selbe Implementierung, nur mit anderen Zahlenwerten. Im Projektionsschritt beschränken wir uns auf das Messen der Laufzeit zur Bestimmung des Druckgradienten und der Divergenz des Geschwindigkeitsfeldes (vgl. Abschnitt 2). Vektorupdates, die zusätzlich auftreten, wie zum Beispiel im Diffusionsschritt, sind für unsere Betrachtung nicht weiter relevant, da sie bezüglich ihrer Laufzeit durch das Kraftaufprägen repräsentiert werden. Die Tabelle 4.3 gibt die Laufzeit der gesamten Berechnung sowie die ihrer einzelnen Bestandteile für

46 KAPITEL 4. TESTS 44 unterschiedliche Schrittweiten h in jedem Zeitschritt an. h Gesamt Vektorupdate Tracer Jacobi Gradient und Divergenz Tabelle 4.3: Laufzeiten der einzelnen Löser-Komponenten in Sekunden für unterschiedliche Schrittweiten Alle Angaben gelten dabei für eine feste Anzahl von maxiter = 32 Iterationen im Jacobi-Löser. Im Gegensatz zu den in Abbildung 4.25 angebenen Anteilen handelt es sich bei den Werten in Tabelle 4.3 nicht um gewichtete Werte. Wir können direkt festhalten, dass wir in diesem Status der Implementierung für kein h bei 25 fps (Frames per Second) Echtzeit-Simulation erreichen. Der ersten Spalte von Tabelle 4.3 können wir entnehmen, dass bei einer Halbierung der Schrittweite die Laufzeit des Lösers um einen Faktor vier zunimmt. Eine Erklärung dafür ist, dass die meisten der im Quellcode verwendeten Arrays die Größe 2N = 2 ( 1 h + 1) 2 haben, also N 1 für kleine Schrittweiten h gilt. Das heißt, h 2 dass bei Halbierung der Schrittweite die zu berechnenden Vektoren um einen Faktor vier größer werden. Natürlich sind dann entsprechend mehr Rechnungen im Löser durchzuführen. Wie wir aus den übrigen Spalten erkennen können, schlägt sich dieser Faktor auf jede einzelne Komponente des Lösers nieder, was bedeutet, dass jeder Teil auch gleichmäßig von einer Schrittweitenhalbierung betroffen ist. Nun wollen wir uns den einzelnen Bestandteilen des Lösers widmen und dazu die in Tabelle 4.3 angeführten Laufzeiten genauer analysieren. Um die Anteile der einzelnen Komponenten bezüglich der Gesamtlaufzeit besser einschätzen zu können, stellen wir die Laufzeiten zusätzlich in einem Kreisdiagramm (vgl. Abbildung 4.25) dar. Dabei ist zu beachten, dass für alle Schrittweiten die Anteile der Laufzeiten der einzelnen Komponenten unverändert bleiben, was die obige These der gleichmäßigen Auswirkung der Schrittweite auf alle Komponenten des Lösers untermauert. Außerdem haben wir die Zeiten von Operationen, die mehr als einmal verwendet werden, entsprechend gewichtet, also die Zeiten für Vektorupdates mit den Faktor sechs, die für den Jacobi-Löser mit dem Faktor drei und alle anderen Zeiten einfach. 11% 5% 2% Grad./Div. Vektorupdates Tracer Jacobi 82% Abbildung 4.25: Laufzeitenanteile für beliebige Schrittweiten h { 1 Iterationen im Jacobi-Löser 64, 1 128, } für maxiter= 32 Es wird deutlich, dass der Jacobi-Löser mit Abstand den größten Anteil der Gesamtlaufzeit der Berechnungen in Anspruch nimmt. Wie in Kapitel 3.1 bereits beschrieben, verwenden wir eine Stencil-Methode,

47 KAPITEL 4. TESTS 45 um den Jacobi-Löser zu realisieren. Diese ist offensichtlich schon sehr effizient, da wir bereits das Aufstellen eines kompletten Gleichungssystems sparen und nur jeden inneren Gitterpunkt durch eine relativ simple Berechnungsvorschrift aktualisieren. Wie wir uns anhand des zur Diskretisierung verwendeten Fünf-Punkte-Sterns leicht überlegen können, kommt es dabei zu Speicherzugriffen auf nicht kontinuierlich abgelegte Daten, was einen langsameren Zugriff und damit eine Verzögerung der Berechnung zur Folge hat. Das Umgehen dieses Phänomens ist nicht trivial, eine Möglichkeit dazu findet sich jedoch unter anderem bei [Strzodka]. Dort wird ein Verfahren vorgestellt, das das Anwenden der Stencil-Methode im Jacobi-Löser bezüglich der Laufzeit verbessert. Dies geschieht dadurch, dass temporäre Datenlokalität über mehrere Iterationen erhöht wird. Dazu werden die Arrays der verwendeten Daten gekachelt, um die Berechnung des Stencils auf diesen Kacheln im Cache durchführen zu können. Dieses Vorgehen ist sehr effizient, da weniger Zugriffe auf den Datenspeicher erfolgen und der verhältnismäßig kleine Cache im Prozessor besser ausgenutzt wird als bei der von uns verwendeten naiven Implementierung. Eine zusätzliche Verbesserung der Laufzeit können wir erzielen, wenn wir die Kachelung der Datenarrays auf die zur Verfügung stehende Cachegröße anpassen. Die Aktualisierung der Gitterpunkte erfolgt in beiden Fällen über mehrere for-schleifen, was die Idee nahelegt, diesen Vorgang zu parallelisieren. Auf dem von uns verwendetem Gerät stehen zwei Kerne zur Verfügung, wobei das Betriebssystem bereits einen für die Visualisierung und den anderen für Berechnungen und Ähnliches verwendet. Somit können wir, wenn überhaupt, nur eine Verbesserung der Laufzeiten um einen Faktor zwei erreichen. Da wir auch in allen anderen Löser-Komponenten solche for-schleifen verwenden, wird der Effekt der Reduktion der Laufzeit durch Parallelisierung verstärkt, die Dominanz des Jacobi-Lösers jedoch nicht beeinflusst. Insgesamt lässt sich also als Konzept zur Laufzeitverbesserung konkret für den Jacobi-Löser und auch im Allgemeinen das Parallelisieren der for- Schleifen anführen. Die Vektorupdates und die Berechnung von Gradient und Divergenz im Diffusionsschritt, welche wir im Wesentlichen auch als Vektorupdate auffassen können, bestehen ebenfalls hauptsächlich aus for- Schleifen, was daher erneut eine Parallelisierung nahelegt. Desweiteren haben wir die Möglichkeit die Schleifen auszurollen, was zu wesentlich mehr Quellcode führt. Wie sehr sich dieses Vorgehen etwa im Hinblick auf die Laufzeit auszahlen würde, bleibt zu untersuchen, jedoch ist davon auszugehen, dass es gegenüber der Parallelisierung den geringeren Effekt hat. Beim Aufprägen der Kraft verändern wir, wie in Abschnitt 3.3 beschrieben, nur die Komponente des Kraftvektors, die zu dem Knotenpunkt gehört, den der Anwender auf dem Bildschirm berührt. Am Ende des Lösers füllen wir dennoch den kompletten Kraftvektor mit Nullen. Diese Aktualisierung lässt sich in der Form reduzieren, als dass wir nur den zuvor veränderten Eintrag auf Null setzen. Wenn wir uns jedoch die Zeiten in Tabelle 4.3 anschauen, so stellen wir fest, dass der hier durch erzielte Gewinn an Laufzeit eher unbedeutsam ist. Abschließend wollen wir uns mit der Laufzeit des Tracers beschäftigen, die immerhin den zweitgrößten, wenn auch den im Vergleich zum Jacobi-Löser deutlich kleineren Teil der Gesamtdauer des Lösers ausmacht. Hier treten neben for-schleifen vor allem if-abfragen auf, welche jeweils zwei Bedingungen überprüfen. Diese Abfragen sind verhältnismäßig teuer und beanspruchen deshalb einen relativ großen Teil der Laufzeit des Tracers. Hier gewährleisten wir, dass wir ein Fluidpartikel, wie in Abschnitt 2.4 beziehungsweise 3.1 beschrieben, nicht so lange zurückverfolgen, bis es an einem Punkt außerhalb des Rechengebiets angekommen ist. Falls diese Gefahr besteht, so wählen wir den entsprechenden Randpunkt als Endpunkt des Pfades, durch den der Stromfaden verläuft. Es ist also klar, dass diese if-abfragen absolut nötig sind und nicht weggelassen werden können. Eine Verbesserungsmöglichkeit bietet wie oben das Parallelisieren der for-schleifen. Nachdem wir uns zuvor mit der Variation der Schrittweite h beschäftigt haben, wollen wir nun die rein laufzeitorientierten Auswirkungen von unterschiedlichen Iterationsanzahlen im Jacobi-Löser betrachten. Im Folgenden werden wir also die Laufzeiten des Jacobi-Lösers für verschiedene Werte von

48 KAPITEL 4. TESTS 46 maxiter {16, 32, 64, 128} analysieren. Wir untersuchen nur die Laufzeit des Jacobi-Lösers und vernachlässigen die übrigen Komponenten, weil diese nicht von maxiter beeinflusst werden können und deshalb keine Laufzeitvariationen festzustellen sind. Als feste Schrittweite wählen wir h = 1 128, um die Laufzeitveränderungen unabhängig von der Gitterweite beurteilen zu können. In der folgenden Tabelle 4.4 finden sich die entsprechenden Laufzeiten. maxiter Laufzeit Tabelle 4.4: Laufzeiten des Jacobi-Lösers in Sekunden für verschiedene Werte von maxiter Wir können feststellen, dass das zu erwartende Ergebnis eintritt: Bei einer Verdopplung der Anzahl durchzuführender Iterationen benötigt der Jacobi-Löser doppelt so viel Zeit wie zuvor. Wir müssen also besonders darauf achten, wie wir maxiter wählen, da wir dadurch viel Zeit einsparen können, zumal diese Komponente des Lösers, wie oben gesehen, den mit Abstand größten Teil der Laufzeit ausmacht (vgl. Abbildung 4.25). Es bietet sich also an, die Anzahl der Iterationen im Jacobi-Löser problemabhängig zu wählen, um nicht unnötig lange Laufzeiten zu erhalten. Wir verweisen hier auf Abschnitt 4.2.3, wo wir eine Untersuchung der visuellen Auswirkungen der Wahl von maxiter durchführen. Anhand der Ergebnisse, welche dort erzielt werden, können wir die Wahl der maximalen Iterationszahl vereinfachen Analyse der Visualisierungs-Komponente Nachdem wir uns im vorherigen Abschnitt mit den Laufzeiten des Lösers und seiner einzelnen Bestandteile beschäftigt haben, wollen wir eine ähnliche Analyse auch für die Visualisierungs-Komponente durchführen. Diese werden in der Funktion drawgrid zusammengefasst, die im Wesentlichen aus zwei Elementen besteht. Zunächst weisen wir jedem Knotenpunkt im Gitter eine Farbe zu, die den Wert einer bestimmten Größe in diesem Gitterpunkt repräsentiert. Bei uns werden je nach Testfall Geschwindigkeiten oder Drücke dargestellt. Dann lassen wir das Gitter mittels der Funktion drawarrays auf den Bildschirm zeichnen, wobei die Farbgebung zwischen zwei Gitterpunkten durch lineare Interpolation der jeweiligen Farben erfolgt, was von einer Standardfunktion von OpenGL ES 2.0 unterstützt wird. Die Gesamtlaufzeit der Visualisierung sowie die Laufzeiten der einzelnen Komponenten für verschiedene Schrittweiten h werden in Tabelle 4.5 zusammengefasst. h Gesamt Farbe setzen drawarrays Tabelle 4.5: Laufzeiten der einzelnen Visualisierungs-Komponenten in Sekunden für unterschiedliche Schrittweiten Ähnlich wie im vorherigen Abschnitt wollen wir analysieren, welche Komponente für verschiedene Gitterweiten wie stark bezüglich ihrer Laufzeit beeinflusst wird. Um die Entwicklung der Laufzeiten besser beurteilen zu können, stellen wir die Anteile der beiden Komponenten erneut in einem Kreisdiagramm (vgl. Abbildung 4.26) dar.

49 KAPITEL 4. TESTS 47 (a) Anteile für h = 1 64 (b) Anteile für h = Farbe setzen drawarrays 45% 55% (c) Anteile für h = Abbildung 4.26: Anteile der Laufzeiten der einzelnen Visualisierungs-Komponenten an der Gesamtlaufzeit für unterschiedliche Schrittweiten h Wir erkennen deutlich, dass sich mit kleiner werdender Schrittweite die Anteile der beiden Komponenten annähern. Die Zeiten selbst wachsen trotzdem weiter an, wie Tabelle 4.5 zu entnehmen ist. Wir können also festhalten, dass das Setzen der Farben stärker von einer Schrittweitenvariation beeinflusst wird als das Zeichnen selbst. Der Grund hierfür ist, dass das OpenGL ES-Rendern, also das Zeichnen eines Frames, in den Tegra-Chips, die in unserem Gerät verwendet werden, in der dafür besser geeigneten GPU-Komponente durchgeführt wird und somit hardwarebeschleunigt im Vergleich zu der allgemeinen Berechnung auf der CPU-Komponente ist. Die Farben setzen wir mittels for-schleifen, das Zeichnen wird hingegen von einer Standardfunktion von OpenGL ES 2.0 ausgeführt. Wie im Implementierungskapitel 3.2 beschrieben, entsteht unser Simulationsgebiet auf dem Bildschirm durch Zeichnen vieler kleiner Quadrate, welche sich wiederum aus zwei Dreiecken ergeben. Ein Gitterpunkt wird dabei unter Umständen bis zu sechsmal gezeichnet, obwohl wir ihn zum Aufbau des Gitters nur einmal benötigen. Dies können wir den Nummern an den Knoten in Abbildung 3.3 entnehmen. Statt vorgegebenen N = ( 1 h + 1) 2 = n 2 Gitterpunkten lassen wir effektiv 2(n 1)(n 1)3 Gitterpunkte zeichnen, da wir für die Darstellung von n 2 Gitterpunkten (n 1) 2 Quadrate benötigen. Die Größe h gibt dabei die Schrittweite im Gitter und n die Anzahl der Gitterpunkte in einer Zeile beziehungsweise Spalte an. Die Zeichenroutine bietet somit ebenfalls Ansatzpunkte, um eine Laufzeitverbesserung zu erreichen, da wir deutlich mehr Punkte als nötig zeichnen lassen. Ähnliche Konsequenzen ergeben sich für den Array, in dem wir die Farben der Gitterpunkte zum Zeichnen speichern. Der Farbarray, der alle Gitterpunkte berücksichtigt, hat die Länge 4(n 1)(n 1)6 = 24, h 2 da wir für jeden Gitterpunkt die in Abschnitt 3.2 genannten vier Werte setzen müssen: den Rot-, Blau-, Grün- und Transparenzwert. Bei einer Halbierung der Gitterschrittweite erhalten wir also einen vier mal so großen Farbarray. Dieser Faktor spiegelt sich jedoch nicht in den Zeiten aus Tabelle 4.5 wider. Dies lässt sich erklären, wenn wir uns den Quellcode 3.2 genauer anschauen. In der Funktion colourset treten sehr viele if-abfragen auf, durch die wir den eingegebenen Wert in eine geeignete Farbskala einordnen. Der Faktor, um den die verschiedenen Farbarrays bei Halbierung der Gitterschrittweite größer

50 KAPITEL 4. TESTS 48 werden, muss sich nicht zwangsläufig auf die Laufzeit niederschlagen, da wir nicht nur einfache for- Schleifen ausführen, sondern auch if-abfragen, die nicht schrittweitenabhängig sind. Dadurch geht die Übertragung des Faktors, der aus der Schrittweitenhalbierung resultiert, auf die Laufzeit verloren. Außerdem kann es zu Sprüngen beim Speicherzugriff kommen, wodurch sich kein optimales Cacheverhalten einstellt. Die Laufzeit der Visualisierungs-Komponente wird also bei einer Halbierung der Schrittweite deutlich höher, jedoch nicht in dem Maße, wie man es anhand der zunehmenden Größe der Vektoren erwarten würde. Statt die Simulation, wie in Kapitel 3.2 beschrieben, über eine Heat Map zu realisieren, bei der wir jedem Gitterpunkt eine Farbe zuordnen, können wir auch einen alternativen Zugang wählen, den wir im Folgenden beschreiben und analysieren wollen. Bisher sind wir immer von einem zweidimensionalen Rechengebiet ausgegangen, das wir auf dem Bildschirm darstellen lassen. Natürlich bietet OpenGL ES 2.0 auch die Möglichkeit, dreidimensionale Objekte darzustellen. Genau diese Eigenschaft werden wir uns nun zu Nutze machen. Dabei werden die zuvor unerlässlichen Farbarrays irrelevant, dafür weisen wir jedoch dem Positionsarray, der bisher nur ein einziges Mal im Konstruktor aufgerufen wurde, eine entscheidendere Rolle zu. Wie weiter oben bereits angeführt, benötigen wir für die Ausführung der drawarrays-methode als Eingabe sowohl einen Positionsarray als auch einen Farbarray. Letzteren füllen wir im Konstruktor in jedem Eintrag mit dem gleichen Werten, was heißt, dass wir unser gesamtes Gebiet einheitlich färben. Den Positionsarray verändern wir nun in jedem Zeitschritt in der Weise, als dass wir in die z-komponente, die wir bisher immer als Null gesetzt haben, einen skalierten Wert des Drucks an dem jeweiligen Gitterpunkt eintragen. Dadurch lösen wir uns von unserem zweidimensionalen Gebiet und erhalten ein in gewisser Weise gewelltes Gebiet. Durch die Skalierung des Drucks können wir beeinflussen, in welcher Größenordnung sich die Amplituden der Wellen befinden. Die Blickrichtung des Anwenders ändern wir dabei nicht, wir betrachten das Gebiet also immer noch von oben. Die Idee ist es, dass wir uns nun einer Option von OpenGL ES 2.0, eine Lichtquelle zu simulieren, bedienen, die wir bisher noch nicht verwendet haben. Setzen wir also eine solche Lichtquelle ein, so entstehen aufgrund des gewellten Gebiets Schattierungen, welche abhängig von der Höhe des jeweiligen Gitterpunktes für unterschiedlich helle Färbungen sorgen. Zur Veranschaulichung betrachten wir die Umsetzung der oben beschriebenen Idee mittels Paraview 1 anhand des in diesem Kapitel verwendeten Testfalls Driven Cavity, den wir in Kapitel beschreiben, mit Gitterschrittweite h = Als Testkonfiguration haben wir außerdem 1 v 0 = , maxiter= 50, ν = und t = 500(n 1)v 0 gewählt, wobei durch die festgelegte Gitterschrittweite h für die Anzahl der Knoten pro Zeile beziehungsweise Spalte n = 33 gilt. (a) Ansicht von oben (b) Ansicht von schräg oben nach zehn Zeit- Abbildung 4.27: Druckfeld über dem dreidimensionalen Rechengebiet für h = 1 schritten 32 1 Wie am Ende von Abschnitt erwähnt, verzichten wir auf eine Implementierung dieses Ansatzes in unserer Software und bedienen uns deshalb einer geeigneten Visualisierungsumgebung.

51 KAPITEL 4. TESTS 49 (a) Ansicht von oben nach 30 Zeitschritten (b) Ansicht von oben nach 50 Zeitschritten Abbildung 4.28: Druckfeld über dem dreidimensionalen Rechengebiet für h = 1 32 nach verschiedenen Zeitschritten Die Entwicklung des Fluids über mehrere Zeitschritte sehen wir in Abbildung 4.27 und 4.28, wobei wir den Druck mit dem Faktor 10 4 skaliert haben, um eine ausreichende visuelle Bewertung durchführen zu können. Anhand der beiden Abbildungen können wir feststellen, dass wir trotz einheitlicher Färbung des Rechengebiets das Fluidverhalten beobachten können, was in den Abbildungen 4.27(a), 4.28(a) und 4.28(b) dargestellt wird. In Abbildung 4.27(b) sehen wir außerdem, dass es sich tatsächlich um ein gewelltes Gebiet handelt. Nun wollen wir uns überlegen, wie wir den zuvor dargestellten Ansatz zur Visualisierung der Ergebnisse des Lösers umsetzen. Für Details bezüglich der Mathematik von Lichtsimulation und der Implementierung selbiger verweisen wir auf [Learn OpenGL ES] und beschreiben hier nur die in unserem Quellcode wesentlichen Änderungen. Wie oben bereits erwähnt, müssen wir im Positionsarray für jeden Gitterpunkt die z-komponente verändern. Da wir in dem Positionsarray auch zuvor drei Einträge pro Gitterpunkt vorgesehen haben, müssen wir dessen Größe nicht variieren. Aus diesem Grund benötigen wir keine gravierenden Umstrukturierungen im Quellcode, sondern können das Setzen der z-komponente durch eine einfache for-schleife realisieren. Dies müssen wir jetzt in die drawgrid-methode einbauen, in der wir den Quellcode 3.2 und die nachfolgenden Schleifen durch die Schleifen zum Ändern des Positionsvektors ersetzen. Dadurch reduzieren wir den Aufwand bereits erheblich, da wir die zahlreichen Aufrufe der Funktion colourset vermeiden. Zusätzlich zu den for-schleifen benötigen wir den Normalenvektor in jedem Gitterpunkt, wie es in [Learn OpenGL ES] beschrieben wird, um OpenGL ES 2.0 zur Visualisierung einsetzen zu können. Dies können wir jedoch relativ einfach realisieren: Zunächst berechnen wir die Normalenvektoren eines jeden Dreiecks in unserem Gebiet, indem wir das Kreuzprodukt von zwei Schenkeln des Dreiecks bilden. Dies ist möglich, da die Koordinaten aller Punkte bekannt sind. Den Normalenvektor eines Gitterpunktes bestimmen wir anschießend als Mittelung der Normalenvektoren der benachbarten Dreiecke. Bei Randpunkten verfahren wir analog, nur dass weniger Nachbardreiecke vorliegen als im Innern des Gebiets. Diese Berechnungen können wir auch über for- Schleifen durchführen, wobei wir die Bestimmung der Normalen eines jeden Punktes als eigenständige Funktion auslagern können. Durch Verwenden dieser alternativen Variante können wir die komplette Visualisierungs-Komponente unserer Simulationssoftware optimieren, da wir pro Gitterpunkt einen Funktionenaufruf sparen und stattdessen nur einen Eintrag im Positionsarray ändern müssen. Wir verzichten allerdings auf eine Implementierung dieser Visualisierungsmöglichkeit, da sie mit einem relativ großen Aufwand verbunden ist. Zwar ist der visuelle Gewinn enorm, da wir durch die Schattierungen wesentlich glattere Farbübergänge erzielen, allerdings sind die Auswirkungen auf die Gesamtlaufzeit der Software viel zu gering.