Computerorientierte Physik / SS2011

Computerorientierte Physik / SS2011
Stefan Rosenberger
25. Juni 2011
Inhaltsverzeichnis
1 Nummerische Lösung des Doppelpendels
1.1 Beschreibung der Problemstellung . . . . . . . . . . . . .
1.2 Mathematische Beschreibung des Problems . . . . . . . .
1.3 Nummerische Lösung der einfachen Differentialgleichnung
1.4 Analyse von chaotischen Verhalten und Stabilitätsanalyse
1.5 Auswertung und Graphen . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Berechnung von elektrostatischen Potentialen
2.1 Beschreibung der Problemstellung und Grundlegende Gleichungen
2.2 Numerische Lösung von Poisson- und Laplace Gleichung . . . . . .
2.3 Realisierung des Verfahrens . . . . . . . . . . . . . . . . . . . . . .
2.4 Auswertung und Graphen . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
. 8
. 8
. 10
. 12
3 Berechnung des Ising Modells mit der Monte Carlo Simulation
3.1 Beschreibung der Problemstellung . . . . . . . . . . . . . . . . . .
3.2 Monte-Carlo Simulation . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Technische Details, Berechnung von Observablen . . . . . . . . . .
3.4 Auswertung und Graphen . . . . . . . . . . . . . . . . . . . . . . .
3.5 Auszug aus dem Code . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15
15
15
17
18
23
4 Molecular-Dynamic-Simulation
4.1 Beschreibung der Problemstellung . . . . . . . . . .
4.2 Grundgleichungen für klassische Molucular-Dynamic
4.3 Schritte zur praktischen Implementierung . . . . . .
4.4 Graphen . . . . . . . . . . . . . . . . . . . . . . . . .
4.5 Auszug aus dem Code . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
25
25
25
26
28
38
5 Numerische Lösung der eindimensionalen Schrödingergleichung
5.1 Beschreibung der Problemstellung . . . . . . . . . . . . . . . . . . .
5.2 Der unendlich tiefe Potentialtopf . . . . . . . . . . . . . . . . . . . .
5.3 Bestimmung der Korrekten Energie Eigenwerte E . . . . . . . . . . .
5.4 Auszug aus meinem Code . . . . . . . . . . . . . . . . . . . . . . . .
5.5 Auswertung und Graphen . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
41
41
42
43
43
45
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
2
3
4
5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6 Lösung der 1-dim. zeitabhängigen Schrödingergleichung
55
6.1 Beschreibung der Problemstellung und Algorithmus . . . . . . . . . . . . . . . . 55
6.2 Auswertung und Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
1
1
Nummerische Lösung des Doppelpendels
1.1
Beschreibung der Problemstellung
In diesem Projekt wird als Ausgangsproblem ein zwei dimesionales Doppelpendel betrachtet.
Der Ortsraum wird hierbei durch {(x, z)T |x, z ∈ R} beschrieben. Das erste Pendel ist an einem
Fixpunkt x0 = (0, 2 · L)T aufgehängt, und kann sich mit konstantem Abstand L > 0 um diesen
Punkt bewegen. Das zweite Pendel wird am Massepunkt des ersten Pendels aufgehängt, und
kann sich mit konstantem Abstand L > 0 um dieses bewegen. Beide Pendel haben jeweils die
Masse m.
Zur Vereinfachung wird angenommen dass die Verbindungen kein Gewicht aufweisen, die Rotationsbewegung reibungsfrei verläuft und nur die Gravitationsbeschleunigung g = 9, 81 sm2 wirkt.
1.2
Mathematische Beschreibung des Problems
Zur Lösung werden die Hamilton’schen Gleichungen verwendet. Alternativ hätten auch die
Lagrange Gleichungen das Problem beschreiben können, da diese jedoch Differentialgleichungen 2-ter Ordnung sind, die Hamilton’schen Gleichungen hingegen Differentialgleichungen 1-ter
Ordnung sind, sind sie bei nummerischer Näherung durch den Computer wesentlich leichter,
insbesondere bei weniger Rechenschritten genauer, zu lösen.
Hierfür wird das Problem in Polarkoordinaten umgeschrieben:
ˆ 1. Pendel
ˆ 2. Pendel
x1 = L · sin(Θ1 )
z1 = 2 · L − L · cos(Θ1 )
x2 = L · sin(Θ1 ) + L · sin(Θ2 )
z2 = 2 · L − L · cos(Θ1 ) − L · cos(Θ2 )
Wobei Θ1 den Winkel beschreibt der vom ersten Pendel und der negativen z-Achse eingeschlossen
wird und Θ2 jenen der vom zweiten Pendel und der negativen z-Achse eingeschlossen wird. Somit
kann die Lagrange Funktion aufgestellt werden:
L=T −U =
m · L2 2 · Θ˙ 21 + Θ˙ 22 + 2Θ̇1 Θ̇2 cos(Θ1 − Θ2 ) − m · g · L (3 − 2 cos(Θ1 ) − cos(Θ2 ))
2
2
Daraus berechnen sich die verallgemeinterten Impulse:
p1 =
m · L2
∂L
=
(4Θ̇1 + 2Θ̇2 cos(Θ1 − Θ2 ))
2
∂ Θ̇1
m · L2
∂L
=
(2Θ̇2 + 2Θ̇1 cos(Θ1 − Θ2 ))
2
∂ Θ̇2
Mit diesen Gleichungen lassen sich die Hamilton Funktion und daraus die Hamilton’schen Gle∂H
∂H
ichungen Θ̇i = ∂p
, p˙i = − ∂Θ
aufstellen.
i
i
p2 =
H=T +U =
p˙1 = −
p2 + 2p22 − 2p1 p2 cos(Θ1 − Θ2 )
1
· 1
+ m · g · (3 − 2 cos(Θ1 ) − cos(Θ2 ))
2
2mL
1 + sin(Θ1 − Θ2 )2
Θ̇1 =
1
p1 − p2 cos(Θ1 − Θ2 )
·
mL2
1 + sin(Θ1 − Θ2 )2
Θ̇2 =
1
2p2 − p1 cos(Θ1 − Θ2 )
·
mL2
1 + sin(Θ1 − Θ2 )2
1 p21 + 2p22 − 2p1 p2 cos(Θ1 − Θ2 )
1 p1 p2 sin(Θ1 − Θ2 )
·
+
·
sin(Θ1 −Θ2 ) cos(Θ1 −Θ2 )
mL2 1 + sin(Θ1 − Θ2 )2 mL2
1 + sin(Θ1 − Θ2 )2
−2mgL sin(Θ1 )
p˙2 = −
1 p1 p2 sin(Θ1 − Θ2 )
1 p21 + 2p22 − 2p1 p2 cos(Θ1 − Θ2 )
·
−
·
sin(Θ1 −Θ2 ) cos(Θ1 −Θ2 )
mL2 1 + sin(Θ1 − Θ2 )2 mL2
1 + sin(Θ1 − Θ2 )2
−mgL sin(Θ2 )
Um die Notation zu vereinfachen werden im folgenden die Zustände
~y (t) ∈ P := {(Θ1 (t), Θ2 (t), p1 (t), p2 (t))T |∀t ≥ 0Θ1 (t), Θ2 (t), p1 (t), p2 (t) ∈ R}
betachtet.
Damit lassen sich die Bewegungsgleichungen vereinfacht schreiben:
~y˙ (t) = F~ (~y (t))
1.3
(1)
Nummerische Lösung der einfachen Differentialgleichnung
Zur Lösung von 1 haben wir zwei Diskretisierungsverfahren besprochen.
Euler-Methode
Die Euler Methode verwendet die Potenzreihenentwicklung einer reell analytischen Funktion, und bricht diese beim quadratischen Term ab.
f (t + ε) = f (t) + εf 0 (t) +
ε2 00
f (t) + ...
2
=⇒ ~y (t + ε) = ~y (t) + εF~ (~y (t), t) + O(ε2 )
Mithilfe dieser Beschreibung der Differentialgleichung lässt sich eine rekursive Definition,
beginnend mit der Zeit t0 = 0, angeben:
~y (t0 ) = ~y (0)
~y (tn+1 ) = ~y (tn ) + εF~ (~y (tn ), tn ) mit tn+1 = tn + ε
3
Runge-Kutter 4
Das Runge Kutter 4 Verfahren verwendet zusätzliche Stützstellen bei ~y (tn + 2ε ), insgesamt
werden 4 Stützstellen betrachtet. Durch geeignete Linearkombination werden alle Korrekturen bis inklusive ε4 wegfallen, womit der Fehler des Iterationsverfahrens nur noch der
Ordnung ε5 ist.
Ein Herzstück des Verfahrens sind die vier Stützstellen:
~k1 = F~ (~y (tn ), tn )
~k2 = F~ (~y (tn ) + ε ~k1 , tn + ε )
2
2
~k3 = F~ (~y (tn ) + ε ~k2 , tn + ε )
2
2
~k4 = F~ (~y (tn ) + ε~k3 , tn + ε)
Mit diesen Gleichungen ergibt sich die Iterationsvorschrift:
ε
~y (tn + ε) = ~y (tn ) + (~k1 + 2~k2 + 2~k3 + ~k4 ) + O(ε5 )
6
1.4
Analyse von chaotischen Verhalten und Stabilitätsanalyse
Um das System auf chaotisches Verhalten zu überprüfen haben wir Poincare Schnitte, und für
die Stabilitätsanalyse haben wir die Ljapunov-Stabilität besprochen.
Poincare Schnitte
Hierfür wird das Problem im Phasenraum P betrachtet.
Wenn der Raum P die Dimension k hat, so kann man diese durch Erhaltungsgrößen reduzieren, denn jede Erhaltungsgröße reduziert die Dimension der Untermanigfaltigkeit
(welche die Bewegung beschreibt) im Phasenraum. Beim Problem des Doppelpendes ist
(für g 6= 0) nur die Energie erhalten. (Für g = 0 gilt zusätzlich die Drehimpulserhaltung)
Das Doppelpendel bewegt sich in einem vier dimensionalen Raum. Mithilfe der Energieerhaltung verbleibt also eine 3-dimensionale Untermanigfaltigkeit für die Bewegung des
Pendels. Um im verbleibenden Raum Stabilitätseigenschaften zu erkennen, betrachten
wir 2-dimensionale Unterräume, indem wir eine Komponente Null setzen. Ist im System
Stabilität gegeben so kann man eine weitere Einschränkung erkennen, die Bewegung des
Pendels kann in solchen Fällen eine (eindimensionale) Kurve beschreiben.
In unserem Problem wird die Differentialgleichung in diskreten Schritten beschrieben. Da
hierbei der Fall dass eine Komponente genau gleich 0 ist selten (bzw. so gut wie garnicht)
auftritt kann man für die Poincare Schnitte verschiedene Konzepte verwenden. Hier zwei
Möglichkeiten:
1. Man betrachte all jene Punkte für die die einzuschränkende Komponente sich in einer
ε-Umgebung um Null befindet.
2. Man nutzt die Eigenschaft dass die Bewegung des Pendels ein stetiger Vorgang ist,
daher kann man jene Punkte betrachten an denen die einzuschränkende Komponente
das Vorzeichen wechselt.
Beide Konzepte haben Vorteile und Nachteile:
1. Wenn man nur eine kleine Umgebung um die Nullstelle betrachtet so kann es sein,
dass, falls ε sehr klein gewählt wurde, viele Nullstellen nicht berücksichtigt werden.
Was entweder zu sehr langen Rechenzeiten führt oder es nicht ermöglicht eine Stabilität zu erkennen. Falls die Umgebung zu groß gewählt wurde vermischen sich die
eigentlichen Nullstellen mit Punkten (bzw. Untermanigfaltigkeiten) welche nicht zur
Einschränkung gehören, was dazu führen kann dass die mögliche Kurve ”verwischt”bzw. durch ”rauschen”verzerrt wird.
4
2. Wenn man das Wechseln der Vorzeichen betrachtet so findet man so gut wie alle
Nullstellen. Bei großen Änderungsraten des Systems können jedoch viele Punkte in
den Schnitten auftauchen die weit von der Nullstelle entfernt sind.
Ljapunov Analyse
Bei der Ljapunov Analyse der Stabilität betrachtet man die Differenz zweier nahe beisammen liegender Startbedingungen, also der Form: ~y (t, ~y0 ) und ~y (t, ~y00 ) = y(t, ~y0 + ~ε). Die
Idee besteht darin die Differenz dieser Startbedinungen ∆(t) = k~y (t, ~y0 ) − ~y (t, ~y00 )k zu
betrachten. Mithilfe dieser Abschätzung kann man folgendes schließen:
ˆ ∆(t) wächst schnell =⇒ Chaotisches System
ˆ ∆(t) bleibt klein =⇒ Reguläres Verhalten
Das Problem in der Praxis besteht natürlich darin dass die Beschreibung nahe beisammen
sehr dehnbar ist. Mathematisch lässt sich die Ljapunov Stabilität für einen Startvektor
~y (t, ~y0 ) wie folgt definieren:
.
(∀ε > 0)(∃δε > 0)(∀~y00 )..k~y0 − ~y00 k < δε =⇒ k~y (t, ~y0 ) − ~y 0 (t, ~y00 )k < ε
1.5
Auswertung und Graphen
Ich habe das Problem mit C ++ beschrieben und die Visualisierung mit Matlab gemacht. Hier
ein Auszug aus meinem Code:
Runge Kutter 4
// yy a k t u e l l e F u n k t i o n s w e r t ;
t t a k t u e l l e Z e i t ; eps Z e i t s c h r i t t
v e c t o r <double> RK4( c o n s t v e c t o r <double>& yy , c o n s t d o u b l e t t ,
const double eps )
{
v e c t o r <double> k1 (NN) , k2 (NN) , k3 (NN) , k4 (NN) ;
v e c t o r <double> YY(NN) , y y t i l d e (NN) ;
double t t t i l d e ;
k1 = Fkt ( yy , t t ) ;
// E r s t e r S c h r i t t
f o r ( i n t i =0; i <NN; i ++)
{
y y t i l d e [ i ] = yy [ i ] + e p s /2 * k1 [ i ] ;
}
t t t i l d e = t t + eps /2;
k2 = Fkt ( y y t i l d e , t t t i l d e ) ; // Z w e i t e r S c h r i t t
f o r ( i n t i =0; i <NN; i ++)
{
y y t i l d e [ i ] = yy [ i ] + e p s /2 * k2 [ i ] ;
}
k3 = Fkt ( y y t i l d e , t t t i l d e ) ;
f o r ( i n t i =0; i <NN; i ++)
{
5
// D r i t t e r S c h r i t t
y y t i l d e [ i ] = yy [ i ] + e p s * k3 [ i ] ;
}
t t t i l d e = t t + eps ;
k4 = Fkt ( y y t i l d e , t t t i l d e ) ;
// V i e r t e r S c h r i t t
f o r ( i n t i =0; i <NN; i ++)
// Der zuruckzugebende Vektor
{
YY[ i ] = yy [ i ] + e p s /6 * ( k1 [ i ] + 2 * k2 [ i ] + 2 * k3 [ i ]
+ k4 [ i ] ) ;
}
r e t u r n YY;
}
Um zu prüfen ob das Programm das gewünschte Resultat liefert wurde zusätzlich die
Gesamtenergie berechnet. Da dies eine Erhaltungsgröße ist soll sich diese nicht ändern.
Auswertung und Graphen
Die ersten beiden Graphen zeigen die Winkel der Testwerte, das zweite Paar an Graphen zeigt
die Poincare Schnitte. Für den Startwert (1, −1, 3, 0) kann man auf reguläres Verhalten schließen,
für den Startwert (0, 0, 4, −2) kann man auf chaotisches Verhalten schließen. Die ersten beiden
Graphen zeigen die ersten 20.000 Schritte (bei einer Zeitänderung von 0, 01). Die zweiten beiden
Graphen zeigen die Nullstellen von Θ2 , falls der dazugehörige Impuls p2 größer Null ist.
Poincare Schnitte
6
Ljapunov Analyse
Um die Stabilitätsanalyse nach Ljapunov durchzuführen wurden die Startbedingungen (1, −1, 3, 0)
und (1, −1, 2.9, 0.1) für die erste Differenz sowie (0, 0, 4, −2) und (0, 0, 3.9, −2.1) für die zweite
Differenz betrachtet. Auch hierbei ist das Verhalten von chaotisch und regulär gleich dem Re-
sultat aus den Poincare Schnitten.
7
2
2.1
Berechnung von elektrostatischen Potentialen
Beschreibung der Problemstellung und Grundlegende Gleichungen
Dieser Abschnitt hat das Ziel ein beliebiges Elektrostatisches Potential zu berechnen wenn die
Randbedingungen oder die Ladungsverteilung vorgegeben sind.
~ dass
Bei einer gegebenen kontinuierliche Ladungsverteilung gilt für das Elektrische Feld E
Z
~r − ~r0 3 0
~
E(~r) = ρ(~r0 )
d ~r .
k~r − ~r0 k3
Wegen
∇
1
1
~r − ~r0
1
1
0
p
=
−
2(~
r
−
~
r
)
=
−
=
∇
~r − ~r0
2 (~r − ~r0 ) 32
k~r − ~r0 k3
(~r − ~r0 )2
gilt
~ r) = −∇
E(~
Z
ρ(~r0 ) 3 0
d ~r := −∇φ(~r).
k~r − ~r0 k
wobei φ(~r) das Elektrostatische Potential beschreibt. Aus dieser Beziehung folgt
~ r) = ∇(−∇φ(~
~ r) = −4φ(~r) = 4πρ(~r)
∇E(~
Damit lässt sich das Problem als Laplace bzw. Poisson Gleichung formulieren:
4φ(~r) = −4πρ(~r) .....Piosson Gleichung
4φ(~r) = 0 .....Laplace Gleichung
2.2
Numerische Lösung von Poisson- und Laplace Gleichung
Für unser Problem betrachten wir Differentialgleichungen die vorgegebene Randbedingungen
erfüllen. Der Ansatz zur Lösung ist ähnlich zum Doppelpendel eine Diskretisierung des Raums.
Eine Standard-Diskrtetisierung für die zweite Ableitung einer gegebenen Funktion f resultiert
wie folgt.
Da f zwei mal stetig differenzierbar ist können wir eine Taylor-Reihen Entwicklung betrachten:
f (x + ε) = f (x) + f 0 (x)ε + f 00 (x)
ε2
ε3
ε4
+ f 000 (x) + f (4) (x) + O(ε5 )
2
6!
4!
ε2
ε3
ε4
− f 000 (x) + f (4) (x) + O(ε5 )
2
6!
4!
Addieren und umformen der Gleichungen liefert:
f (x − ε) = f (x) − f 0 (x)ε + f 00 (x)
f 00 (x) = [f (x + ε) − 2f (x) + f (x − ε)]
1
+ O(ε2 )
ε2
(2)
Zuerst betrachten wir die Laplace-Gleichung 4φ(~r), und eine Diskretisierung der Koordinaten
(n)
(0)
xi = xi + δi · n wobei n ∈ {1, 2, ..., Ni } gilt. Um die Beschreibung zu vereinfachen wird im
folgenden angenommen dass δi = δ gilt ∀i. Mit der eben gezeigten Repräsentation der zweiten
Ableitung folgt nun für den Laplace-Operator:
4φ(~r) =
d
X
∂2
φ(x1 , .., xi , .., xd ) =
∂x2i
i=0
8
=
d
X
φ(x1 , .., xi + δ, .., xd ) − 2φ(x1 , .., xi , .., xd ) + φ(x1 , .., xi − δ, .., xd )
δ2
i=0
Führt man noch den Vektor î = (0, ..., 1, ..., 0)T (der i-te Einheitsvektor) ein so folgt:
4φ(~r) =
d
X
φ(~r + îδ) − 2φ(~r) + φ(~r − îδ)
δ2
i=0
Somit gilt:
2
δ 4φ(~r) =
d
X
φ(~r + îδ) − 2φ(~r) + φ(~r − îδ) = δ 2 ρ(~r)
i=0
=⇒
d
X
φ(~r + îδ) + φ(~r − îδ) = 2dφ(~r) + δ 2 ρ(~r)
i=0
" d
#
1 X
1
=⇒ φ(~r) =
φ(~r + îδ) + φ(~r − îδ) + δ 2 ρ(~r)
2d
2d
i=0
Wenn man sich diese Gleichung etwas näher ansieht, so kann man erkennen das der Funktionswert an der Position ~r dem Mittlewert der Funktionswerte aller 2d Nachbarn entspricht
(natürlich mit einem Fehler der Ordnung O(ε2 )). Um diese Gleichung zu nähern betrachten wir
ein Relaxationsverfahren, welches folgende Grundstruktur hat:
ˆ Verwende Generationen von Feldwerten φ(n) (~r), n = 0, 1, 2, ...
ˆ Die Feldwerte der Anfangskonfiguration φ(0) (~r) müssen vorgegeben werden. (Nach Möglichkeit
sollten diese Anfagswerte geschickt gewählt werden, dass kann die Rechenzeit deutlich
verkürzen)
ˆ Schreibe eine Masterschleife:
Bei jedem Durchlauf wird an jedem Gitterpunkt der Mittelwert der Nachbarn gebiltet
(+eventuell Korrektur bei ρ 6= 0). Dieser Mittelwert ersetzt den alten Feldwert −→
φ(n+1) (~r).
ˆ Die Masterschleife endet wenn bei einer vorgegebenen Fehlerschrankt ε für alle ~r gilt
d h
1 X
i
2
δ
φ(n) (~r + îδ) − φ(n) (~r − îδ) − φ(n) (~r) − ρ(~r) ≤ ε
2d
2d
i=0
Für die Relaxationsverfahren Haben wir drei Beschreibungen der Generationen besprochen:
Jakobi-Methode
φ
(n+1)
" d
#
1 X (n)
1
(n)
(~r) =
φ (~r + îδ) + φ (~r − îδ) + δ 2 ρ(~r)
2d
2d
i=0
φ(n+1) (~r)
in ein Hilfsfeld einschreiben. Wenn die Werte φ(n+1) (~r) für alle ~r berechnet sind,
wird das Masterfeld mit dem Hilfsfeld überschrieben.
9
Gauß-Seidl-Methode
" d
#
X
1
1
φ(n+1) (~r) =
φ(n) (~r + îδ) + φ(n+1) (~r − îδ) + δ 2 ρ(~r)
2d
2d
i=0
Hierbei wird jeder berechnete Feldwert sofort weiterverwendet. Dieses Verfahren benötigt
zum einen kein Hilfsfeld und konvergiert zusätzlich deutlich schneller als die JakobiMethode.
Sukzessive Überrelaxation
Definiere die Gauß-Seidl-Methode durch:
" d
#
1 X (n)
1
φ(~r) =
φ (~r + îδ) + φ(n+1) (~r − îδ) + δ 2 ρ(~r)
2d
2d
i=0
Man betrachte nun folgende Gleichung:
h
i
φ(n+1) (~r) = φ(n) (~r) + ω φ(~r) − φ(n) (~r)
ω = 1 ⇒ Gauß-Seidl Methode
ω > 1 ⇒ Überrelaxation
ω < 1 ⇒ Unterrelaxation
Ein Theorem besagt dass die Relaxation nur für 0 < ω < 2 konvergieren kann und dass
nur bei Überrelaxation (ω > 1) das Verfahren schneller konvergieren kann als Gauß-Seidl.
Die Geschwindigkeit des Algorithmus ist sehr sensitiv auf ω. Leider gibt es kaum allgemeine
Aussagen über die Wahl von ω −→ ausprobieren.
2.3
Realisierung des Verfahrens
Um das Hilfsfeld und die Funktionswerte von φ effizient aufrufen zu können verwenden wir
einen sogenannten aufgerollten Index. Bei einem d-dimensionalen N1 × N2 × ... × Nd -Gitter und
einem gegebenen Vektor (n1 , n2 , ..., nd ) ist der Index gegeben durch
k = n1 + n2 · N1 + n3 · N1 · N2 + ... + nd · N1 · N2 · ... · Nd−1
Weiters ist es hilfreich ein sogenanntes Nachbarfeld als Hilfsfeld zu erzeugen. Ich habe diesen
aufgerollten Index und das Hilfsfeld mit C++ wie folgt realisiert:
// I n i t i a l i s i e r e n e i n e s d d i m e n s i o n a l e n G i t t e r s
v o i d n e i b i n i t ( i n t d , v e c t o r <v e c t o r <i n t > > & neib ,
c o n s t v e c t o r <i n t > & Abmessung )
{
v e c t o r <i n t > xx ( d ) , xxp ( d ) , xxm( d ) ;
i n t k=0;
S c h l e i f e ( d , k , neib , Abmessung , xx , xxp , xxm ) ;
}
//*******************************************************************
// k i s t Z a e h l v a r i a b l e d i e zu Beginn 0 s e i n muss
// Das Feld n e i b hat dann am Ende im :
10
/ / 0 . t e n E i n t r a g den Nachbar d e r 1 . t e n Achse i n Plus Richtung
/ / 1 . t e n E i n t r a g den Nachbar d e r 1 . t e n Achse i n Minus Richtung
/ / 2 . t e n E i n t r a g den Nachbar d e r 2 . t e n Achse i n Plus Richtung
/ / 3 . t e n E i n t r a g den Nachbar d e r 2 . t e n Achse i n Minus Richtung
// e c t .
v o i d S c h l e i f e ( c o n s t i n t d , i n t k , v e c t o r <v e c t o r <i n t > > & neib ,
c o n s t v e c t o r <i n t > & Abmessung , v e c t o r <i n t > xx , v e c t o r <i n t > xxp ,
v e c t o r <i n t > xxm)
{
// Rufe d i e S c h l e i f e a u f b i s a l l e Dimensionen e r r e i c h t s i n d
i f ( k<d−1)
{
i n t p = k+1;
f o r ( i n t i =0; i <Abmessung [ k ] ; i ++)
{
xx [ k ] = i ;
xxp [ k ] = i +1;
xxm [ k ] = i −1;
i f ( xx [ k ] == Abmessung [ k ] −1) xxp [ k ] = 0 ;
i f ( xx [ k ] == 0 ) xxm [ k ] = Abmessung [ k ] −1;
// Rufe d i e S c h l e i f e e r n e u t a u f
S c h l e i f e ( d , p , neib , Abmessung , xx , xxp , xxm ) ;
}
}
else
{
v e c t o r <i n t > n a c h b a r p l u s ( d ) , nachbarminus ( d ) ;
i n t i s , i s p , ism ;
f o r ( i n t i =0; i <Abmessung [ k ] ; i ++)
{
xx [ k ] = i ;
xxp [ k ] = i +1;
xxm [ k ] = i −1;
i f ( xx [ k ] == Abmessung [ k ] −1) xxp [ k ] = 0 ;
i f ( xx [ k ] == 0 ) xxm [ k ] = Abmessung [ k ] −1;
// Berechne d i e a k t u e l l e P o s i t i o n
i s = i n d e x ( xx , Abmessung , d ) ;
f o r ( i n t q=0; q<d ; q++)
{
n a c h b a r p l u s = xx ;
nachbarminus = xx ;
n a c h b a r p l u s [ q ] = xxp [ q ] ;
nachbarminus [ q ] = xxm [ q ] ;
i s p = i n d e x ( n a c h b a r p l u s , Abmessung , d ) ;
11
ism = i n d e x ( nachbarminus , Abmessung , d ) ;
neib [ i s ] [ 2 * q ] = isp ;
n e i b [ i s ] [ 2 * q+1] = ism ;
}
}
}
}
//*******************************************************************
// Berechnen d e s ” a u f g e r o l l t e n ” Index
i n t i n d e x ( c o n s t v e c t o r <i n t > & xx , c o n s t v e c t o r <i n t > & abm ,
const int d)
{
i n t i s = xx [ 0 ] ;
i n t NN = 1 ;
f o r ( i n t i =1; i <d ; i ++)
{
NN = NN*abm [ i − 1 ] ;
i s += xx [ i ] * NN;
}
return i s ;
}
2.4
Auswertung und Graphen
Ich habe diese Konzepte nun zum Einen angewand um das Potential eines Dipols (mit Laplace)
und zum Anderen einen Kondensator mit integrierten Faradyschen Käfig darzustellen. Da ich
mein Programm für beliebige Dimensionen erweitert habe, habe ich auch einen Kondensator mit
integrierten Faradayschen Käfig in 3 Dimensionen simuliert. Hierfür habe ich folgende Randbedingungen betrachtet:
ˆ Ein 3 dimensionaler Würfel mit den Rasterabmessungen 45 × 45 × 45.
ˆ Im inneren befindet sich ein Fraday Käfig mit den Rasterabmessungen 25 × 25 × 25 der
zentriert platziert wurde.
Die Darstellung des Potential ist natürlich nicht direkt möglich, daher habe ich 8 plots des
Potential gemacht, wobei jeweils das Potential in der x − y-Ebene für fixierte z-Werte geplottet
wurde.
12
13
Abbildung 1: Kondensator mit Farady Käfig in 3 Dimensionen
14
3
3.1
Berechnung des Ising Modells mit der Monte Carlo Simulation
Beschreibung der Problemstellung
In diesem Beispiel betrachten wir ein d-dimensionales kubisches Gitter Ω an dem an jedem
Punkt ~n ∈ Ω ein Teilchen mit Spin S~n ∈ {−1, 1} sitzt. Die Randbedingungen sollen periodisch
sein, soll heißen dass die Ränder zusammengeklappt“ werden.
”
Mikroskopisches Modell
Die Hamiltonfunktion für das Modell lässt sich schreiben als:
d
H[S] =
α XX
µX
(1 − S~n )
(1 − S~n · S~n+î ) +
2
2
~
n
i=1
~
n
wobei α ∈ R die nächste Nachbarkopplung und µ ein äußeres Magnetfeld beschreibt und î =
(0, ..., 0, 1, 0, ..., 0) der i-te Einheitsvector ist. Damit lässt sich nun die Entwicklung abhängig
vom Zustand betrachten:
Grundzustand: Alle Spins ↑= +1 damit gilt H = 0.
1. angeregter Zustand: Ein Spin ↓= −1 sonst sind alle Spins ↑ dann gilt H = 2dα + µ.
2. angeregter Zustand: Zwei benachbarte Spins ↓↓ dann gilt H = (4d − 2)α + 2µ.
3. angeregter Zustand: Zwei nicht benachbarte Spins ↓↓ dann gilt H = 4dα + 2µ.
..
.
Nun wird angenommen dass das System (Ising Magnet) in einem Wärmebad ist, und daher
wird eine konstante Temperatur T betrachtet. Ein solches System kann mit dem kanonischen
Ensamble beschrieben werden.
Die Wahrscheinlichkeit das System in einem Zustand S zu finden ist gegeben durch:
P (S) =
X
1 −βH[S]
1
e
mit Z =
e−βH[S] ; β =
Z
kB T
S
wobei kB die Boltzmann Konstante ist. Der Erwartungswert einer Observablen O(S) ist gegeben
durch:
X
1 X
hOiT =
O(S) · P (S) =
O(S)e−βH[S]
Z
S
3.2
S
Monte-Carlo Simulation
Zur Berechnung der Observablen werden sehr viele Beiträge benötigt. Für auch nur annähernd
realistische Systeme ist es praktisch unmöglich alle Beiträge zu berücksichtigen, daher verwenden wir eine Monte-Carlo Simulation um uns bei einem großen System der Lösung anzunähern.
Idee der Simulation: Man ersetzte die Summe über alle Konfigurationen durch eine Summe
über eine mit Zufallsmethoden generierte Untermenge von Konfigurationen.
S (t) für t = 1, ..., N
15
seien die Konfigurationen die durch einen Zufallsprozess erzeugt werden. (N <<< 2V )
N
1 X
(t)
O[S (t) ]e−βH[S ]
Z
hOi ∼
t=1
Z∼
n
X
e−βH[S
(t) ]
t=1
Um die Zufallsmethode umzusetzen haben wir zwei Möglichkeiten kennengelernt:
Simple sampling: (Naive Methode)
Hierbei wird S (t) als gleichverteilt angenommen und hofft daß
hOiT ∼
N
1 X
(t)
O[S (t) ]e−βH[S ]
ZN
t=1
Dieser direkte Ansatz funktioniert im Allgemeinen nicht, nur für T −→ ∞ ist dieser
brauchbar, denn dann strebt der Boltzmann Faktor gegen 1.
Importance Sampling: Man wählt die Konfiguration nicht gleichverteilt sondern nach einer
Verteilung R[S (t) ]. Dann gilt
hOiN
(t)
N
1 X e−βH[S ]
=
O[S (t) ]
(t)
ZN
R[S ]
t=1
mit
ZN =
(t)
N
X
e−βH[S ]
R[S (t) ]
t=1
Eine Gute Wahl für viele Anwendungen ist:
R[S (t) ] =
mit
ζN =
1 −βH[S (t) ]
e
ζN
N
X
e−βH[S
(t) ]
t=1
Somit erhalten wir für unser Model:
hOiN
N
N
t=1
t=1
X
X
1
=
ζN
O[S (t) ]; ZN = ζN
= N ζN
ZN
Daher erhalten wir den Erwartungswert approximiert durch einen einfachen Mittelwert
der Observablen über alle N Konfigurationen:
hOiN '
N
1 X
O[S (t) ]
N
t=1
Es gilt:
hOi = hOiN + o
1
√
N
16
=⇒ lim hOiN = hOi
N →∞
Es bleibt nun die Aufgabe die Konfigurationen zu S (t) gemäß einer Verteilung P [S (t) ] zu erzeu(t)
gen. (bei uns gilt P [S (t) ] ∼ e−βH[S ] ). Dafür verwenden wir das Konzept der Markov Ketten:
Man geht Schrittweise auf einem Pfad von aufeinander folgenden Konfigurationen S (t) durch den
Raum aller Konfigurationen. Die Konfiguration S (t+1) wird aus der Konfiguration S (t) durch
einen Zufallsprozess erzeugt. Der Zufallsprozess wird durch eine Übergangswahrscheinlichkeit
charakterisiert:
W (S (t+1) ) = S 0 |S (t) = S) = W (S → S 0 )
Wir verwenden für unser Model die Detailed balance Gleichung:
0
e−βH[S] W (S → S 0 ) = e−βH[S ] W (S 0 → S)
Bildet man die Summe über alle Konfigurationen S dann folgt:
X
X
e−βH[S] W (S → S 0 ) = e−βH[S]
W (S 0 → S) = e−βH[S]
S
S
Ein attraktiver Fixpunkt dieser Abbildung ist die Zielverteilung (gewünscht) e−βH[S]
Metropolis Algorithmus:
Hier die Struktur des Metropolis Algorithmus für das Ising Modell
1. Wähle einen Gitterpunkt ~n0
Die Angebotskonfiguration S̃ unterscheidet sich von S nur durch den Spin S~n0 dessen
Vorzeichen umgedreht wurde.
2. Berechnen der Übergangswahrscheinlichkeit:
" ±d
#!
±d
α X
α X
e−βH[S̃]
(1 − (−S~n0 )S~n0 +î ) −
(1 − S~n0 S~n0 +î )
ρ = −βH[S] = exp −β
2
2
e
i=±1
i=±1
±d
X
α
S~n0 +î
= exp −β S~n0 · 2
2
!
= exp −2JS~n0
i=±1
±d
X
!
S~n0 +î
i=±1
3. Mann wähle eine Zufallszahl r ∈ [0, 1]. Falls r < ρ gilt dann: −§~n0 −→ §~n0 .
4. GoTo (1).
3.3
Technische Details, Berechnung von Observablen
Bemerkungen zum Algorithmus
1. Bei Gleichgewichtssystemen: ~n0 . . . systematisches Durchlaufen des Gitters.
2. Alle Konfigurationen können in endlich vielen Schritten erreicht werden.
3. Der Algorithmus muss äquilibriert werden.
4. Critical slowing down:
In der Nähe von Phasenübergängen wird die Anzahl der benötigten äquilibrierungs Schritte sehr groß
17
Observablen:
Magnetisierung: M [S] =
X
S~n ; Suszeptibilität: χ = h(M − hM i)2 i
~
n
Energie: H[S] =
d
XX
~
n
1 − S~n S~n+î
; Wärmekapazität: C = h(H − hHi)2 i
i=1
1
Für die Magnetisierung gilt die Grenzfunktion: M (T ) = [1 − sinh(2J)−4 ] 8 für J > 0, 44068 und
0 sonst.
3.4
Auswertung und Graphen
Auf einem 100 × 100 Feld lässt sich einfach eine Zufallsverteilung simulieren und auswerten:
Abbildung 2: Zufallsverteilung mit P = 0.5
Ich eine Simulation in einem 500 × 500 Feld durchgeführt, dies liefert ein Resultat in dem man
gut die Weißschen Bezirke erkennen kann. Lässt man nun die Monte-Carlo Simulation laufen so
kann man bei verschiedenen Kopplungskonstanten J die Weiß’schen Bezirke erkennen. (kleines
J bedeutet hohe Temperatur, großes J bedeutet eine niedrige Temperatur).
18
19
20
21
22
3.5
Auszug aus dem Code
i n t main ( )
{
c o n s t i n t d=2;
v e c t o r <i n t > Abmessung ( d ) ;
f o r ( i n t i =0; i <d ; i ++)
{
Abmessung [ i ] = 1 0 0 ;
}
i n t Volumen = 1 ;
f o r ( i n t i =0; i <d ; i ++)
{
Volumen = Volumen * Abmessung [ i ] ;
}
v e c t o r <v e c t o r <i n t > > Nachbarn ( Volumen , v e c t o r <i n t >(2 * d ) ) ;
n e i b i n i t ( d , Nachbarn , Abmessung ) ;
i n t s p i n s [ Volumen ] ;
z u f a l l ( s p i n s , Volumen ) ;
// Z u f a l l i g e s v e r t e i l e n d e r S p i n s
// Begin f r den M e t r o p o l i s Algorithmus
// c o l d s t a r t ( s p i n s , Volumen ) ;
d o u b l e J0 = 0 . 5 0 ;
double J ;
double J d i s t = 0 . 0 1 ;
int JSchritte = 1;
i n t nsweep = 2 0 ;
int Gesamtschritte = 5000;
i n t nequi = 500;
s t r i n g name = ”MagUEner . t x t ” ;
o f s t r e a m d a t e i ( name . c s t r ( ) ) ;
s t r i n g name2 = ” Ausgabe . t x t ” ;
o f s t r e a m d a t e i 2 ( name2 . c s t r ( ) ) ;
s t r i n g name3 = ” S p i n k o n f i g . t x t ” ;
o f s t r e a m d a t e i 3 ( name3 . c s t r ( ) ) ;
f o r ( i n t k=0; k<J S c h r i t t e ; k++)
{
J = J0 + k * J d i s t ;
c o u t << J << e n d l ;
update ( s p i n s , Nachbarn , nequi , J , Volumen , d ) ;
23
f o r ( i n t i =0; i <G e s a m t s c h r i t t e ; i ++)
{
update ( s p i n s , Nachbarn , nsweep , J , Volumen , d ) ;
Observablen1 ( s p i n s , Nachbarn , Volumen , d , d a t e i ) ;
}
}
i n t kk =0;
v e c t o r <i n t > yy ( d ) ;
ausgabe ( s p i n s , Abmessung , yy , d a t e i 3 , d , kk ) ;
Observablen2 ( J0 , J d i s t , J S c h r i t t e , G e s a m t s c h r i t t e , d a t e i 2 , . . .
Volumen ) ;
datei . close ( ) ;
return 0;
}
//*******************************************************************
// Anderung d e r S p i n s j e D u r c h l a u f
v o i d update ( i n t s p i n s [ ] , v e c t o r <v e c t o r <i n t > > & neib , i n t nsweep , . . .
d o u b l e J , i n t Volumen , i n t d )
{
s ra n d ( time (NULL) ) ;
d o u b l e r r , roh ;
i n t SpinSumme ;
f o r ( i n t k=0; k<nsweep ; k++)
{
f o r ( i n t l =0; l <Volumen ; l ++)
{
SpinSumme = 0 ;
f o r ( i n t i =0; i <2*d ; i ++)
{
SpinSumme += s p i n s [ n e i b [ l ] [ i ] ] ;
}
roh = exp(−2 * J * SpinSumme * s p i n s [ l ] ) ;
r r = ( rand ( ) + 0 . 0 ) /RAND MAX;
i f ( r r <roh )
{
s p i n s [ l ] = −s p i n s [ l ] ;
}
}
}
}
24
4
4.1
Molecular-Dynamic-Simulation
Beschreibung der Problemstellung
In diesem Beispiel simulieren wir Mehrteilchen Systeme die untereinander wechselwirken. (Gase,
Flüssigkeiten, Festkörper). Hierfür verwenden wir Bewegungsgleichungen der klassischen Mechanik.
Wir betrachten ein System mit folgender Notation:
4.2
N
...Teilchen
~ri
...Position des i-ten Teilchen
~vi
...Geschwindigkeit des i-ten Teilchen
~rkl = ~rk − ~rl
...Abstandsvektor des k-ten zum l-ten Teilchen
rkl = |~rk − ~rl |
...Abstand des k-ten zum l-ten Teilchen
Grundgleichungen für klassische Molucular-Dynamic
Es lassen sich die Bewegungsgleichungen schreiben als:
d2 ri
= f~i für i = 1, · · · , N
dt2
Für das Potential zwischen den Teilchen verwenden wir das Lennard-Jones-Potential :
σ 12 σ 6
−
U(~t) = 4ε
r
r
mi ·
Nun verwenden wir eine weiter Vereinfachung der Notation:
~ = (~r1 , ~r2 , · · · , ~rN )
R
~ = (~v1 , ~v2 , · · · , ~vN )
V
!
~N
~1 f~2
f
f
~ =
,
,··· ,
G
m1 m2
mN
Um die Differentialgleichung nummerisch zu lösen verwenden wir erneut eine Diskretisierung
der Zeit, wobei h der Abstand zwischen den Zeitschritten ist und n ∈ N gilt:
t
~
R(t)
~ (t)
V
−→ n · h
~ n = R(n
~ · h)
−→ R
~n = V
~ (n · h)
−→ V
~ R(t))
~
~ n = G(
~ R
~ n)
G(
−→ G
Mit dem selben Ansatz wie schon in 2 erhalten wir:
f (t + h) − 2 · f (t) + f (t − h)
f 00 (t) =
+ O(h2 )
h2
Mit analogem Vorgehen folgt:
f (t + h) − f (t − h)
+ O(h2 )
2·h
Mit diesen Näherungen erhalten wir (nach einfachen Umformungen) die Bewegungsgleichungen
für den Verlet-Algorithmus:
f 0 (t) =
~ n+1 = 2 · R
~n − R
~ n−1 + G
~ n · h2 + O(h4 )
R
h
i
~n
~ n+1 − R
~ n−1 1 + O(h2 )
V
= R
2·h
25
Vor und Nachteile des Verlet Algorithums:
⊕ Der Algorithmus ist symmetrisch unter Zeitumkehr.
⊕ Hohe Präzision der Positionen.
Geringe Präzision der Geschwindigkeiten.
Auswertung der Geschwindigkeiten einen Zeitschritt hinterher.
Aufwändige Startprozedur.
Andere Variante des Verlet Algorithmus
Mit einigen einfachen Umformungen (Taylorreihe umschreiben und einsetzen) kann der VelocityVerlet-Algorithmus umgeschrieben werden zu:
2
~ n+1 = R
~n + h · V
~n + h G
~ n + O(h3 )
R
2
h
i
~n+1 = V
~n + h G
~ n+1 − G
~ n + O(h3 )
V
2
Diese neue Formulierung weist einige bessere Eigenschaften auf:
~ n+1 und V
~n+1 werden im gleichen Zeitschritt berechnet.
⊕ R
~ n+1 und V
~n+1 haben die gleiche Genauigkeit.
⊕ R
⊕ Einfache Startprozedur
Die Zeitumkehr ist weg. (soll heißen dass der Algorithmus nicht in die Vergangenheit rechnen
kann)
4.3
Schritte zur praktischen Implementierung
Systeme die in der Praxis simuliert werden können sind VIEL kleiner als realistische Systeme,
daher sind finite Volume Effekte unvermeidbar.
Periodische Randbedingungen haben meist die geringeren finite Volume Effekte (aufgrund der
erhaltenen Translationsinvarianz).
Periodische Randbedingungen entsprechen einer zusätzlichen Wechselwirkung mit unendlich
vielen Kopien des Systems. In unserem Model verwenden wir das Lennard Jones Potential.
26
Eine zentrale Eigenschaft diese Potentials ist dass es für große Abstände sehr schnell abfällt.
Daher verwenden wir den Ansatz das jene Potentialkräfte mit großem Abstand vernachlässigt
werden. Dafür wird die Minimal Image convention verwendet:
~
1. Ersetze rij −→ min ~ri − ~rj + k · L.
~k∈{−~1,~0,~1}
2. Nach einem Propagationsschritt wird das Teilchen zurück in die Box gesetzt:
xi < 0
=⇒ xi ←− xi + L
xi > L =⇒ xi ←− xi − L
Wobei L die Länge der Box ist.
Häufig ist es sinnvoll die Schwehrpunktsbewegung abzudrehn (Damit das System in dem vorgegebenen Bereich bleibt). In unserem Model verwenden wir zufällig gewählte Geschwindigkeiten. Im
Allgemeinen verschwindet der Gesamtimpuls nicht, er ist jedoch eine Erhaltungsgröße. Es entsteht also eine Gleichförmige Bewegung des Schwerpunkts.
Diese Bewegung trägt zwar zu kinetischen Energie (und somit zu Temperatur) bei, hat jedoch
keinen physikalischen Beitrag. (Soll heißen dass es für uns egal ist ob sich das gesamte System
bewegt oder nicht, da wir nur an den Wechselwirkungen der Teilchen interessiert sind.) Die
Gesamtbewegung abzudrehen ist prinzipiell einfach:
1. Berechne ~vtot =
N
P
~vn (0).
n=1
2. Ersetze ~vn (0) ←− ~vn (0) −
~vtot
N .
Damit ist die Schwerpunktsbewegung des Systems eliminiert.
Einstellen der Temperatur
Wir verwenden das Mikrokanonische Ensamble, also E = const. Um die Temperatur einzustellen
reskalieren wir die Geschwindigkeiten:
~vn −→ ~vn0 = λ · ~vn
Es gilt:
Ekin =
N
X
m
n=1
2
1
~vn2 = (dN − d) kB T
2
(−d da durch das abdrehen der Schwerpunktsbewegung drei Freiheitsgrade eliminiert wurden!)
Damit folgt nun
kB T =
N
N
n=1
n=1
X 2
X
λ2
m
v~0 n =
~vn = kB Tgewollt
d(N − 1)
d(N − 1)
Damit resultiert der Parameter zur Reskalierung als:
s
d(N − 1)kB Tgewollt
λ=
2Ekin
Wichtig bei der praktischen Implementierung: Es sind mehrere Iterationen von Reskalierungen
und Äquilibrierungen notwendig bis die Temperatur verlässlich eingestellt ist.
27
Transformation auf natürliche Einheiten
Wir verwenden nun die natürliche Längeneinheit σ, ε die natürliche Energie und betrachten
damit die erste Verlet Gleichung zerlegt für den Beitrag zum Teilchen k:
" 6 #
12
2 24 · ε X r~k
d
h
σ
σ
~
il
~
~
k
rn+1 = rnk + h · rnk +
·
2
−
k
k
dt
2
m
(ril )2
ril
rilk
i6=l
Um zu kontrollieren ob das System richtig simmuliert wird sollte kontrolliert werden ob die
Energie in einer vorgegebenen Toleranz liegt:
E(t) − E0 ∆E
<δ
=
E0
E0
4.4
Graphen
Die ersten Grafiken wurden erstellt durch eine Simulation mit folgenden Parametern (wobei
eine Äquilibrirung mit 100 Schritten gemacht wurde):
ˆ 2 Dimensional
ˆ Gitterabmessung: 30 × 30
ˆ Teilchenanzahl: 100
ˆ Zeitinterval: 0.01
ˆ Gesamtschritte der Simulation: 2000
28
Abbildung 3: Kristallförmig bei kB T = 0, 1
Abbildung 4: Schmelzprozess bei kB T = 0, 4
29
Abbildung 5: Tropfenbildung bei kB T = 1, 2
Abbildung 6: Gasförmig bei kB T = 2, 0
30
Nun lässt sich die Verteilung der Geschindigkeiten berechnen. (Bei der Initialisierung werden
diese zufällig gewählt und dann so moduliert dass die entsprechende Temperatur erreicht wird)
31
32
Nun habe ich die Simulation beliebig Dimensional programmiert, daher hab ich die Simulationen auch in 3D durchlaufen lassen. Folgende Parameter wurden fixiert:
ˆ 3 Dimensional
ˆ Gitterabmessung: 30 × 30 × 30 bzw. 50 × 50 × 50
ˆ Teilchenanzahl: 1000
ˆ Zeitinterval: 0.01
ˆ Gesamtschritte der Simulation: 1000
33
Abbildung 7: Kristallförmig bei kB T = 0, 1
Abbildung 8: Schmelzprozess bei kB T = 0, 4
34
Abbildung 9: Beginn einer Tropfenbildung bei kB T = 1, 2
Abbildung 10: Tröpfchen - gasförmig: bei kB T = 2, 0
35
Weiters habe ich zwei ausgedehnte Simulationen gemacht, die erste unter folgenden Parametern:
ˆ 3 Dimensional
ˆ Gitterabmessung: 50 × 50 × 50
ˆ Teilchenanzahl: 1000
ˆ Zeitinterval: 0.01
ˆ Gesamtschritte der Simulation: 2500
Hier bewegen sich alle Teilchen auf EINE gemeinsame Position zu (periodische RB). Vermut-
Abbildung 11: Bei kB T = 2, 0
lich war die Simulation nicht lang genug, daher hab ich eine lange Simulation durchgeführt:
36
Und unter folgenden Parametern:
ˆ 3 Dimensional
ˆ Gitterabmessung: 50 × 50 × 50
ˆ Teilchenanzahl: 1000
ˆ Zeitinterval: 0.009
ˆ Gesamtschritte der Simulation: 5000
ˆ Gesamt Rechenzeit: 8 Stunden und 5 Minuten
Abbildung 12: Gasförmig bei kB T = 2, 7
37
4.5
Auszug aus dem Code
v o i d o n e s t e p ( v e c t o r <v e c t o r <double> > & Eig , c o n s t i n t T e i l c h e n , . . .
c o n s t i n t d , c o n s t i n t Volumen , c o n s t v e c t o r <i n t > & Abmessung , . . .
const double h)
{
v e c t o r <v e c t o r <double> > EigNeu ( 3 * T e i l c h e n , v e c t o r <double >(d ) ) ;
d o u b l e MinAbQuad = 0 ;
double F = 0 ;
v e c t o r <double> MinRichtVec ( d ) ;
v e c t o r <double> GSum( d ) ;
f o r ( i n t i =0; i <T e i l c h e n ; i ++)
{
f o r ( i n t j =0; j <d ; j ++)
{
EigNeu [ 3 * i ] [ j ] = Eig [ 3 * i ] [ j ] + . . .
h * Eig [ 3 * i + 1 ] [ j ] + h * h/2 * Eig [ 3 * i + 2 ] [ j ] ;
}
}
f o r ( i n t i =0; i <T e i l c h e n ; i ++)
{
f o r ( i n t k=0; k<d ; k++)
{
GSum[ k ] = 0 ;
}
f o r ( i n t j =0; j <T e i l c h e n ; j ++)
{
i f ( j != i )
{
f i n d m i n ( EigNeu [ 3 * i ] , EigNeu [ 3 * j ] , . . .
Abmessung , d , Volumen , MinAbQuad , . . .
MinRichtVec ) ;
F = ZweiPot ( MinAbQuad ) ;
f o r ( i n t k=0; k<d ; k++)
{
GSum[ k ] += F * ( MinRichtVec [ k ] ) ;
}
}
}
f o r ( i n t k=0; k<d ; k++)
{
EigNeu [ 3 * i + 2 ] [ k ] = GSum[ k ] ;
}
}
f o r ( i n t i =0; i <T e i l c h e n ; i ++)
{
f o r ( i n t k=0; k<d ; k++)
{
38
EigNeu [ 3 * i + 1 ] [ k ] = Eig [ 3 * i + 1 ] [ k ] + . . .
h / 2 * ( Eig [ 3 * i + 2 ] [ k ] + EigNeu [ 3 * i + 2 ] [ k ] ) ;
}
}
f o r ( i n t i =0; i <T e i l c h e n ; i ++)
{
f o r ( i n t k=0; k<d ; k++)
{
i f ( EigNeu [ 3 * i ] [ k ] < 0 )
{
EigNeu [ 3 * i ] [ k ] += Abmessung [ k ] ;
}
i f ( EigNeu [ 3 * i ] [ k ] > Abmessung [ k ] )
{
EigNeu [ 3 * i ] [ k ] −= Abmessung [ k ] ;
}
Eig [ 3 * i ] [ k ] = EigNeu [ 3 * i ] [ k ] ;
Eig [ 3 * i + 1 ] [ k ] = EigNeu [ 3 * i + 1 ] [ k ] ;
Eig [ 3 * i + 2 ] [ k ] = EigNeu [ 3 * i + 2 ] [ k ] ;
}
}
}
//*******************************************************************
// Funktion um min ( | Ri−Rj+LK | ) zu f i n d e n
v o i d f i n d m i n ( c o n s t v e c t o r <double> & E r s t e , . . .
c o n s t v e c t o r <double> & Zweite , c o n s t v e c t o r <i n t > & Abmessung , . . .
c o n s t i n t d , c o n s t i n t Volumen , d o u b l e & MinAbQuad , . . .
v e c t o r <double> & MinRichtVec )
{
MinAbQuad = 1 ;
f o r ( i n t i =0; i <d ; i ++)
{
MinAbQuad *= Abmessung [ i ] ;
}
v e c t o r <double> RIJ ( d ) ;
f o r ( i n t i =0; i <d ; i ++)
{
RIJ [ i ] = E r s t e [ i ]− Z w e i t e [ i ] ;
}
f o r ( i n t i =0; i <d ; i ++)
{
MinRichtVec [ i ] = RIJ [ i ] ;
}
i n t kk =0;
v e c t o r <double> Abstand ( d ) ; hat
M i n S c h l e i f e ( RIJ , MinRichtVec , Abstand , Abmessung , d , kk , . . .
MinAbQuad ) ;
}
39
//*******************************************************************
// R e k u r s i v e S c h l e i f e durch a l l e Dimensionen z u r Minimumssuche
v o i d M i n S c h l e i f e ( c o n s t v e c t o r <double> & RIJ , . . .
v e c t o r <double> & MinRichtVec , v e c t o r <double> & Abstand , . . .
c o n s t v e c t o r <i n t > & Abmessung , c o n s t i n t d , i n t kk , . . .
d o u b l e & MinAbQuad )
{
i f ( kk < d−1)
{
i n t j j = kk +1;
f o r ( i n t Richtung=−1; Richtung <2; Richtung++)
{
Abstand [ kk ] = RIJ [ kk ] + Richtung * Abmessung [ kk ] ;
M i n S c h l e i f e ( RIJ , MinRichtVec , Abstand , . . .
Abmessung , d , j j , MinAbQuad ) ;
}
}
else
{
double Ve rgl ei ch ;
f o r ( i n t Richtung=−1; Richtung <2; Richtung++)
{
Vergleich = 0;
Abstand [ kk ] = RIJ [ kk ] + Richtung * Abmessung [ kk ] ;
f o r ( i n t i =0; i <d ; i ++)
{
V e r g l e i c h += Abstand [ i ] * Abstand [ i ] ;
}
i f ( V e r g l e i c h < MinAbQuad )
{
MinAbQuad = V e r g l e i c h ;
f o r ( i n t i =0; i <d ; i ++)
{
MinRichtVec [ i ] = Abstand [ i ] ;
}
}
}
}
}
40
5
5.1
Numerische Lösung der eindimensionalen Schrödingergleichung
Beschreibung der Problemstellung
In diesem Beispiel betrachten wir die Schrödigergleichung:
i~
mit
Ĥ = −
∂
ψ(~x, t) = Ĥψ(~x, t)
∂t
~2
M +V (~x);
2m
ψ(~x, t) ∈ C
i
Mit einem Seperationsansatz ψ(~x, t) = e− ~ Et ψ(~x) lässt sich die zeitfreie Schrödingergleichung
herleiten:
~2
−
M ψ(~x) + V (~x)ψ(~x) = Eψ(~x)
2m
wobei E der Energie Eigenwert ist.
Mit |ψ(~x, t)|2 = |ψ(~x)|2 ist ein Wahrscheinlichkeitsmaß gegeben, womit eine Normierung der
Wellenfunktion folgt:
Z
dV |ψ(~x)| = 1
V
Analog zu 3.1 schreibt sich damit der Erwartungswert für den Ort als:
Z
Z
2
h~xi =
~x |ψ(~x)| dV =
ψ(~x)∗ · ~x · ψ(~x)dV
V
V
Die Gleichung
Ĥψ(~x) = Eψ(~x)
ist eine Eigenwert Gleichung, damit gilt dass es nur für bestimmte Energie Eigenwerte normierte
Lösung gibt. Damit haben die Lösungen deskrete Spektren:
Energie EW: En für n = 1, 2, ...
Wellenfunktionen: ψn (~x) für n = 1, 2, ...
Somit lassen sich die diskreten Lösungen schreiben als:
i
ψn (~x, t) = e− ~ En ·t ψn (~x)
Für diese Lösungen gilt die orthonormalität:
Z
ψn (~x)∗ · ψm (~x)dV = δn,m
V
Weiters gilt die Superposition von Lösungen:
X
X
i
ψ(~x, t) =
cn ψn (~x, t) =
cn e− ~ En ·t ψn (~x)
n
n
wobei mit ψ(~x, 0) = ρ(~x) gilt
Z
cn =
ψn (~x)∗ · ρ(~x)dV
V
41
5.2
Der unendlich tiefe Potentialtopf
In unserem Problem betrachten wir den unendlichtiefen Potentialtopf, also das Potential:
0
für 0 ≤ x ≤ L
V (x) =
∞
sonst
Wie schon in 4 eliminieren wir die Dimensionen der Gleichung, dafür betrachten wir:
~2 1
· · · hat Dimension Energie
m L2
x
s = · · · ist dimensionslos
L
Multiplizieren der Schrödingergleichung mit E1 und mit
E=
v(s) =
√
V (sL)
; ϕE (s) = Lψ(sL)
E
folgt
1 d2
−
+ v(s) ϕE (s) = EϕE (s) · · · dimensionslose Schrödinger Gleichung
2 ds2
mit
v(s) =
für 0 ≤ s ≤ 1
sonst
0
∞
Referenzresultate zum Testen des Computerprogramms
Nun lässt sich in diesem dimensionslosen System die Schrödinger Gleichung lösen, womit man
√
2 sin(nπs)
für 0 ≤ s ≤ 1
ϕn (s) =
∞
sonst
erhält, und die dimensionslosen erlaubten Energie Eigenwerte sind:
En =
π2 2
n
2
Observablen sind:
Z
hsi =
1
Z
∗
ϕ(s) · s · ϕ(s)ds = 2 ·
0
1
sin(n · π · s)2 ds =
0
1
2
1
6
h(s − hsi) i = · · · =
1− 2 2
12
n π
2
Lösen der Gleichung mit Runge Kutta 4
Um Runge Kutta 4 anwenden zu können schreiben wir das Gleichungssystem in ein differentialgleichungs System 1.Ordung um:
d ϕE (s)
ϕ0E (s)
=
;
2[v(s) − E]ϕE (s)
ds ϕ0E (s)
wobei v(s) ein beliebiges Potential sein kann. Weiters führen wir eine Diskretisierung durch:
s −→ n · 4; mit n ∈ N0 und 4 =
Damit lässt sich nun das Runge Kutta 4 Verfahren anwenden.
42
1
N
5.3
Bestimmung der Korrekten Energie Eigenwerte E
Um das Problem zu lösen ist es notwendig die zweite Randbedingung ϕ(1) = 0 zu berücksichtigen.
Um dies auszuführen kann man wie folgt vorgehen:
1. Wähle eine Energie E1 und E2 = E1 + ∆E und berechne ϕE1 (1).
2. Berechne ϕE2 (1).
3.
ˆ Falls ϕE1 (1) · ϕE2 (1) < 0 −→ STOP
ˆ Sonst: E2 ←− E2 + ∆E und GOTO (2)
Damit erhält man ein Energie Intervall E1 , E2 in dem ein E existiert sodass ϕE (1) = 0 gilt, nun
bleibt nur noch diese E zu finden, dies lässt sich wie folgt realisieren:
1. Sei Ẽ =
2.
E2 −E1
2 .
ˆ Falls ϕE1 (1) · ϕE (1) < 0 −→ E2 = Ẽ
ˆ Sonst E1 = Ẽ
3.
ˆ Falls |E1 − E2 | < δ −→ STOP
ˆ Sonst Ẽ =
E2 −E1
2
und GOTO 2.
Die damit gefundene Wellenfunktion ϕẼ erfüllt beide Randbedingungen, nun bleibt nur noch
die Normierung durchzuführen. Dafür schreiben wir das Normierungsintegral:
Z 1
I=
ϕẼ (s)2 ds
0
als eine Summe:
N
1 X
I≈
ϕẼ (si )2 · |si − si−1 |
N
i=1
Damit erhalten wir die gesuchte Wellenfunktion als:
ϕẼ (s)
ϕẼ (s) = √
I
5.4
Auszug aus meinem Code
// D i e s e Randbedingungen werden i n d e r Funktion NIE g e n d e r t ! ! ! !
phi1 [ 0 ] [ 0 ] = 0 ;
phi1 [ 0 ] [ 1 ] = 1 ;
phi2 [ 0 ] [ 0 ] = 0 ;
phi2 [ 0 ] [ 1 ] = 1 ;
// Bestimmen d e r I n t e r v a l l g r e n z e n
int Schritt = 0;
EE [ 0 ] = E1 ;
w h i l e ( S c h r i t t < AnzEW)
{
S c h r i t t += 1 ;
EE [ S c h r i t t ] = GrenzSuche ( phi1 , phi2 , EE [ S c h r i t t − 1 ] , . . .
43
EnergieSuche , TeilungGrob , d , deltaGrob , MaxIt ) ;
}
//*******************************************************************
// N h e r u n g s s c h l e i f e um d i e e c h t e n E n e r g i e E i g e n w e r t e zu f i n d e n
f o r ( i n t j j =0; j j <AnzEW; j j ++)
{
E1 = EE [ j j ] ;
E2 = EE [ j j + 1 ] ;
f o r ( i n t i i =0; i i <T e i l u n g ; i i ++)
{
p h i 1 [ i i +1] = RK4( p h i 1 [ i i ] , d e l t a * i i , d e l t a , d , E1 ) ;
p h i 2 [ i i +1] = RK4( p h i 2 [ i i ] , d e l t a * i i , d e l t a , d , E2 ) ;
}
w h i l e ( abs ( p h i 1 [ T e i l u n g ] [ 0 ] ) > e p s && abs ( p h i 2 [ T e i l u n g ] [ 0 ] ) > e p s )
{
E = ( E1+E2 ) / 2 ;
phi [ 0 ] = 0 ;
phi [ 1 ] = 1 ;
f o r ( i n t i i =0; i i <T e i l u n g ; i i ++)
{
p h i = RK4( phi , d e l t a * i i , d e l t a , d , E ) ;
}
i f ( phi [ 0 ] * phi1 [ Teilung ] [ 0 ] > 0)
{
E1 = E ;
f o r ( i n t i i =0; i i <T e i l u n g ; i i ++)
{
p h i 1 [ i i +1] = RK4( p h i 1 [ i i ] , d e l t a * i i , d e l t a , d , E1 ) ;
}
}
else
{
E2 = E ;
f o r ( i n t i i =0; i i <T e i l u n g ; i i ++)
{
p h i 2 [ i i +1] = RK4( p h i 2 [ i i ] , d e l t a * i i , d e l t a , d , E2 ) ;
}
}
}
}
//*******************************************************************
// Funktion d i e den E ig en we rt E2 zuruck g i b t , s o d a s s . . .
s i g n ( p h i ( Teilung , E1 ) ) != s i g n ( p h i 2 ( Teilung , E2 ) )
d o u b l e GrenzSuche ( v e c t o r <v e c t o r <double> > phi1 , . . .
v e c t o r <v e c t o r <double> > phi2 , c o n s t d o u b l e & E1 , . . .
c o n s t d o u b l e EnergieSuche , c o n s t i n t Teilung , c o n s t i n t d , . . .
44
c o n s t d o u b l e d e l t a , c o n s t i n t MaxIt )
{
int Iteration = 0;
d o u b l e E2 = E1 + E n e r g i e S u c h e ;
f o r ( i n t i i =0; i i <T e i l u n g ; i i ++)
{
p h i 1 [ i i +1] = RK4( p h i 1 [ i i ] , d e l t a * i i , d e l t a , d , E1 ) ;
p h i 2 [ i i +1] = RK4( p h i 2 [ i i ] , d e l t a * i i , d e l t a , d , E2 ) ;
}
w h i l e ( p h i 1 [ T e i l u n g ] [ 0 ] * p h i 2 [ T e i l u n g ] [ 0 ] >= 0 & & . . .
I t e r a t i o n < MaxIt )
{
I t e r a t i o n += 1 ;
E2 += E n e r g i e S u c h e ;
f o r ( i n t i i =0; i i <T e i l u n g ; i i ++)
{
p h i 2 [ i i +1] = RK4( p h i 2 [ i i ] , d e l t a * i i , d e l t a , d , E2 ) ;
}
}
i f ( I t e r a t i o n == MaxIt )
{
c o u t << ” Kein Wechsel d e s V o r z e i c h e n s gefunden ” << e n d l ;
}
r e t u r n E2 ;
}
//*******************************************************************
// Funktion z u r D i f f e r e n t i a l g l e i c h u n g d e r S c h r d i n g e r g l e i c h u n g
v e c t o r <double> Fkt ( c o n s t v e c t o r <double>& yy , c o n s t d o u b l e s s , . . .
c o n s t i n t d , c o n s t d o u b l e E)
{
v e c t o r <double> FF( d ) ;
FF [ 0 ] = yy [ 1 ] ;
FF [ 1 ] = 2 * ( P o t e n t i a l ( s s ) − E) * yy [ 0 ] ;
r e t u r n FF ;
}
//*******************************************************************
5.5
Auswertung und Graphen
Ich habe nun die Simulation für verschiedene Potentiale durchgeführt und die errechneten
Wellenfunktionen ausgegeben (wobei die Energie Eigenwerte in der Legende fixiert wurden)
45
46
47
48
49
50
51
52
53
54
6
Lösung der 1-dim. zeitabhängigen Schrödingergleichung
6.1
Beschreibung der Problemstellung und Algorithmus
In diesem Beispiel betrachten wir die Zeitabhängige Schrödingergleichung mit natürlichen Einheiten ~ = 0 und 2m = 1.
∂ψ(x, t)
∂2
i
= Ĥ(x)ψ(x, t) = − 2 + V (x) ψ(x, t)
∂t
∂t
Diese partielle Differentialgleichung zweiter Ordung wird als Anfangswertproblem behandelt,
wobei ψ(x, 0) vorgegeben ist und ψ(x, t) für t > 0 berechnet wird. Wie schon in 5 wird |ψ(x, t)|2
als die Aufenthaltswahrscheinlichkeitsdichte interpretiert.
Wie bei den anderen Beispielen wird auch hier eine Diskretisierung vorgenommen. Für partielle
Differentialgleichungen gibt es kein Standardverfahren wie Runge Kutta 4 für gewöhnliche Differentialgleichungen. Die Diskretisierung:
ˆ x = j · ∆x · · · 0 ≤ j ≤ N ∈ N
ˆ t = n · ∆t · · · n ∈ N0
Im folgenden wird folgende Notation verwendet:
ψnj = ψ(j · ∆x, n · ∆t) ∈ C
Wie auch schon in den letzten Beispielen kann die zweite Ableitung wie folgt approximiert
werden:
∂2
ψnj+1 − 2ψnj + ψnj−1
ψ(x,
t)
=
∂x2
∆x2
Formal lässt sich die Lösung der Schrödinger Gleichung schreiben als:
ψ(x, t) = U (t)ψ(x, 0)
wobei U (t) = e−iĤt der unitäre Zeitentwicklungsoperator ist. Nun betrachten wir einen Zeitschritt
∆t. Mithilfe eines symmetrischen Trennungsansatz lässt sich schreiben:
∆t
∆t
j
1 + iĤ
ψn+1 = 1 − iĤ
ψnj + O(∆t2 )
2
2
Damit folgt mit einigen Umformungen dass:
2∆x2
2∆x2
j+1
j
j−1
2 j
j+1
2 j
ψn+1 + i
− ∆x V − 2 ψn+1 +ψn+1 = −ψn + i
+ ∆x V + 2 ψnj −ψnj−1 := Ωjn
∆t
∆t
(3)
Mit einem scharfen Blick kann man erkennen dass Ωjn mithilfe einer Dreiband Matrix geschrieben
werden kann, sei T diese Matrix dann gilt:
~n+1 = Ω
~n+1 = T −1 Ω
~ n =⇒ ψ
~n
Tψ
0
N
festgelegt wird lediglich dass Ω0n = ΩN
n = 0 und ψn = ψn = 0 gilt. Um diese Gleichungssystem
zu lösen wird ein rekusiver Ansatz verwendet:
j+1
j
ψn+1
= aj · ψn+1
+ bjn
55
(4)
Mit 3 und einigen Umformungen folgt dass:
1
aj−1 =
2 + ∆x2 V j −
i2∆x2
∆t
− aj
(5)
bj−1
n
(6)
=
+ j−1
a
Mit den Gleichungen 3,4,5 und 6 ist der Algorighmus zum Implementieren beinah fertig, es fehlt
nur noch die Anfangsbedingungen festzulegen:
2∆x2
1
2
1
2
1
Ωn = ψn+1 + i
− V ∆x − 2 ψn+1
∆t
2∆x2
a1 = 2 + ∆x2 V j − i
∆t
1
1
bn = Ωn
bj+1
n
Ωjn
Damit lässt sich mit einem vorgegebenen Potential und einem Anfangswellenpaket die zeitabhängige
Schrödingergleichung simulieren.
Als Anfangswellenfunktion habe ich ein Wellenpaket der Form
ψ(x, 0) = eiqx · e−
(x−x0 )2
2σ 2
verwendet.
6.2
Auswertung und Graphen
Ich habe den Code mit C++ umgesetzt wobei ich die Klasse complex verwendet habe um die
Arithmetik der komplexen Zahlen zu verwenden.
// G l o b a l e V a r i a b l e Komplexe E i n h e i t
complex<double> i ( 0 , 1 ) ;
i n t main ( )
{
i n t Teilung = 1000;
double d e l t a t = 0 . 1 ;
int Schritte = 5000;
v e c t o r <complex<double> > p s i ( T e i l u n g ) , omega ( T e i l u n g ) , . . .
a ( Teilung ) , b( Teilung ) ;
s t r i n g name = ” Welle7 . t x t ” ;
o f s t r e a m d a t e i ( name . c s t r ( ) ) ;
s t r i n g name1 = ” Pot7 . t x t ” ;
o f s t r e a m d a t e i 1 ( name1 . c s t r ( ) ) ;
p s i i n i t ( psi , Teilung ) ;
// Beginn d e r P a r a m e t e r f e s t l e g u n g
omega [ 0 ] = 0 ;
f o r ( i n t j =1; j <Teilung −1; j ++)
{
56
omega [ j ] = −p s i [ j +1] + ( i * 2 . 0 / d e l t a t + p o t e n t i a l ( j ) . . .
+ 2. 0 ) * psi [ j ] − psi [ j −1];
}
omega [ Teilung −1] = 0 ;
a [ 1 ] = 2 + potential (1) − i * 2.0 / deltat ;
f o r ( i n t j =1; j <T e i l u n g ; j ++)
{
a [ j ] = 2 + p o t e n t i a l ( j ) − i *2.0 / d e l t a t − 1.0 / a [ j −1];
}
// Beginn d e r S i m u l a t i o n
f o r ( i n t k=0; k<S c h r i t t e ; k++)
{
b [ 1 ] = omega [ 1 ] ;
f o r ( i n t j =2; j <T e i l u n g ; j ++)
{
b [ j ] = omega [ j ] + b [ j −1]/ a [ j − 1 ] ;
}
p s i [ Teilung −1] = 0 ;
f o r ( i n t j=Teilung −2; 0< j ; j −−)
{
p s i [ j ] = ( p s i [ j +1] − b [ j ] ) / a [ j ] ;
}
psi [ 0 ] = 0;
omega [ 0 ] = 0 ;
f o r ( i n t j =1; j <Teilung −2; j ++)
{
omega [ j ] = −p s i [ j +1] + ( i * 2 . 0 / d e l t a t + . . .
p o t e n t i a l ( j ) + 2 . 0) * psi [ j ] − psi [ j −1];
}
omega [ Teilung −1] = 0 ;
w r i t e w e l l e ( datei , psi , Teilung ) ;
}
writepot ( datei1 , Teilung ) ;
return 0;
}
Nun habe ich dieses Programm für verschiedene Potentiale ausgeführt, wobei das Startwellenpaket stets das selbe blieb. In der Legende wird angegeben nach wie viele Schritte die Kurve
geplottet wurde.
57
58
59
60
61
62
63
64