Numerische Betrachtungen und Realisierung mit DUNE fileSplitting-Methode Finite-Element-Methode...

Splitting-Methode Finite-Element-Methode Finite-Volumen-Methode

Numerische Betrachtungen und Realisierung mitDUNE

Daniel Seibel

Universitat des Saarlandes

3. Januar 2018

Daniel Seibel Universitat des Saarlandes

Numerische Betrachtungen und Realisierung mit DUNE


Splitting-Methode

Finite-Element-MethodeTheoretische EinfuhrungImplementierung mit DUNE

Finite-Volumen-MethodeTheoretische EinfuhrungImplementierung mit DUNE




Beispiel Vlassov-Poisson Gleichung

Die nichtrelativistische Vlassov-Poisson Gleichung

∂f(t, x, v)

∂t+ v · ∇xf(t, x, v)− E(t, x) · ∇vf(t, x, v) = 0,

−∆xφ(t, x) = ρ(t, x) = 1−∫R3

f(t, x, v) dv,

E(t, x) = −∇xφ(t, x),

wird in zwei Transportgleichungen “aufgesplittet”.




Fur festes v betrachte man

∂f

∂t+ v · ∇xf = 0,

und fur festes x∂f

∂t+ E · ∇vf = 0.

Beide Transportgleichungen sind linear mit konstantenKoeffizienten.




Godunov-Splitting

Die beiden Transportgleichungen werden pro Zeitschrittabwechselnd gelost.

I Lose zuerst die erste Gleichung fur alle v.

I Lose anschließend mit aktualisierten Anfangsbedingungen diezweite Gleichung fur alle x.

Dabei muss im Vorfeld E aus dem Poisson-Problem fur dasPotential berechnet werden.




Fehlerabschatzung

Betrachte abstrakt die Differentialgleichung

∂u(t, x)

∂t= (A+B)u(t, x),

und die gesplitteten Gleichungen

∂u∗(t, x)

∂t= Au∗(t, x),

∂u∗∗(t, x)

∂t= Bu∗∗(t, x).




Die Losungen der Gleichungen in t+ ∆t lauten dann

u(t+ ∆t) = e∆t(A+B)u(t).

bzw.

u∗(t+ ∆t) = e∆tAu∗(t), u∗∗(t+ ∆t) = e∆tBu∗∗(t).

Godunov-Splitting liefert die Losung

u(t+ ∆t) = e∆tBu∗(t+ ∆t) = e∆tBe∆tAu(t).




Ein Vergleich der Reihenentwicklungen zeigt

e∆t(A+B) − e∆tBe∆tA =∆t2

2(AB −BA) +O(∆t3),

d.h., falls die Operatoren nicht kommutieren, ist der Fehler vonOrdnung 1 in der Zeit.




Numerische Behandlung

Eine Moglichkeit, die Splitting-Methode numerisch zu realisieren,ist, in jedem Zeitschritt t

I das elliptische Problem −∆xφ(t, x) = ρ(t, x) mit FEM zulosen und

I die zwei Transportgleichungen

∂f

∂t+ v · ∇xf = 0,

∂f

∂t+ E · ∇vf = 0

mit FVM zu behandeln.

Im Folgenden werden beide Verfahren zusammen mit einerImplementierung in DUNE vorgestellt.




Theoretische Einfuhrung

Galerkin-FormulierungWir betrachten als Beispiel das Poisson-Problem

−∆u = f in Ω,

u = 0 auf Γ.

Die FEM basiert auf einer schwachen Formulierung, derGalerkin-Formulierung. Betrachten wir dazu den Raum

V =v ∈ H1(Ω) | v = 0 auf Γ

.

Mit der ersten Greenschen Formel erhalten wir fur u, v ∈ V :∫Ω−∆u v dx =

∫Ω∇u · ∇v dx,





Seien fur u, v ∈ V und f ∈ L2(Ω)

a(u, v) =

∫Ω∇u · ∇v dx =

∫Ω−∆u v dx,

und

ϕ(v) =

∫Ωf v dx .

Damit lautet die Galerkin-Formulierung des ProblemsFinde u ∈ V , sodass

a(u, v) = ϕ(v), v ∈ V,

gilt.





Galerkin-Approximation

Fur die FEM schranken wir die Galerkin-Formulierung auf einenendlich dimensionalen Unterraum Vh ⊂ V ein. Diese sogenannteGalerkin-Approximation lautet:Finde uh ∈ Vh, sodass

a(u, v) = ϕ(v), v ∈ Vh,

gilt.





Konstruktion Finiter Elemente

Die Idee der FEM ist es, den Raum Vh bezuglich einer Zerlegungvon Ω in Dreiecke Ki zu wahlen. Dabei sind die Dreiecke Ki Teileines Tupels (Ki,Pi,Ni), genannt Finites Element, mit denEigenschaften:

I Ki ⊂ R2 ist abgeschlossen und beschankt mit nichtleeremInneren und stuckweise glattem Rand.

I Pi ist ein endlich dimensionaler Vektorraum von Funktionenauf Ki.

I Ni = Ni,1, Ni,2, . . . , Ni,k ist eine Basis von P ′i.





Beispiel Lagrange Element

z1

z2z3

L3L2

L1

Abbildung: Lagrange-Element fur lineare Ansatzfunktionen





xi

ϕi

Abbildung: Lineare Ansatzfunktion ϕi im Knoten xi





Interpolationsoperator

Zu jedem finiten Element (K,P,N ) betrachten wir den lokalenInterpolationsoperator

IKv =

k∑j=1

Nj(v)ϕj ,

wobei ϕj eine duale Basis zu N ist.Den globale Interpolationsoperator definieren wir durch

(Ihv)|Ki= IKiv, i ∈ I.





Beispiel fur Interpolation

x4x1 x2 x3 x5 x6

Abbildung: Interpolation durch lineare Ansatzfunktionen





Fehlerabschatzung

Die Formfunktionen Pi konnen so gewahlt werden, dass sie dieApproximationsordnung m haben, d.h.

‖v − Ihv‖H1(Ω) ≤ Chm−1|v|Hm(Ω), ∀v ∈ V ∩ Ck(Ω).

Wahlt man nun den Unterraum Vh als

Vh = Ih(V ∩ Ck(Ω)) ∩ C(Ω),

so folgt aus Ceas Lemma direkt

‖u− uh‖H1(Ω) ≤ Chm−1|u|Hm(Ω).





Ist ψjNj=1 eine Basis von Vh, so lasst sich die Galerkin-Appro-ximation als lineares Gleichungssystem

Auh = fh

schreiben. Dabei ist die Matrix A ∈ RN×N durch

Ajk = a(ψj , ψk) =

∫Ω∇ψj · ∇ψk dx,

und die rechte Seite fh ∈ RN durch

(fh)j = ϕ(ψj) =

∫Ωfψj dx

gegeben.




Implementierung mit DUNE

Uberblick

DUNE, kurz fur Distributed and Unified Numerics Environment, istein in C++ geschriebener, modularer Baukasten zum Losen vonpartiellen Differentialgleichungen mit gitterbasierten Methoden.Er besteht aus

I core modules,

I grid modules und

I discretization modules.

Der Fokus dieses Vortrags liegt auf dem discretization moduledune-fem.





Das Programm

Im Kern besteht das Programm aus sechs Teilen, namlich

I der Klasse Probleminterface,

I der Klasse Model,

I der Klasse EllipticOperator,

I der Funktion assembleRHS(),

I der Klasse FemScheme und

I den Funktionen main() und algorithm().





ProblemInterface und Model

Die Klassen ProblemInterface und Model beschreiben das Problem,d.h., sie enthalten die Koeffizienten und die Randbedingungen desallgemeineren Problems

−div(D(x) · ∇u(x)) +m(x)u(x) = f(x), x ∈ Ω,

u(x) = g(x), x ∈ ΓD,

D(x)∇u(x) · ν + α(x)u(x) = t(x), x ∈ ΓN .





Beispiel fur Model

1 template < class FunctionSpace , class GridPart >

2 struct DiffusionModel

3

4 template < class Entity , class Point >

5 void diffusiveFlux ( const Entity &entity ,

6 const Point &x,

7 const RangeType &value ,

8 const JacobianRangeType &

gradient ,

9 JacobianRangeType &flux ) const

10

11 flux = gradient;

12





EllipticOperator

Die Klasse EllipticOperator kummert sich um den Aufbau derMatrix A, d.h., sie berechnet die Eintrage

Ajk =

∫Ω∇ψj · ∇ψk dx =

∑i∈I

∫Ki

∇ψj · ∇ψk dx .

Dazu betrachtet man lokale Matrizen Ai,i ∈ I, die den Beitrag aufdem Element Ki umfassen.





Referenzelement

Es ist ublich, die Elemente Ki mit einem Referenzelement Kvermoge einer Abbildung Fi : K → Ki zu identifizieren.Somit folgt

Aijk =

∫Ki

∇ψj · ∇ψk dx

=

∫K|detDFi| (∇ψj · ∇ψk) Fi dx

≈ |K|q∑

α=1

wα|detDFi(xα)| (∇ψKj · ∇ψKk )(xα),

fur eine geeignete Quadratur und BasisfunktionenψKj

auf K.





Beispiel fur Berechnung der Eintrage1 for( IteratorType it = rangeSpace.begin(); it !=

rangeSpace.end(); ++it )

2

3 const EntityType &entity = *it;

4 const GeometryType &geometry = entity.geometry ();

5

6 LocalMatrixType jLocal = jOp.localMatrix( entity ,

entity );

7

8 QuadratureType quadrature( entity , order );

9 for( size_t pt = 0; pt < quadrature.nop(); ++pt )

10

11 const double weight = quadrature.weight( pt ) *

geometry.integrationElement( quadrature.point( pt

) );





Berechnung der Matrixeintrage

Die Matrix Ai wird spaltenweise aufgebaut, d.h., in

Aijk = |K|q∑

α=1

wα|detDFi(xα)| (∇ψKj · ∇ψKk )(xα),

werden fur festes k und alle j die Eintrage simultan berechnet.Durch Caching werden die Basisfunktionen ψKj nur einmalig in denQuadraturpunkten ausgewertet.





Beispiel fur Berechnung der Eintrage

1 domainBaseSet.jacobianAll( quadrature[ pt ], dphi );

2

3 RangeJacobianRangeType adphi( 0 );

4 for( unsigned int localCol = 0; localCol <

domainNumBasisFunctions; ++ localCol )

5

6 model().DiffusiveFlux( entity , quadrature[ pt ],

dphi[ localCol ], adphi );

7

8 jLocal.column( localCol ).axpy( dphi , adphi , weight

);

9





Das restliche Programm

I Der Aufbau der rechten Seite fh in assembleRHS() verlauftanalog zur Berechnung der Matrix A.

I Die Klasse FemScheme wahlt den Raum Vh und lasst dasGleichungssystem aufstellen und losen.

I Die Funktionen algorithm() und algorithm erzeugen einObjekt der Klasse FemScheme fur das gewahlte Problem undGitter. Außerdem lesen sie die Parameterdatei und schreibendie Ergebnisse in eine Datei.





Beispiel

Wir betrachten das Poisson-Problem mit rechter Seite f = 0 undDirichletbedingung

g(x) = ‖x‖2/32 sin

(2α

3

),

wobei α = arctan(x1/x2) ist.





Bemerkungen

I Die Behandlung von Randbedingungen erfolgt in der KlasseDirichletConstraints.

I Es konnen verschiedene Loser fur das Gleichungssystemverwendet werden.

I Durch leichte Modifikationen kann das Programm auchnichtlineare Probleme losen.





Problemstellung

Wir betrachten das eindimensionale hyperbolische Problem

∂q

∂t+∂f(q)

∂x= 0,

in Ω× R>0.





Diskretisierung

Wir zerlegen Ω in Intervalle

Ci = (xi−1/2, xi+1/2) ⊂ Ω

der Lange ∆x und die Zeitachse in Intervalle

(tn, tn+1) ⊂ R>0

der Lange ∆t.





Umformulierung

Wir integrieren die Gleichung uber jede Zelle Ci:

∂

∂t

∫Ciq dx = −

∫Ci

∂f(q)

∂xdx = f(q(xi−1/2))− f(q(xi+1/2))

und uber jedes Zeitintervall (tn, tn+1):∫Ciq(x, tn+1) dx−

∫Ciq(x, tn) dx =∫ tn+1

tn

f(q(xi−1/2, t)) dt−∫ tn+1

tn

f(q(xi+1/2, t)) dt





Mit

Qni ≈1

∆x

∫ xi+1/2

xi−1/2

q(x, tn) dx

und

Fni−1/2 ≈1

∆t

∫ tn+1

tn

f(q(xi−1/2, t)) dt

erhalten wir das numerische Schema

Qn+1i = Qni −

∆t

∆x(Fni+1/2 − F

ni−1/2).





Qni−1 Qni Qni+1

tn+1

tn

Qn+1i

Fni−1/2 Fni+1/2

Abbildung: Motivation fur das numerische Schema.





Godunovs Methode

1. Approximiere q im Zeitschritt tn durch die stuckweisekonstante Funktion qn, gegeben durch

qn(x, tn) = Qni fur x ∈ Ci.

2. Berechne die Losung qn+1 des hyperbolischen Problemsqt + f(q)x = 0 mit Anfangsbedingung qn zur Zeit tn+1.

3. Berechne die neuen Zellmittelwerte

Qn+1i =

1

∆x

∫Ciqn(x, tn+1) dx

und gehe zu Schritt 1.





Qni−1 Qni

tn+1

tnxi−1/2

Wi−1/2

Abbildung: Riemann-Problem im Punkt xi−1/2.





Riemann-Problem

Die Funktion qn(xi−1/2, ·) ist konstant auf (tn, tn+1) und ihr Wert

q↓(Qi−1,Qi) kann durch Losen des Riemann-Problems

qt + f(q)x = 0, q(x, tn) =

Qni−1, x < xi−1/2,

Qni , x > xi−1/2,

bestimmt werden. Der numerische Fluss ist dann gegeben durch

Fni−1/2 =1

∆t

∫ tn+1

tn

f(q↓(Qni−1,Qni )) dt = f(q↓(Qni−1,Qni )).





Qni−1 Qni

tn+1

tnxi−1/2xi−3/2 xi+1/2

smax∆t

Abbildung: Stabilitatsbedingung fur Godunovs Methode.





Stabilitat und Konvergenz

I Godunovs Methode ist im Allgemeinen stabil fur Courantzahl

smax∆t

∆x≤ 1,

wobei smax die großte Wellengeschwindigkeit ist.

I Godunovs Methode ist von erster Ordnung.

I Anstelle von konstanten Funktionen konnen auch lineareFunktionen q verwendet werden. Dies bildet die Grundlage furhoher aufgeloste Methoden.





Upwind-Methode

Wir betrachten die Gleichung qt + aqx = 0 mit a ∈ R konstant.Dann gilt offenbar fur t ∈ (tn, tn+1)

qn(xi−1/2, t) = qn(xi−1/2 − a(t− tn), tn) =

Qni−1, a > 0,

Qni , a < 0.

Mit a = a+ + a− erhalten wir den numerischen Fluss

Fni−1/2 = a+Qni−1 + a−Qni .





Qni−1 Qni

tn+1

tnxi−1/2

a∆t

Abbildung: Veranschaulichung der Upwind-Methode





Das Programm

Das Programm besteht aus

I der Klasse ProblemData,

I der Klasse TransportModel

I der Klasse FiniteVolumeScheme und

I den Funktionen main() und algorithm().





ProblemData

Wie zuvor beschreibt ProblemData ein Problem der Form

∂q(x, t)

∂t+ a · ∇q(x, t) = 0, x ∈ Ω, t ∈ (0, T ),

q(x, t) = h(x, t), x ∈ ΓD, t ∈ (0, T ),

q(x, 0) = q0(x), x ∈ Ω.





TransportModel

Ausgehend von einem Objekt der Klasse ProblemData wird hierder numerische Fluss F berechnet. Fur eine einfache Upwind-Methode ist er gegeben durch

F (q`, qr, n) =

(aq`) · n, a · n < 0,

(aqr) · n, a · n ≥ 0.





FiniteVolumeScheme

Hier wird die Losung fur den Zeitschritt tn nach tn+1 berechnet.Seien Ci ⊂ Ω Zellen mit

I Nachbarn Cj mit gemeinsamen Randflachen Sij , j ∈ N(i),

I Randflachen Sj mit Sj ⊂ Γ, j ∈ B(i),

I und außerem Normalenvektor ni.





Damit lautet das lokale Update:

Qn+1i = Qni −

∆t

|Ci|

∑j∈N(i)

|Sij |F (Qni ,Qnj , ni)

+∑j∈B(i)

|Sj |F (Qni , h(·, tn), ni)





Implementierung

1 const IteratorType end = space.end();

2 for( IteratorType it = space.begin(); it != end; ++it

)

3

4 const EntityType &entity = *it;

5 const double enVolume = 1.0 / geo.volume ();

6

7 const LocalFunctionType lfSolEn = solution.

localFunction( entity );

8 LocalFunctionType lfUpdEn = update.localFunction(

entity );





1 const IntersectionIteratorType iitend = gridPart.iend(

entity );

2 for( IntersectionIteratorType iit = gridPart.ibegin(

entity ); iit != iitend; ++iit )

3

4 const IntersectionType &intersection = *iit;

5

6 const GlobalCoordinateType normal = intersection.

centerUnitOuterNormal ();

7 LocalCoordinateType pointEn = intersection.

geometryInInside ().center ();

8 const double faceVolume = intersection.geometry ().

volume ();

9

10 RangeType qLeft;

11 lfSolEn.evaluate( pointEn , qLeft );





1 if( intersection.neighbor () )

2

3 const EntityType neighbor = intersection.outside ();

4 const double nbVolume = 1.0 / neighbor.geometry ().

volume ();

5

6

7 LocalFunctionType lfSolNb = solution.localFunction(

neighbor );

8 LocalFunctionType lfUpdNb = update.localFunction(

neighbor );

9

10 LocalCoordinateType pointNb = intersection.

geometryInOutside ().center ();





1 RangeType qRight;

2 lfSolNb.evaluate( pointNb , qRight );

3

4 RangeType flux;

5 model().numericalFlux( normal , qLeft , qRight , flux );

6

7 RangeType enFlux = flux;

8 enFlux *= -enVolume * faceVolume;

9 lfUpdEn.axpy( pointEn , enFlux );

10

11 RangeType nbFlux = flux;

12 nbFlux *= nbVolume * faceVolume;

13 lfUpdNb.axpy( pointNb , nbFlux );

14





Beispiel 1

Wir betrachten das Transportproblem fur a = (1.25, 1.25)> und

q0 = 1B1/2(0).





Bemerkungen

I Die zweite Summe fur die Randbedingung wird ahnlichberechnet.

I Es konnen alternativ verschiedene Runge-Kutta-Verfahrenverwendet werden.





Zusammenfassung

I Wir haben die FEM und FVM am Beispiel des PoissonProblems und der Transportgleichung kennengelernt.

I Die FEM baut auf der Galerkin-Formulierung auf, wahrend dieFVM die Erhaltungsgleichung als Grundlage nimmt.

I Wir haben die Methoden mit Hilfe der Bibliothek DUNErealisiert. Die Vorteile von DUNE bestehen in derModularisierung und einfachen Handhabung.



Numerische Betrachtungen und Realisierung mit DUNE fileSplitting-Methode Finite-Element-Methode...

Documents

Transcript of Numerische Betrachtungen und Realisierung mit DUNE fileSplitting-Methode Finite-Element-Methode...