Einführung in die Grundlagen der Numerik und das Programmieren unter Unix/Linux

Vorlesungsmitschrift Alexandra Gronholz

Iterative Verfahren zur Bestimmung von Nullstellen

Euler-Verfahren

   1 from pylab import *
   2 
   3 L=100 #raeumlich
   4 M=500 #zeitschritte
   5 #c=0.1  #oder unten als sinus def
   6 dx=1./L
   7 dt=1./10
   8 X=linspace(0,1,L)
   9 u=zeros((M,L))
  10 u[0,:]=exp(-500*(X-0.5)**2) #gaussfunktion
  11 #u[0,45:55]=1. #rechteck
  12 
  13 ion()
  14 figure()
  15 line,=plot(X,u[0,:])
  16 
  17 for n in range(M-1):
  18     
  19     c=0.1*cos((n*dt)/10*pi)
  20     CFL=c*dt/dx
  21     for j in range(L-1):
  22         u[n+1,j]=u[n,j]-CFL/2*(u[n,j+1]-u[n,j-1])
  23                                  
  24     line.set_ydata(u[n+1,:])
  25     draw()

euler_start.png euler_t50.png links: Startsituation rechts: Situation nach 50 Zeitschritten

Finite Differenzen Methode zur Lösung der Advektionsgleichung

Upstream-Verfahren

   1 from pylab import *
   2 
   3 L=100 #raeumlich
   4 M=500 #zeitschritte
   5 #c=0.1  #oder unten als sinus def
   6 dx=1./L
   7 dt=1./10
   8 X=linspace(0,1,L)
   9 u=zeros((M,L))
  10 u[0,:]=exp(-500*(X-0.5)**2) #gaussfunktion
  11 #u[0,45:55]=1. #rechteck
  12 
  13 ion()
  14 figure()
  15 line,=plot(X,u[0,:])
  16 
  17 for n in range(M-1):
  18     
  19     c=0.1*cos((n*dt)/10*pi)
  20     CFL=c*dt/dx
  21     for j in range(L-1):
  22         if CFL>0:
  23             u[n+1,j]=u[n,j]-CFL*(u[n,j]-u[n,j-1])
  24         else:
  25             u[n+1,j]=u[n,j]-CFL*(u[n,j+1]-u[n,j])
  26                                  
  27     line.set_ydata(u[n+1,:])
  28     draw()

upstream_start.png upstream_t50.png

links: Startsituation rechts: Situation nach 50 Zeitschritten

Upstream-Verfahren mit Werteüberschreibung

   1 from pylab import *
   2 
   3 L=100 #raeumlich           #modifiziert mit ueberschr werten/kein feld mehr
   4 M=500 #zeitschritte
   5 #c=0.1  #oder unten als sinus def
   6 dx=1./L
   7 dt=1./10
   8 X=linspace(0,1,L)
   9 u=zeros((2,L))
  10 u[0,:]=exp(-500*(X-0.5)**2) #gaussfunktion
  11 #u[0,45:55]=1. #rechteck
  12 
  13 ion()
  14 figure()
  15 line,=plot(X,u[0,:])
  16 
  17 for n in range(M-1):
  18     
  19     c=0.1*cos((n*dt)/10*pi)
  20     CFL=c*dt/dx
  21     for j in range(L-1):
  22         if CFL>0:
  23             u[1,j]=u[0,j]-CFL*(u[0,j]-u[0,j-1])
  24         else:
  25             u[1,j]=u[0,j]-CFL*(u[0,j+1]-u[0,j])
  26                                  
  27     line.set_ydata(u[1,:])
  28     draw()
  29     u[0,:]=u[1,:]

Lax-Wendroff-Verfahren

   1 from pylab import *
   2 
   3 L=100 #raeumlich
   4 M=500 #zeitschritte
   5 #c=0.1  #oder unten als sinus def
   6 dx=1./L
   7 dt=1./10
   8 X=linspace(0,1,L)
   9 u=zeros((M,L))
  10 #u[0,:]=exp(-500*(X-0.5)**2) #gaussfunktion
  11 u[0,45:55]=1. #rechteck
  12 
  13 ion()
  14 figure()
  15 line,=plot(X,u[0,:])
  16 
  17 for n in range(M-1):
  18     
  19     c=0.1*cos((n*dt)/10*pi)
  20     CFL=c*dt/dx
  21     for j in range(L-1):
  22         u[n+1,j]=u[n,j]-CFL/2*(u[n,j+1]-u[n,j-1])+CFL**2/2*(u[n,j+1]-2*u[n,j]+u[n,j-1])
  23                                  
  24     line.set_ydata(u[n+1,:])
  25     draw()

laxwendroff_start.png laxwendroff_t50.png links: Startsituation rechts: Situation nach 50 Zeitschritten

Leapfrog-Verfahren

   1 from pylab import *
   2 
   3 L=100 #raeumlich
   4 M=500 #zeitschritte
   5 #c=0.1  #oder unten als sinus def
   6 dx=1./L
   7 dt=1./10
   8 X=linspace(0,1,L)
   9 u=zeros((M,L))
  10 u[0,:]=exp(-500*(X-0.5)**2) #gaussfunktion
  11 #u[0,45:55]=1. #rechteck
  12 
  13 ion()
  14 figure()
  15 line,=plot(X,u[0,:])
  16 
  17 c=0.1*cos((0*dt)/10*pi)
  18 CFL=c*dt/dx
  19    
  20 
  21 for j in range(L-1): #j=raum
  22         u[1,j]=u[0,j]-CFL/2*(u[0,j+1]-u[0,j-1])+CFL**2/2*(u[0,j+1]-2*u[0,j]+u[0,j-1])
  23 
  24 for n in range(1,M-1):
  25     
  26     c=0.1*cos((n*dt)/10*pi)
  27     CFL=c*dt/dx
  28    
  29     
  30     for j in range(L-1):
  31         u[n+1,j]=u[n-1,j]-CFL*(u[n,j+1]-u[n,j-1])
  32                                  
  33     line.set_ydata(u[n+1,:])
  34     draw()

leapfro_start.png leapfrog_t50.png links: Startsituation rechts: Situation nach 50 Zeitschritten


FAZIT

Das Eulerverfahren zeit starke Instabilität. Während das Upstream-Verfahren zwar stabiler ist als das Euler-Verfahren (sofern CFL-Bedingung erfüllt), zeigt es dennoch starke Diffusion. Das Lax-Wendroff-Verfahren ist weniger diffusiv als das Upstrem-Verfahren und das Leapfrog-Verfahren zeigt keine Diffusion mehr, dafür jedoch starke Dispersion.