Embed Size (px)
Citation preview
Karl-Franzens Universitat GrazInstitut fur Physik
Projekt fur Computerorientierte Physik
Numerische Simulation eines Doppelpendels
und Ising-Modell
Markus Hopfer
Andreas Windisch
Graz, am 24. Juni 2008
Inhaltsverzeichnis
1 Numerische Losung des Doppelpendels 21.1 Der Hamilton Formalismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2 Die Hamilton’schen Gleichungen fur das Doppelpendel . . . . . . . . . . . . . . . . 31.3 Numerische Losung von DGLn 1.Ordnung . . . . . . . . . . . . . . . . . . . . . . . 41.4 Numerische Analyse von dynamischen Systemen . . . . . . . . . . . . . . . . . . . 6
1.4.1 Einige Grundbegriffe: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.4.2 Analyse von chaotischem Verhalten mit Poincare Schnitten . . . . . . . . . 61.4.3 Mogliche Szenarien fur Poincare Schnitte . . . . . . . . . . . . . . . . . . . 71.4.4 Stabilitatsanalyse von Bahnen (Ljapunov) . . . . . . . . . . . . . . . . . . . 7
1.5 Der Source-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.5.1 Teil 1 - Runge-Kutta-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . 81.5.2 Teil 2 - Poincare Schnitte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.5.3 Teil 3 - Ljapunov Abstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2 Monte Carlo Simulation des Ising-Modells 192.1 Das Ising-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.1 Die Hamiltonfunktion (Energiefunktional einer Konfiguration) . . . . . . . 192.1.2 Grundzustand und erste Anregungen . . . . . . . . . . . . . . . . . . . . . . 192.1.3 Abschatzung der Anzahl der Zustande in einem 100x100x100 Gitter . . . . 19
2.2 Das kanonische Ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.2.1 Die Boltzmannverteilung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Berechnung von Observablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.3.1 Nachbemerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Monte-Carlo Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.4.1 Zentrale Idee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.4.2 Simple Sampling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.4.3 Importance Sampling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5 Markov-Ketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.5.1 Detailed Balance Condition . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6 Metropolisalgorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.6.1 Implementierung des Metropolisalgorithmus in das Ising-Modell . . . . . . . 23
2.7 Berechnung der Observablen, Phasenubergang . . . . . . . . . . . . . . . . . . . . . 232.7.1 Allfallige Bemerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.8 Der Source-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.8.1 Erzeugung von Zufallskonfigurationen . . . . . . . . . . . . . . . . . . . . . 252.8.2 Der Metropolisalgorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.8.3 Der letzte Schritt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312.8.4 Z2-Flip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1
1 Numerische Losung des Doppelpendels
1.1 Der Hamilton Formalismus
Gegeben ist ein Doppelpendel in zwei Dimensionen (ebenes Doppelpendel), also ein System mitzwei Freiheitsgraden. Um das Problem numerisch besser behandeln zu konnen, ist es von Vorteildie Hamiltonfunktion des Systems zu bestimmen. Der Hamilton Formalismus - als alternativeFormulierung der Mechanik - hat den Vorteil, dass das System aus f Differentialgleichungen 2.Ordnung auf ein System von 2f Differentialgleichungen 1. Ordnung reduziert werden kann.(f ist die Zahl der Freiheitsgrade)
Ausgehend von der Lagrange-Funktion,
L(q, q, t) = T (q, q, t) − U(q, t), q = (q1, q2, . . . , qf ) (1)
fuhren wir sogenannte verallgemeinerte (oder kanonische) Impulse ein:
pi(q, q, t) =∂L(q, q, t)
∂qi
, (i = 1, 2, . . . , f) (2)
Im Prinzip kann man die Funktion pi(q, q, t) invertieren und die Geschwindigkeiten qi als Funktionder verallgemeinerten Impulse pi ausdrucken. Diese Invertierung ist meist allerdings nur lokalmoglich.
⇒ qk = qk(q, p, t) (3)
Man kann nun die Hamilton-Funktion H definieren als:
H(q, p, t) =
f∑
i=1
qi(q, p, t)pi − L(q, q(q, p, t), t) (4)
Wesentlich ist, dass H =∑
qipi−L als Funktion von q1, . . . , qf (also der Orte) sowie von p1, . . . , pf
(also den Impulsen) und der Zeit t definiert ist.
Unter Verwendung der Lagrangegleichungen berechnen wir die partiellen Ableitungen der Ha-miltonfunktion (4):
∂H∂qk
=
f∑
i=1
∂qi
∂qk
pi −∂L∂qk
−f
∑
i=1
∂L∂qi
∂qi
∂qk
= − ∂L∂qk
= − d
dt
(
∂L∂qk
)
= −pk (5)
∂H∂pk
=
f∑
i=1
∂qi
∂pk
pi + qk −f
∑
i=1
∂L∂qi
∂qi
∂pk
= qk (6)
Diese beiden Gleichungen sind die kanonischen oder Hamilton’schen Gleichungen:
pk = −∂H(q, p, t)
∂qk
, qk =∂H(q, p, t)
∂pk
, (k = 1, . . . , f) (7)
Sie folgen nach (5) und (6) aus den Lagrangegleichungen. Die Hamilton’schen Gleichungen sind einSystem von 2f Differentialgleichungen 1. Ordnung und konnen die ursprunglichen f Differentialglei-chungen 2. Ordnung (Lagrangegleichungen) vollstandig ersetzen. Der Hamilton Formalismus bietetalso eine alternative Formulierung der Bewegungsgleichungen. Das System wird nicht mehr durchdie Positionen und Geschwindigkeiten, sondern durch die Positionen und Impulse beschrieben.
2
1.2 Die Hamilton’schen Gleichungen fur das Doppelpendel
Zunachst wird die Lagrange-Funktion des Systems bestimmt. Die kinetische Energie in kartesischenKoordinaten ist:
T =m
2(x1
2 + z12 + x2
2 + z22) (8)
Wir transformieren die kartesischen Koordinaten in ebene Polarkoordinaten:
x1 = Lsin(θ1) (9)
z1 = 2L − Lcos(θ1) (10)
x2 = Lsin(θ1) + Lsin(θ2) (11)
z2 = 2L − Lcos(θ1) − Lcos(θ2) (12)
(13)
Und bilden die erste Ableitung:
x1 = Lcos(θ1)θ1 (14)
z1 = Lsin(θ1)θ1 (15)
x2 = Lcos(θ1)θ1 + Lcos(θ2)θ2 (16)
z2 = Lsin(θ1)θ1 + Lsin(θ2)θ2 (17)
(18)
Nun kann die kinetische Energie in den neuen Koordinaten bestimmt werden:
T =m
2L2(2θ1
2+ θ2
2+ 2θ1θ2cos(θ1 − θ2)) (19)
Die potentielle Energie des Systems ergibt sich wie folgt:
U = mgz1 + mgz2 = mgL(4 − 2cos(θ1) − cos(θ2)) (20)
Nun kann die Lagrange-Funktion angeschrieben werden als:
L = T − U =m
2L2(2θ1
2+ θ2
2+ 2θ1θ2cos(θ1 − θ2))−
− mgL(4 − 2cos(θ1) − cos(θ2)) (21)
Die verallgemeinerten Impulse sind die folgt definiert:
p1 =∂L∂θ1
= mL2(2θ1 + θ2cos(θ1 − θ2)) (22)
p2 =∂L∂θ2
= mL2(θ2 + θ1cos(θ1 − θ2)) (23)
Die Hamilton-Funktion H = T + U als Funktion von θ1, θ2, p1, p2 lautet demnach:
H =
2∑
i=1
∂L∂θi
θi − L = mL2(2θ1 + θ2cos(θ1 − θ2))θ1 +
+ mL2(θ2 + θ1cos(θ1 − θ2))θ2 + mgL(4 − 2cos(θ1) − cos(θ2)) =
= . . . =m
2L2(2θ1
2+ θ2
2+ 2θ1θ2cos(θ1 − θ2)) +
+ mgL(4 − 2cos(θ1) − cos(θ2)) (24)
3
Daraus ergibt sich mit der Rucksubstitution von
θ1 =1
mL2
p1 − p2cos(θ1 − θ2)
1 + sin(θ1 − θ2)2(25)
θ2 =1
mL2
2p2 − p1cos(θ1 − θ2)
1 + sin(θ1 − θ2)2(26)
und mehr oder weniger muhsamer Rechnung die folgende Form der Hamilton-Funktion fur dasD.P.-Problem:
⇒ H(θ1, p1, θ2, p2) =1
2mL2
p21 + p2
2 − 2p1p2cos(θ1 − θ2)
1 + sin(θ1 − θ2)2+
+ mgL (4 − 2cos(θ1) − cos(θ2)) (27)
Die partielle Ableitung der Hamilton-Funktion nach θi ergibt:
p1 = − 1
mL2
p1p2sin(θ1 − θ2)
1 + sin(θ1 − θ2)2+
+1
mL2
p12 + 2p2
2 − 2p1p2cos(θ1 − θ2)
(1 + sin(θ1 − θ2)2)2sin(θ1 − θ2) cos(θ1 − θ2) −
− 2mgL sin(θ1) (28)
p2 =1
mL2
p1p2sin(θ1 − θ2)
1 + sin(θ1 − θ2)2−
− 1
mL2
p12 + 2p2
2 − 2p1p2cos(θ1 − θ2)
(1 + sin(θ1 − θ2)2)2sin(θ1 − θ2) cos(θ1 − θ2) −
− mgL sin(θ2) (29)
1.3 Numerische Losung von DGLn 1.Ordnung
Der Hamilton Formalismus liefert die Bewegungsgleichungen als System von Differentialgleichun-gen 1.Ordnung, also in der Form:
~y(t) = ~F (~y(t), t) (30)
Eine sehr einfache Methode ist die nach Leonhard Euler benannte Euler-Methode. Fur die Praxisist diese Methode, aufgrund der hohen Ungenauigkeit, nicht empfehlenswert. Dafur ist sie fur dasVerstandis des numerischen Zugangs nutzlich.
Man betrachtet eine Losung ~y(t) an der Stelle ~y(t + ǫ), variiert also das Argument um einenkleinen Parameter ǫ. Dieser Parameter ist frei wahlbar und wird dem Problem entsprechend an-gepasst, d.h. wenn sich ~y(t) stark andert wird man ǫ klein wahlen. Nun kann die neue Funktionin eine Potenzreihe in ǫ entwickelt werden:
⇒ ~y(t + ǫ) = ~y(t) + ǫ ~y(t) + O(ǫ2)
= ~y(t) + ǫ ~F (~y(t), t) + O(ǫ2) (31)
Die hoheren Ordnungen werden hierbei vernachlassigt. Ausgehend von einem Anfangswert ~y0(t0),findet man den nachsten Wert durch eine lineare Naherung der Losungsfunktion. Man ersetzt alsodie tatsachliche Anderung dy durch ∆y, wobei die Genauigkeit von ǫ abhangt.Fur lineare Losungsfunktionen ist dieses Verfahren keine Naherung sondern exakt. Fur alle ande-ren Funktionen ist der Fehler von der Ordnung O(ǫ2). Die Euler-Methode ist also relativ einfach,aber zu ungenau. Um die Genauigkeit zu verbessern muss der Parameter ǫ sehr klein gemachtwerden und das erfordert eine hohere Rechenleistung.
4
Ein besseres Verfahren ist die sogenannte Runge-Kutta-Methode.
Runge-Kutta-Methode
1. Man verwendet nicht nur die diskreten Werte ~y(tn), sondern auch zusatzliche Stutzstellen~y(tn + ǫ
2 )
2. Die Vorfaktoren sind so gewahlt, dass alle Korrekturterme bis einschließlich O(ǫ4) wegfallen.
3. Die Runge-Kutta-Methode ist die Standardlosungsmethode fur gewohliche DGLn. 1.Ord-nung.
Bestimmung der Hilfsvektoren:
~K1 = ~F (~y(tn), tn) (32)
~K2 = ~F (~y(tn) +ǫ
2~K1, tn +
ǫ
2) (33)
~K3 = ~F (~y(tn) +ǫ
2~K2, tn +
ǫ
2) (34)
~K4 = ~F (~y(tn) + ǫ ~K3, tn + ǫ) (35)
Daraus folgt der (n+1)-Schritt:
~y(tn+1) = ~y(tn) +ǫ
6( ~K1 + 2 ~K2 + 2 ~K3 + ~K4) + O(ǫ5) (36)
Der Fehler geht also erst in der 5.Ordnung ein, d.h. wenn man den Parameter ǫ klein wahlt ist derFehler ≪ 1. Das Runge-Kutta-Verfahren ist also sehr gut geeignet um die numerische Naherungs-rechnung fur das Doppelpendel durchzufuhren. Abschließend sei noch erwahnt, dass es sich hierum die sogenannte Runge-Kutta-Methode 4.Ordnung (RK 4) handelt, d.h. es werden Ordnungenbis einschließlich O(ǫ4) berucksichtigt. Daneben gibt es noch Verfahren 2.Ordnung, also mit einemFehler O(ǫ3).
Bemerkungen:
• Es ist moglich die Schrittweite ǫ dynamisch anzupassen⇒ Bereiche starker Krummung → ǫ klein⇒ Bereiche geringer Krummung → ǫ großer
• Beim Runge-Kutta-Verfahren mussen die Anfangswerte und i.a. die Ableitungen an denjeweiligen Stellen vorgegeben werden.
5
1.4 Numerische Analyse von dynamischen Systemen
1.4.1 Einige Grundbegriffe:
f . . . Zahl der Freiheitsgrade ( f = 2 bei Doppelpendel)
• (φ1, . . . , φf ) . . . Punkt im Konfigurationsraumz.B. Doppelpendel mit θi ∈ [−π, π] ⇒ Torus
• (φ1, . . . , φf , p1, . . . , pf ) . . . Punkt im Phasenraum (2f-dimensional)
• Bahnen im Konfigurations- und Phasenraum sind stetig differenzierbar (wenn keine expliziteZeitabhangigkeit gegeben ist → z.B. Motor).
• Ein autonomes System(
∂H∂t
= 0)
heißt integrabel, wenn es f unabhangige Erhaltungsgroßengibt:
Fj(q1, . . . , qf , p1, . . . , pf ) = cj = const, (j = 1, . . . , f) (37)
Eine von diesen Erhaltungsgroßen cj ist z.B. die Energie.
Wenn es weniger als f Erhaltungsgroßen gibt → System nicht integrabel!
• Das System bewegt sich im Phasenraum→ jede Erhaltungsgroße reduziert die Dimension der Mannigfaltigkeit auf der sich das Sy-stem im Phasenraum bewegen kann.
Integrables System → f-dimensionale Mannigfaltigkeit im Phasenraum
• Ein 1-dimensionales autonomes System ist integrabel (weil die Energie erhalten ist).
• Systeme die nicht integrabel sind konnen Chaos zeigen.
• Meist gibt es nur spezielle Losungen in geschlossener Form.
• Allgemeine Losungen sind oft nur am Computer moglich.
1.4.2 Analyse von chaotischem Verhalten mit Poincare Schnitten
• Man studiert die Trajektorien im Phasenraum und pruft ob sich das System nur auf einerUntermannigfaltigkeit niedrigerer Dimension bewegt.
• Poincare Schnitt : Bestimmen der Durchstoßpunkte p1, p2, . . . der Phasenraumbahnen durchvorgegebene 2-dimensionale Flachen. Meist schrankt man auch noch die Durchstoßrichtungein.
• Eine mogliche Vorschrift fur das Doppelpendel ware: Immer wenn θ2 = 0 und p2 > 0 soll einPunkt (θ1, p1) gezeichnet werden.
Doppelpendel → Das System bewegt sich auf einer 3-dimensionalen Untermannigfaltig-keit in Phasenraum (weil die Energie erhalten ist). Die Vorschrift θ2 = 0 schrankt dieseweiter auf eine 2-dimensionale Flache ein.
6
1.4.3 Mogliche Szenarien fur Poincare Schnitte
1. Das System ist integrabel: (z.B. keine Erdbeschleunigung bei D.P.)
Die Energie und der Impuls sind erhalten. Daraus folgt, dass die Bahnen auf 2-dimensionaleFlachen im Phasenraum eingeschrankt sind. Beim Schnitt mit der vorgegebenen 2-dimensionalenFlache entstehen 1-dimensionale Kurven.
2. Das System ist nicht integrabel:
• Das System darf sich - im Beispiel des Doppelpendels - auf einer 3-dimensionalen Man-nigfaltigkeit bewegen ⇒ Die Schnittmenge mit der gewahlten 2-dimensionalen Flachehat selbst zwei Dimensionen.
• Unterschiedliche Anfangsbedingungen konnen chaotisches oder regulares Verhalten pro-duzieren.
1.4.4 Stabilitatsanalyse von Bahnen (Ljapunov)
Man betrachtet zwei Trajektorien im Phasenraum. Zunachst wird fur einen bestimmten Anfangs-wert die Zeitentwicklung berechnet. Danach betrachtet man, wie sich die zweite Losungskurveverhalt, wenn man die Anfangsbedingungen geringfugig variiert. Wenn das System chaotischist divergieren die beiden Kurven (chaotisches Verhalten) oder liegen nahe beieinander (nicht-chaotisches Verhalten). Den Abstand der beiden Losungskurven nennt man Ljapunov-Abstand,wobei man die Starke der Storung mit δ bezeichnet. Mathematisch kann der Zusammenhang wiefolgt formuliert werden:
Eine Losung heißt Ljapunov-stabil wenn:
∀ ǫ > 0 ∃ δ(ǫ) > 0 : ∀ ~y ′0 : |~y0 − ~y ′
0| < δ ⇒ |~y(t, ~y0) − ~y(t, ~y ′0)| < ǫ , ∀ t (38)
Die Losung heißt asymtotisch-stabil wenn gilt:
∃ δ > 0 : ∀ ~y ′0 : |~y0 − ~y ′
0| < δ : limt→∞
|~y(t, ~y0) − ~y(t, ~y ′0)| = 0 (39)
Asymptotisch stabile Losungen ziehen Trajektorien aus der Nachbarschaft an → Attraktoren.
7
1.5 Der Source-Code
1.5.1 Teil 1 - Runge-Kutta-Verfahren
Zunachst werden die Bibliotheken eingebunden die fur Input/Output-Befehle benotigt werdenund allgemeine Konstanten definiert. Anschließend werden die Prototypen deklariert, damit dasProgramm - oder vielmehr der Compiler - weiß welche Unterprogramme existieren. Die Unterpro-gramme werden spater noch eingehender erklart.
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Globale Anweisungen// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
#include <i ostream>
#include <f stream>
#include <cmath>
using namespace std ;
const double l l = 1 ;const double mm = 1;const double gg = 9 . 8 1 ;const double eps = 0 . 0 0 1 ;const int ns teps = 60000;
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Prototypen// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
double ene r g i e ( double yy [ 4 ] ) ;void f c a l c ( double yy [ 4 ] , double f f [ 4 ] ) ;
Es folgt das Hauptprogramm:
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Hauptprogramm// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
int main ( ){
double tt , ee ;double yy [ 4 ] , f f [ 4 ] , yaux [ 4 ] , k1 [ 4 ] , k2 [ 4 ] , k3 [ 4 ] , k4 [ 4 ] ;
cout << endl ;cout << ” Program pendel v2 . cpp” << endl ;cout << endl ;cout << endl ;
i f s t r eam i n f i l e ( ” pendel2 . s t a r t ” ) ;
i n f i l e >> yy [ 0 ] ;i n f i l e >> yy [ 1 ] ;i n f i l e >> yy [ 2 ] ;i n f i l e >> yy [ 3 ] ;
i n f i l e . c l o s e ( ) ;
Anschließend werden die Variablen deklariert, welche spater im Programm benotigt werden. Dazuzahlen je eine Variable fur die Zeit und eine fur die Berechnung der Energie (liefert das Unterpro-gramm ”energie”). Weiters einen Vektor yy[4] (Array mit 4 Elementen) der (θ1, p1, θ2, p2) - alsoeinen Punkt im Phasenraum - reprasentiert. Der Vektor ff[4] enthalt die Ableitungen (θ1, p1, θ2, p2).Er wird vom Unterprogramm ”fcalc” erzeugt, welches als Parameter den Vektor yy[4] erwartet.yaux[4] ist ein temporarer Vektor der fur die Berechnung der Hilfsvektoren benotigt wird, ki[4]sind die Hilfsvektoren fur RK 4. Das Programm meldet sich kurz und liest dann die Startwerteaus der Datei (”pendel2.start”) ein.
8
Es wird eine Datei zur Speicherung der Daten erzeugt. Anschließend werden Anfangsenergie sowieAnfangsauslenkung und Impulse auf das File geschrieben.
ofstream o u t f i l e ( ” pendel2 . out ” ) ;
t t = 0 . 0 ;ee = ene r g i e ( yy ) ;
o u t f i l e . width ( 1 6 ) ;o u t f i l e . p r e c i s i o n ( 7 ) ;o u t f i l e . s e t f ( i o s b a s e : : s c i e n t i f i c , i o s b a s e : : f l o a t f i e l d ) ;o u t f i l e << t t << ” ” << ee << ” ” << yy [ 0 ]
<< ” ” << yy [ 1 ] << ” ” << yy [ 2 ] << ” ” << yy [ 3 ] << endl ;
Im Folgenden wird das Runge-Kutta-Verfahren implementiert. Eine for-Schleife wird insgesamtnsteps-mal durchlaufen. Bei jedem Durchlauf wird - ausgehend von einem Anfangswert - ein Folge-wert berechnet und somit eine Trajektorie im Phasenraum durchlaufen. Im Programm wird nstepsauf 60000 gesetzt, das Inkrement eps auf 0.001. Daher berechnet das Programm das Zeitverhaltendes Systems fur 60 Sekunden. Der Vektor yaux[4] dient als Zwischenspeicher fur die Berechnungder Stutzstellen. Danach wird die jeweilige Energie des Systems berechnet, die Zeit inkrementiertund die Daten gespeichert.
for ( int n = 0 ; n < ns teps ; n++){
f c a l c ( yy , k1 ) ;yaux [ 0 ] = yy [ 0 ] + k1 [ 0 ] ∗ eps ∗ 0 . 5 ;yaux [ 1 ] = yy [ 1 ] + k1 [ 1 ] ∗ eps ∗ 0 . 5 ;yaux [ 2 ] = yy [ 2 ] + k1 [ 2 ] ∗ eps ∗ 0 . 5 ;yaux [ 3 ] = yy [ 3 ] + k1 [ 3 ] ∗ eps ∗ 0 . 5 ;f c a l c ( yaux , k2 ) ;
yaux [ 0 ] = yy [ 0 ] + k2 [ 0 ] ∗ eps ∗ 0 . 5 ;yaux [ 1 ] = yy [ 1 ] + k2 [ 1 ] ∗ eps ∗ 0 . 5 ;yaux [ 2 ] = yy [ 2 ] + k2 [ 2 ] ∗ eps ∗ 0 . 5 ;yaux [ 3 ] = yy [ 3 ] + k2 [ 3 ] ∗ eps ∗ 0 . 5 ;f c a l c ( yaux , k3 ) ;
yaux [ 0 ] = yy [ 0 ] + k3 [ 0 ] ∗ eps ;yaux [ 1 ] = yy [ 1 ] + k3 [ 1 ] ∗ eps ;yaux [ 2 ] = yy [ 2 ] + k3 [ 2 ] ∗ eps ;yaux [ 3 ] = yy [ 3 ] + k3 [ 3 ] ∗ eps ;f c a l c ( yaux , k4 ) ;
yy [ 0 ] = yy [ 0 ] + ( k1 [ 0 ] + 2 .0∗ k2 [ 0 ] + 2 .0∗ k3 [ 0 ] + k4 [ 0 ] )∗ eps / 6 . 0 ;yy [ 1 ] = yy [ 1 ] + ( k1 [ 1 ] + 2 .0∗ k2 [ 1 ] + 2 .0∗ k3 [ 1 ] + k4 [ 1 ] )∗ eps / 6 . 0 ;yy [ 2 ] = yy [ 2 ] + ( k1 [ 2 ] + 2 .0∗ k2 [ 2 ] + 2 .0∗ k3 [ 2 ] + k4 [ 2 ] )∗ eps / 6 . 0 ;yy [ 3 ] = yy [ 3 ] + ( k1 [ 3 ] + 2 .0∗ k2 [ 3 ] + 2 .0∗ k3 [ 3 ] + k4 [ 3 ] )∗ eps / 6 . 0 ;
ee = ene r g i e ( yy ) ;t t = t t + eps ;
o u t f i l e . width ( 1 6 ) ;o u t f i l e . p r e c i s i o n ( 7 ) ;o u t f i l e . s e t f ( i o s b a s e : : s c i e n t i f i c , i o s b a s e : : f l o a t f i e l d ) ;o u t f i l e << t t << ” ” << ee << ” ” << yy [ 0 ]
<< ” ” << yy [ 1 ] << ” ” << yy [ 2 ] << ” ” << yy [ 3 ] << endl ;}o u t f i l e . c l o s e ( ) ;cout << endl ;cout << ” Fe r t i g ! ” << endl ;cout << endl ;
return 0 ;
9
Die Unterprogramme dienen der Ubersichtlichkeit des Quellcodes. Das Programm ”energie” be-rechnet die Energie, d.h die Hamilton-Funktion H (27). Im Unterprogramm ”fcalc” sind die Ha-miltonschen Gleichungen (25,26,28,29) implementiert.
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Unterprogramme// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
double ene r g i e ( double yy [ 4 ] ) {
double ee ;
ee = ( yy [ 2 ] ∗ yy [ 2 ] + 2∗yy [ 3 ] ∗ yy [ 3 ] − 2∗yy [ 2 ] ∗ yy [ 3 ] ∗ cos ( yy [0]−yy [ 1 ] ) )/ ( 2∗mm∗ l l ∗ l l ∗( 1 + s i n ( yy [0]−yy [ 1 ] ) ∗ s i n ( yy [0]−yy [ 1 ] ) ) )
+ mm∗gg∗ l l ∗( 3 − 2∗ cos ( yy [ 0 ] ) − cos ( yy [ 1 ] ) ) ;
return ee ;}
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
void f c a l c ( double yy [ 4 ] , double f f [ 4 ] ) {
double fakt , den ;
f ak t = 1/( mm∗ l l ∗ l l ) ;den = 1/( 1 + s i n ( yy [0]−yy [ 1 ] ) ∗ s i n ( yy [0]−yy [ 1 ] ) ) ;
f f [ 0 ] = f ak t ∗den ∗( yy [2]−yy [ 3 ] ∗ cos ( yy [0]−yy [ 1 ] ) ) ;
f f [ 1 ] = f ak t ∗den ∗( 2∗yy [3]−yy [ 2 ] ∗ cos ( yy [0]−yy [ 1 ] ) ) ;
f f [ 2 ] = − f ak t ∗den∗yy [ 2 ] ∗ yy [ 3 ] ∗ s i n ( yy [0]−yy [ 1 ] )+ f ak t ∗den∗den ∗( yy [ 2 ] ∗ yy [ 2 ] + 2∗yy [ 3 ] ∗ yy [ 3 ]− 2∗yy [ 2 ] ∗ yy [ 3 ] ∗ cos ( yy [0]−yy [ 1 ] ) )∗ s i n ( yy [0]−yy [ 1 ] ) ∗
cos ( yy [0]−yy [ 1 ] ) − 2∗mm∗ l l ∗gg∗ s i n ( yy [ 0 ] ) ;
f f [ 3 ] = f ak t ∗den∗yy [ 2 ] ∗ yy [ 3 ] ∗ s i n ( yy [0]−yy [ 1 ] )− f ak t ∗den∗den ∗( yy [ 2 ] ∗ yy [ 2 ] + 2∗yy [ 3 ] ∗ yy [ 3 ]− 2∗yy [ 2 ] ∗ yy [ 3 ] ∗ cos ( yy [0]−yy [ 1 ] ) )∗ s i n ( yy [0]−yy [ 1 ] ) ∗
cos ( yy [0]−yy [ 1 ] ) − mm∗ l l ∗gg∗ s i n ( yy [ 1 ] ) ;}// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Nun kann mit verschiedenen Anfangswerten experimentiert, und versucht werden stark chaotischessowie annahernd periodisches Verhalten zu finden.
10
Der folgende xmgrace-Plot zeigt eine Losungskurve mit annahernd periodischem Verhalten:
-0,2 -0,1 0 0,1 0,2Auslenkung Θ1
-0,4
-0,2
0
0,2
0,4
Aus
lenk
ung
Θ2
DoppelpendelStartbedingungen: Θ1= 0, Θ2= 0, p
1= 0, p
2= 1.0
Ein ahnliches Verhalten bekommt man, wenn man p2 gegenuber p1 auftragt.
-1 -0,5 0 0,5 1Impuls p
1
-2
-1
0
1
2
Impu
ls p
2
Startbedingungen: Θ1= 0, Θ2= 0, p1= 0, p
2= 1.0
11
Nun wurde der Anfangsimpuls des unteren Pendels erhoht. Alle anderen Parameter wurden aufNull gestellt. Man erkennt, dass es ab diesem Wert zu einem Uberschlag des unteren Pendelskommt.
-2 -1 0 1 2Auslenkung Θ1
-5
0
5
Aus
lenk
ung
Θ2
Startbedingungen: Θ1= 0.0, Θ2= 0.0, p1= 0.0, p
2= 4.5
Ab einem Wert von ungefahr 6.4 schlagt auch das obere Pendel uber:
0 5 10 15 20 25Auslenkung Θ1
0
20
40
60
80
Aus
lenk
ung
Θ2
Startbedingungen: Θ1= 0.0, Θ2= 0.0, p1= 0.0, p
2= 6.4
12
1.5.2 Teil 2 - Poincare Schnitte
Der Code bleibt im Wesentlichen gleich, es wurde nun aber im Programm die folgende if-Abfrageeingebaut:
Code:...
yy [ 2 ] = yy [ 2 ] + ( k1 [ 2 ] + 2 .0∗ k2 [ 2 ] + 2 .0∗ k3 [ 2 ] + k4 [ 2 ] )∗ eps / 6 . 0 ;yy [ 3 ] = yy [ 3 ] + ( k1 [ 3 ] + 2 .0∗ k2 [ 3 ] + 2 .0∗ k3 [ 3 ] + k4 [ 3 ] )∗ eps / 6 . 0 ;
ee = ene r g i e ( yy ) ;
i f ( abs ( yy [ 1 ] ) < 0.001 and yy [ 3 ] > 0 . 0 ){
o u t f i l e << ee << ” ” << yy [ 0 ] << ” ” << yy [ 1 ]<< ” ” << yy [ 2 ] << ” ” << yy [ 3 ] << endl ;
}}o u t f i l e . c l o s e ( ) ;
...
Diese Abfrage hat zur Folge, dass wenn θ2 = 0 und p2 > 0, die jeweiligen Werte von θ1, θ2, . . . indas Ausgabe-File gespeichert werden.Die folgenden Plots zeigen Poincare Schnitte bei unterschiedlichen Anfangsbedingungen.
-0,1 -0,05 0 0,05 0,1Auslenkung Θ1
3,1
3,2
3,3
3,4
3,5
3,6
3,7
Impu
ls p
1
Doppelpendel - Poincare SchnitteStartbedingungen: Θ1= 0.1, Θ2= 0.0, p
1= 0.2, p
2= 0.3
Das System bleibt fur diese Anfangsbedingungen auf einer kleineren Untermannigfaltigkeit (2 Di-mensionen). Unendlich viele Punkt liegen dich auf einer Kurve. Der Spezialfall, dass die Mengeder Durchstoßpunkte endlich bleibt, lasst sich aufgrund der diffizil einstellbaren Anfangsbedingungnur schwer realisieren. Dafur zeigt das System relativ bald Chaos. Bei hoheren Auslenkungen oderAnfangsimpulsen werden die Durchstoßpunkte flachenfullend, das System ist chaotisch.
13
-2 -1 0 1 2Auslenkung Θ1
-5
0
5
Impu
ls p
1
Startbedingungen: Θ1= 0.8, Θ2= 1.8, p1= 0.0, p
2= 0.0
1.5.3 Teil 3 - Ljapunov Abstand
Dieser Abschnitt verlangt eine etwas umfangreichere Anderung im Quellcode.
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Globale Anweisungen// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
#include <i ostream>
#include <f stream>
#include <cmath>
using namespace std ;
const double l l = 1 ;const double mm = 1;const double gg = 9 . 8 1 ;const double eps = 0 . 0 0 1 ;
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Prototypen// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
double ene r g i e ( double yy [ 4 ] ) ;void f c a l c ( double yy [ 4 ] , double f f [ 4 ] ) ;void yy wert ( double yy [ 4 ] , double yy next [ 4 ] ) ;
Wie ublich werden zunachst wieder Bibliotheken eingebunden und Konstanten definiert. Die Kon-stante ”nsteps” entfallt hier. Im Unterprogramm ”yy-wert” wurde der Teil des Codes ausgelagert,welcher die Stutzstellen berechnet.
Im Hauptprogrammteil wurde eine User-Interaktion implementiert. Hier kann man eine belie-bige Zeitspanne zwischen 10 und 100 Sekunden wahlen, welche angibt wie lange das Programmrechnen soll. Die ubliche Try/Catch-Bedingung gewahrleistet Schutz vor falschen Eingaben. Wei-ters wurde eine Programmfortschritt-Anzeige eingebaut, da das Programm relativ lange rechnet,wenn man eine großere Zeitspanne angibt.
14
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−// Hauptprogramm// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
int main ( ){
double pr og r e s s = 0 ;double nsteps , tt , y y f i l e [ 4 ] , yy [ 4 ] , yy next [ 4 ] , f f [ 4 ] ;double Ljapunov Abstand ;
cout << endl ;cout << ”−−−−−−−−−−−−−−−−−−−−−−−−−−−−−” << endl ;cout << ” Program pende l l j apunov . cpp” << endl ;cout << ”−−−−−−−−−−−−−−−−−−−−−−−−−−−−−” ;cout << endl ;cout << endl ;cout << ” Bi t te geben s i e d i e gewuenschte
Ze i t ( 10 b i s 100 Sekunden ) e in [ (0) f o r abort ] : ” ;
do
{try
{c in >> ns teps ;
i f ( ns teps == 0 ){
cout << endl << endl << ” Bye ! ” << endl << endl ;return 1 ;
}i f ( ns teps < 10 or ns teps > 100 ) throw ” Bi t te e i n e Ze i t
zwischen 10 und 100 Sekunden eingeben : ” ;}catch ( char ∗ s t r ){
cout << endl << endl << s t r ;}
}while ( ns teps < 10 or ns teps > 100 ) ;
ns teps = nsteps ∗ 1000;
cout . p r e c i s i o n ( 0 ) ;cout . s e t f ( i o s : : f i x ed ) ;cout << endl << endl << ” Fo r t s c h r i t t :\ t ” << pr og r e s s << ” % ”<< ”\ r ” ;
Nun wird aus einer Datei der Anfangswert fur die erste Zeitentwicklung geholt, berechnet und aufein Ausgabe-File geschrieben. Weiters wird der Programm-Status ausgegeben.
i f s t r eam i n f i l e ;
i n f i l e . open ( ” l japunov1 . s t a r t ” ) ;i n f i l e >> yy [ 0 ] ;i n f i l e >> yy [ 1 ] ;i n f i l e >> yy [ 2 ] ;i n f i l e >> yy [ 3 ] ;i n f i l e . c l o s e ( ) ;
o f s tream o u t f i l e ;o u t f i l e . open ( ” l japunov . out ” ) ;o u t f i l e . width ( 1 6 ) ;o u t f i l e . p r e c i s i o n ( 7 ) ;o u t f i l e . s e t f ( i o s b a s e : : s c i e n t i f i c , i o s b a s e : : f l o a t f i e l d ) ;
o u t f i l e << yy [ 0 ] << ” ” << yy [ 1 ] << ” ”<< yy [ 2 ] << ” ” << yy [ 3 ] << endl ;
15
for ( long n = 0 ; n < ns teps ; n++){
yy wert ( yy , yy next ) ;o u t f i l e << yy next [ 0 ] << ” ” << yy next [ 1 ] << ” ”
<< yy next [ 2 ] << ” ” << yy next [ 3 ] << endl ;
for ( int i = 0 ; i < 4 ; i++) yy [ i ] = yy next [ i ] ;
p r og r e s s = 50 ∗ n / ns teps ;cout << ”\ t \ t ” << pr og r e s s << ”\ r ” ;
}o u t f i l e . c l o s e ( ) ;
Im nachsten Teil werden die Startwerte fur die zweite Zeitentwicklung aus einer weiteren Dateigeholt. Gleichzeitig werden aus der Ausgabe-Datei - in der die Daten vom vorigen Durchlauf ge-speichert sind - Werte eingelesen. Nun kann der Ljapunov Abstand (im Folgenden die Vektornorm|~y(t, ~y0)−~y(t, ~y ′
0)|) bestimmt werden. Dieser Abstand wird in eine Ausgabe-Datei (”Abstand.out”)geschrieben.
i n f i l e . open ( ” l japunov2 . s t a r t ” ) ;i n f i l e >> yy [ 0 ] ;i n f i l e >> yy [ 1 ] ;i n f i l e >> yy [ 2 ] ;i n f i l e >> yy [ 3 ] ;i n f i l e . c l o s e ( ) ;
t t = 0 . 0 ;
i n f i l e . open ( ” l japunov . out ” ) ;i n f i l e >> y y f i l e [ 0 ] ;i n f i l e >> y y f i l e [ 1 ] ;i n f i l e >> y y f i l e [ 2 ] ;i n f i l e >> y y f i l e [ 3 ] ;
Ljapunov Abstand = sq r t ( ( yy [ 0 ] − y y f i l e [ 0 ] ) ∗ ( yy [ 0 ] − y y f i l e [ 0 ] ) +(yy [ 1 ] − y y f i l e [ 1 ] ) ∗ ( yy [ 1 ] − y y f i l e [ 1 ] ) +(yy [ 2 ] − y y f i l e [ 2 ] ) ∗ ( yy [ 2 ] − y y f i l e [ 2 ] ) +(yy [ 3 ] − y y f i l e [ 3 ] ) ∗ ( yy [ 3 ] − y y f i l e [ 3 ] ) ) ;
o u t f i l e . open ( ”Abstand . out ” ) ;o u t f i l e . width ( 6 ) ;o u t f i l e . p r e c i s i o n ( 7 ) ;o u t f i l e . s e t f ( i o s b a s e : : s c i e n t i f i c , i o s b a s e : : f l o a t f i e l d ) ;o u t f i l e << t t << ” ” << Ljapunov Abstand << endl ;
for ( long n = 0 ; n < ns teps ; n++){
yy wert ( yy , yy next ) ;
i n f i l e >> y y f i l e [ 0 ] ;i n f i l e >> y y f i l e [ 1 ] ;i n f i l e >> y y f i l e [ 2 ] ;i n f i l e >> y y f i l e [ 3 ] ;
Ljapunov Abstand = sq r t ( ( yy [ 0 ] − y y f i l e [ 0 ] ) ∗ ( yy [ 0 ] − y y f i l e [ 0 ] ) +( yy [ 1 ] − y y f i l e [ 1 ] ) ∗ ( yy [ 1 ] − y y f i l e [ 1 ] ) +( yy [ 2 ] − y y f i l e [ 2 ] ) ∗ ( yy [ 2 ] − y y f i l e [ 2 ] ) +( yy [ 3 ] − y y f i l e [ 3 ] ) ∗ ( yy [ 3 ] − y y f i l e [ 3 ] ) ) ;
o u t f i l e << t t << ” ” << Ljapunov Abstand << endl ;
for ( int i = 0 ; i < 4 ; i++) yy [ i ] = yy next [ i ] ;t t = t t + eps ;
p r og r e s s = 50 + (50 ∗ (n + 1)/ ns teps ) ;cout << ”\ t \ t ” << pr og r e s s << ”\ r ” ;
}i n f i l e . c l o s e ( ) ;
16
o u t f i l e . c l o s e ( ) ;
cout << endl<< endl << ” Fe r t i g ! ” << endl << endl ;
return 0 ;}
Der folgende Plot zeigt den Ljapunov-Abstand bei nicht-chaotischem Verhalten. Der Parameter δ
bezeichnet die Differenz der Anfangswerte (ausgehend von θ1 = 0.0, θ2 = 1.0, p1 = 0.0, p2 = 0.0wurde θ2 = θ2
′ variiert):
0 10 20 30 40 50 60Zeit t [ s ]
0
1
2
3
4
Ljap
unov
Abs
tand
δ = 0.01 δ = 0.001
Doppelpendel - Ljapunov Abstandnicht-chaotisches Verhalten
Man erkennt, dass sich der Abstand auch bei relativ großen Anderungen in den Anfangsbedingun-gen nur wenig vergroßert. Ganz im Gegenteil zum chaotischen Verhalten bei hohen Anfangsim-pulsen (p1 = 8.0). Hier genugt eine winzige Anderung des Anfangswertes und die Losungskurvendivergieren vollig.
17
0 10 20 30 40 50Zeit t [ s ]
0
20
40
60
80
Ljap
unov
Abs
tand
δ = 10−8
δ = 10−6
Doppelpendel - Ljapunov Abstandchaotisches Verhalten
Am Anfang ist das System noch stabil, doch schon nach wenigen Sekunden vergroßert sich derAbstand rapide. Je kleiner die Anfangsdifferenz, desto langer bleibt das System stabil.
18
2 Monte Carlo Simulation des Ising-Modells
2.1 Das Ising-Modell
Im Folgenden soll ein mikroskopisches Modell eines Magneten diskutiert und schließlich implemen-tiert werden. Dazu betrachten wir das sogenannte Ising-Modell, welches eine eben solche Beschrei-bung ermoglicht. Dazu sei Λ ein d-dimensionales Gitter, S~n ∈ {-1,+1}; ~n ∈ Λ. S reprasentiertalso den Spin an jedem Gitterpunkt, welcher durch den Index angegeben wird. Der Spin kann alsodie Werte ±1 annehmen.
2.1.1 Die Hamiltonfunktion (Energiefunktional einer Konfiguration)
H[S] =α
2
∑
~n∈Λ
d∑
i=1
[1 − S~n · S~n+i] +µ
2
∑
~n∈Λ
[1 − S~n] (40)
Der erste Term in Formel (40) steht fur die Nachste-Nachbarn Wechselwirkung. Alle Paare benach-barter Spins werden genau einmal besucht. Der Index i ist der Einheitsvektor in die i-Richtung.Ferner ist α die Kopplung der nachsten Nachbarn, wahrend µ ein externes Magnetfeld darstellt.
2.1.2 Grundzustand und erste Anregungen
• Grundzustand: Alle Spins haben +1, Energie E = 0.
• Erster angeregter Zustand: Nur ein Spin hat den Wert −1. ⇒
E = 2dα + µ (41)
mit 2d...Koordinatenzahl (gibt an wieviele Nachbarn ein Gitterpunkt hat)
• Zweiter angeregter Zustand: zwei benachbarte Spins haben den Wert −1.
E = (4d − 2)α + 2µ (42)
2.1.3 Abschatzung der Anzahl der Zustande in einem 100x100x100 Gitter
Wir betrachten ein Gitter mit den Abmessungen von 100x100x100.Auf einer makroskopischen Skala ist dieses Gitter also winzig. Es soll nun abgeschatzt werden,wieviele mogliche Zustande in einem solchen Volumen auftreten konnen. Dazu beginnen wir:V Gitterpunkte ⇒ 2V Moglichkeiten.
V = 100 · 100 · 100 = 106 = 1000000 (43)
21000000 = 210·100000 = (210)100000 = (1024)100000
≃ (103)100000 = 10300000
Trotz der kleinen Abmessungen gibt es eine sehr große Zahl an Moglichkeiten.
19
2.2 Das kanonische Ensemble
Fur ein statistisches System in einem Warmebad der Temperatur T ist die Wahrscheinlichkeit dasSystem in einem Zustand S zu finden durch die Boltzmann-Verteilung gegeben.
2.2.1 Die Boltzmannverteilung
Die Boltzmannverteilung wird notiert als:
P[S] =1
z· e−βH[S] (44)
β =1
kBT(45)
mit T...Temperatur in Kelvin, kB...Boltzmannkonstante kB = 1.3806505(24) · 10−23J/K.Außerdem ist die Normierungskonstante z gegeben durch:
z =∑
S
e−βH[S] (46)
So finden wir fur tiefe Temperaturen: 1kBT
>>⇒ H[S] <<.
Genauso folgt fur hohe Temperaturen: 1kBT
<<⇒ hohere Energie moglichd.h. mehrere Spins konnen umgeklappt werden (Warmefluktuation)
Erfullt nun P[S] die Anforderung eine Wahrscheinlichkeit zu sein?
0 ≤ P[S] ≤ 1 (47)∑
s
P[S] = 1 (48)
Beide Anforderungen werden offensichtlich erfullt.
2.3 Berechnung von Observablen
Magnetisierung M[S] =1
V
∑
~n∈Λ
S~n (49)
Energie H[S] (50)
(51) und (52) sind nun Beispiele fur Observablen, die im weiteren allgemein als O[S] bezeichnet.Fur den thermischen Erwartungswert im kanonischen Ensemble gilt:
〈O〉T =∑
S
O[S] · P[S] (51)
〈O〉T =1
z
∑
S
O[S]e−βH[S] (52)
Wie bereits in 2.1.3 abgeschatzt wurde ist die Anzahl der zu betrachtenden Konfiguration (≃10300000 Konfigurationen) selbst bei winzigen Volumina so groß, dass der Rechner beim Auswertenuberfordert ware. Der Ausweg aus diesem Dilemma findet sich schließlich in der Monte-CarloSimulation.
20
2.3.1 Nachbemerkungen
• Ising-Modell kann aus quantenmechanischen Uberlegungen abgeleitet werden.
• Am Phasenubergang (zweiter Ordnung) brechen traditionelle Zugangsweisen der theoreti-schen Physik (z.B. entwicklung in der Kopplungskonstanten) zusammen.
• d = 2: explizite Losung von Lars Onsager
limµ→0
limV →∞
〈M〉T = M(T ) =
[1 − (sinh(2j))−4]18 fur j > jC
0 fur j < jC
(53)
mit j = α2 β = α
21
kBT. Der Phasenubergang wurde bestimmt bei
jC = 12 ln (1 +
√2) = 0.44068 .
2.4 Monte-Carlo Simulation
2.4.1 Zentrale Idee
Die Menge aller Konfigurationen S soll durch eine viel kleinere Menge von Konfigurationen S(t),t=1,...,N ersetzt werden. Aus diesem Grunde finden wir einen zusatzlichen, hochgestellten Index(N) an der allgemeinen Observablen O, um anzudeuten dass es sich nun um N Konfigurationenhandelt.
〈O〉(N)T =
1
z(N)
N∑
t=1
O[S(t)]e−j
P
~n
P
d
i=1[1−S(t)
~n·S(t)
~n+i]
(54)
z(N) =
N∑
t=1
e−j
P
~n
P
d
i=1[1−S
(t)~n
·S(t)
~n+i ] (55)
Ferner gilt:
limN→∞
〈O〉(N)T = 〈O〉T (56)
Wir wunschen uns, dass dieser Grenzwert bereits bei niedrigem N gut approximiert wird.Im Weiteren betrachten wir nun zwei Verfahren zur Implementierung unserer zentralen Idee.
2.4.2 Simple Sampling
S(t) wird in diesem Verfahren gleichverteilt gewahlt und mit dem Boltzmannfaktor gewichtet. Au-ßer bei sehr hohen Temperaturen haben die gleichverteilten Konfigurationen einen sehr kleinenBoltzmannfaktor, d.h. dieses Verfahren ist fur dieses Problem nicht besonders gut geeignet.In Frage kame es etwa nur fur sehr hohe Temperaturen, oder auch zur Simulation von anderenSystemen wie Braunscher Bewegung.
2.4.3 Importance Sampling
Die Idee bei diesem Verfahren ist es, die Konfigurationen mit einer bestimmten Verteilung R[S(t)]
zu erzeugen. Ansatz:
〈O〉(N)T =
1
zN
N∑
t=1
e−βH
[S(t)]O[S(t)] ·1
R[S(t)]
(57)
zN =
N∑
t=1
e−βH
[S(t)] · 1
R[S(t)]
(58)
21
Fur unser Problem erweist sich folgende Wahl als gunstig:
R[S(t)] =1
ζ(N)· e−βH
[S(t)] (59)
ζ(N) =
N∑
t=1
e−βH
[S(t)] (60)
Der begunstigende Charakter dieser Wahl wird vor allem dadurch ersichtlich, dass aus Gleichungen(59) und (60) unmittelbar folgt:
〈O〉(N)T =
1
N
N∑
t=1
O[S(t)] (61)
wobei S(t) mit
R[S(t)] =1
ζ(N)· e−βH
[S(t)] (62)
verteilt ist.
Die verbleibende Aufgabe ist nun, Konfigurationen S(t) mit einer Verteilung wie in (62) zu erzeu-gen.
2.5 Markov-Ketten
Man bewegt sich schrittweise auf einem Pfad von Konfigurationen S(t) mit t = 1, 2, ... durch denRaum aller Konfigurationen. Eine neue Konfiguration S(t+1) wird aus der alten Konfiguration S(t)
durch einen Zufallsprozess erzeugt.Dieser Zufallsprozess wird durch eine Ubergangswahrscheinlichkeit charakterisiert. Die Wahr-scheinlichkeit
W (S(t+1) = S′|S(t) = S) = W (S → S′) (63)
hangt nicht von t ab.Wieder fordern wir:
1 ≥ W (S → S′) ≥ 0 (64)∑
S′
W (S → S′) = 1 (65)
Damit wird wieder gewahrleistet dass die Anforderungen, welche an eine Wahrscheinlichkeit ge-stellt werden mussen, erfullt sind.
2.5.1 Detailed Balance Condition
Die Detailed Balance Condition (auch Gleichung fur das detailierte Gleichgewicht) sorgt dafur,dass es keine Senken gibt, in welche die Wahrscheinlichkeit eintreten konnte, dh. es gibt keineWahrscheinlichkeitssenken fur die ein Eintritt wahrscheinlicher ware als ein Austritt.
e−βH[S] · W (S → S′) = e−βH[S′] · W (S′ → S) (66)
Summiert man nun diese Gleichung uber S erhalt man:∑
S
e−βH[S] · W (S → S′) = 1 · e−βH[S′] (67)
Gleichung (67) kann als Eigenwertgleichung aufgefasst werden.Die Verteilung e−βH[S] ist ein Fixpunkt, wenn die Ubergangswahrscheinlichkeiten W (S → S′) dieDetailed Balance Gleichung erfullen.
22
2.6 Metropolisalgorithmus
Es sei
R[S] =1
ζN· e−βH[S] . (68)
Der Algorithmus arbeitet auf folgende Weise:
1. Erzeuge aus S(t) eine Angebotskonfiguration S
2. Berechne ρ =R[S]
R[S(t)]
3. Ziehe eine Zufallszahl r ∈ [0, 1] gleichverteilt und akzeptiere die S als das neue S(t+1), wennr < ρ
4. Gehe zu 1
Der Metropolisalgorithmus erfullt die Detailed Balance Condition.
2.6.1 Implementierung des Metropolisalgorithmus in das Ising-Modell
Fur unseren konkreten Fall, also das Ising-Modell, sieht die Arbeitsweise des Metropolisalgorithmusso aus:
1. Wahle einen Punkt ~n0 des Gitters. Die Angebotskonfiguration S ist die alte Konfiguration
S(t), mit S(t)~n0
geflipt.
2.
ρ =e−βH[S]
e−βH
[S(t)]
= e−β[H[S]−H
[S(t)] (69)
= e−j∗
P±d
i=±1([1−(−S~n0)·S
~n0+i]−[1−S~n0
·S~n0+i
]) (70)
= e−2jS~n0
·P±d
i=±1 S~n0+i (71)
3. Akzeptiere, falls r < ρ
4. Gehe zum nachsten Punkt ~n0
2.7 Berechnung der Observablen, Phasenubergang
Der Mittelwert der allgemeinen, genaherten Observable ergibt sich zu
〈O〉(N)T =
1
N
N∑
t=1
O[S(t)] = O (72)
Fur den statistischen Fehler gilt:
〈O〉T = 〈O〉(N)T ± ǫ (73)
mit
ǫ =1√N
· σ. (74)
Es wurde keine Autokorrelation berucksichtigt.
σ2 =1
N
N∑
t=1
(O − O[S(t)])2
(75)
Es ist also stets zu bedenken, dass durch das 1√N
-Verhalten ein halber Fehler die 4-fache Statistik
erfordert.
23
2.7.1 Allfallige Bemerkungen
• Gleichgewichtsprobleme: ~n0 durchlauft systematisch. Ein Durchlauf durch das Gitter ent-spricht einem sweep.
• Dynamische Probleme (z.B. Abkuhlen): ~n0 zufallig wahlen.
• Metropolisalgorithmus fur Ising-Modell ist ergodisch (ergodisch: alle moglichen Konfigura-tionen werden besucht), dh. jede Spinkonfiguration kann durch endlich viele Schritte erreichtwerden.
• Equilibrierung des Systems ist notwendig damit der Algorithmus im Gleichgewicht ist. Kon-trollgroßen mitlaufen lassen und warten, bis sich Plateaus bilden.
• Critical Slowing Down: In der Nahe des Phasenuberganges werden fast alle Algorithmen in-effizient. Deswegen sind viele Equilibrierungsschritte und viele updates zwischen zwei ”Mes-sungen” der Observablen notwendig, d.h. am Phasenubergang kommt es zu Fluktuationen.
• Z2-Symmetrie, µ = 0 Z2 ist eine Gruppe bestehend aus {1,−1} und derGruppenverknupfung ”·”.Aufgrund der Struktur
P[S] =1
z· e−β α
2
P
~n
P
d
i=1[1−S~n·S~n+i
] (76)
kann man erkennen, dass S und -S die gleiche Wahrscheinlichkeit haben. Solange das Gitterendlich ist kommt es also zu Ubergangen von S nach -S.Eine weitere Konsequenz daraus ist, dass
M =1
V
∑
~N
S ~N(77)
wegen
〈O〉(N)T =
1
N
N∑
t=1
M(St) (78)
der Ausdruck fur den Mittelwert von M, also 〈M〉T = 0.
• Solange V < ∞:
〈O〉 =1
z
∑
S
e−βH[S]O[S] (79)
ist ein Polynom in e−β α
2 = e−j . Dieser Ausdruck ist also eine C∞-Funktion, und kann amPhasenubegang nicht senkrecht auf die Temperaturachse treffen. Dies ist auch der Grund,warum bei einer analytischen Losung des Ising-Modells ein Grenzubergang von V gegen un-endlich durchgefuhrt werden muss. (Vgl. Formel (53))
• Um auf einem endlichen Gitter Informationen uber das unendliche System zu erhalten kannman auch den Absolutbetrag der Magnetisierung studieren.
24
2.8 Der Source-Code
2.8.1 Erzeugung von Zufallskonfigurationen
Im Folgenden finden wir den Sourcecode mit dem eine Zufallskonfiguration von Spins auf einem100x100 Gitter erzeugt wird.
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Globale Anweisungen//
#include <i ostream>
#include <f stream>
#include <cmath>
using namespace std ;
const int l l = 100 ;
//// Prototypen//
void n e i b i n i t ( int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] ) ;void f i l l s p i n s ( int sp in [ l l ] [ l l ] ) ;void wr i t e c on f i g ( int sp in [ l l ] [ l l ] ) ;
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Hauptprogtramm//
int main ( ){
int xneib [ 4 ] [ l l ] [ l l ] , yneib [ 4 ] [ l l ] [ l l ] ;int sp in [ l l ] [ l l ] ;f i l l s p i n s ( sp in ) ;w r i t e c on f i g ( sp in ) ;
double j j = 0 . 5 0 ;int nequi = 1000;
cout << endl << ” Fe r t i g ! ” << endl << endl ;}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm wr i t e c on f i g//// Schr e i b t Konf igurat ion auf f i l e .//
void wr i t e c on f i g ( int sp in [ l l ] [ l l ] ){
ofstream o u t f i l e ( ” con f i g . dat ” ) ;for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
i f ( sp in [ x ] [ y ] < 0 ){o u t f i l e << x+0.5 << ” ” << y+0.5 << endl ;}
}}
}
25
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm f i l l s p i n s//// I n i t i a l i s i e r t d i e Spins .//
void f i l l s p i n s ( int sp in [ l l ] [ l l ] ){
for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
double r ;r = rand ( ) / (RANDMAX + 1 . ) ;
i f ( r <= 0 . 5 ) sp in [ x ] [ y ] = 1 ;i f ( r > 0 . 5 ) sp in [ x ] [ y ] = −1;
// cout << spin [ x ] [ y]<<endl ;}
}}
Diese Programmteile werden im Weiteren benotigt um Konfigurationen fur bestimmte Kopplungs-konstanten j (indirekt proportional zur Temperatur) vorzunehmen. Das Unterprogramm fillspinserwartet als Ubergabewert den zweidimensionalen spin-array und gibt keinen Wert zuruck. Hierwerden mittels Zufallzahlengenerierung alle Spins auf +1 oder -1 gesetzt.Das zweite Unterprogramm, writeconfig, schreibt nun diese Konfiguration auf file, und zwar nurjene Werte die den Spin -1 besitzen.Eine solche Zufallskonfiguration ist im folgenden Plot auf der nachsten Seite zu sehen. Die indigo- farbenen Squares sind Spin -1, die weißen Felder Spin +1.
Zufallskonfiguration 100 x 100Isingmodell
26
2.8.2 Der Metropolisalgorithmus
Nun werden die bereits implementierten Programmteile so umgebaut bzw. erweitert, dass derMetropolisalgorithmus arbeitet. Die Ergebnisse werden mit xmgrace ausgewertet und betrachtet.
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Globale Anweisungen
#include <i ostream>
#include <f stream>
#include <cmath>
using namespace std ;
const int l l = 100 ;
// Prototypen
void n e i b i n i t ( int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] ) ;void f i l l s p i n s ( int sp in [ l l ] [ l l ] ) ;void wr i t e c on f i g ( int sp in [ l l ] [ l l ] ) ;void update ( int nsweeps , int sp in [ l l ] [ l l ] , int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] , double j j ) ;
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Hauptprogtramm
int main ( ){
double j j = 0 . 6 ;int nequi = 10000;int xneib [ 4 ] [ l l ] [ l l ] , yneib [ 4 ] [ l l ] [ l l ] ;int sp in [ l l ] [ l l ] ;
n e i b i n i t ( xneib , yneib ) ;f i l l s p i n s ( sp in ) ;update ( nequi , spin , xneib , yneib , j j ) ;w r i t e c on f i g ( sp in ) ;
cout << endl << ” Fe r t i g ! ” << endl << endl ;}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm wr i t e c on f i g//// Schr e i b t Konf igurat ion auf f i l e .//
void wr i t e c on f i g ( int sp in [ l l ] [ l l ] ){
ofstream o u t f i l e ( ” con f i g . dat ” ) ;for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
i f ( sp in [ x ] [ y ] < 0 ){o u t f i l e << x+0.5 << ” ” << y+0.5 << endl ;}
}}
}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm update
27
//// Macht einen nsweeps sweep .//
void update ( int nsweeps , int sp in [ l l ] [ l l ] , int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] , double j j ){double rho ;for ( int count = 0 ; count < nsweeps ; count ++){
for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
rho = exp ( −2∗ j j ∗ sp in [ x ] [ y ]∗ ( sp in [ xneib [ 0 ] [ x ] [ y ] ] [ yneib [ 0 ] [ x ] [ y ] ]+ sp in [ xneib [ 1 ] [ x ] [ y ] ] [ yneib [ 1 ] [ x ] [ y ] ]+ sp in [ xneib [ 2 ] [ x ] [ y ] ] [ yneib [ 2 ] [ x ] [ y ] ]+ sp in [ xneib [ 3 ] [ x ] [ y ] ] [ yneib [ 3 ] [ x ] [ y ] ] ) ) ;
double r ;r = rand ( ) / (RANDMAX + 1 . ) ;i f ( r <= rho ){
sp in [ x ] [ y ] = −sp in [ x ] [ y ] ;}
}}
}}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm f i l l s p i n s//// I n i t i a l i s i e r t d i e Spins .//
void f i l l s p i n s ( int sp in [ l l ] [ l l ] ){
for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
double r ;r = rand ( ) / (RANDMAX + 1 . ) ;
i f ( r <= 0 . 5 ) sp in [ x ] [ y ] = 1 ;i f ( r > 0 . 5 ) sp in [ x ] [ y ] = −1;
}}
}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm n e i b i n i t//// I n i t i a l i s i e r t das Nachbarfe ld − pe r i od i s c he R.B.//
void n e i b i n i t ( int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] ){
int xp ,xm, yp ,ym;
for ( int x = 0 ; x < l l ; x++ ){
xp = x + 1 ;xm = x − 1 ;i f ( xp == l l ) xp = 0 ;i f ( xm == −1 ) xm = l l − 1 ;
28
for ( int y=0; y < l l ; y++ ){
yp = y + 1 ;ym = y − 1 ;i f ( yp == l l ) yp = 0 ;i f ( ym == −1 ) ym = l l − 1 ;
xneib [ 0 ] [ x ] [ y ] = x ;yneib [ 0 ] [ x ] [ y ] = yp ;xneib [ 1 ] [ x ] [ y ] = xp ;yneib [ 1 ] [ x ] [ y ] = y ;xneib [ 2 ] [ x ] [ y ] = x ;yneib [ 2 ] [ x ] [ y ] = ym;xneib [ 3 ] [ x ] [ y ] = xm;yneib [ 3 ] [ x ] [ y ] = y ;
}}
}
Hinzugekommen sind nun folgende Funktionen:
• neibinit: Diese Funktion initialisiert die Nachbarfelder. Sie gibt keinen Wert zuruck unddefiniert die jeweiligen Nachbarn zu einem Feld durch den array xneib bzw. yneib.
• update: Dieser Programmteil entspricht der Equilibrierung, d.h. zeichnet dafur verantwort-lich, dass das System auf die gewunschte Weise verteilt ist. Es updated das System nsweepsmal ehe letztlich die Konfiguration geschrieben wird.
Nachfolgend sind verschiedene Plots dargestellt, die mit xmgrace visualisiert wurden. Verschie-dene Werte fur die Kopplung j, (also die Temperatur) wurden gewahlt: j=0.20, j=0.43 (nahePhasenubergang) , j=0.60.
Spinkonfiguration bei hoher Temperatur, j=0.20100 x 100
Aus der Graphik geht hervor dass die Spins bei j=0.20, also bei hoher Temperatur, annaherndgleichverteilt sind, dh. etwa gleich viele Spins sehen nach oben wie nach unten.
29
Spinkonfiguration bei T klein, j=0.6100 x 100
In dieser Graphik betrachten wir das System bei j=0.60, dh. bei tiefer Temperatur. Beinahe alleSpins haben dieselbe Ausrichtung, nur einige wenige sehen in die andere Richtung.
Spinkonfiguration nahe Tc, j=0.43100 x 100
In der Graphik mit j=0.43 befinden wir uns nahe am Phasenubergang. Es bilden sich Cluster aus,deren Große auf allen Skalen ansiedelt.Um nun den letzten Schritt zu tun, dh. die Auswertungder Magnetisierung in Abhangigkeit von j (bzw. der Temperatur) zu betrachten, mussen wir unserProgamm nocheinmal adaptieren.
30
2.8.3 Der letzte Schritt
Nachstehend findet sich der Programmcode fur den letzten Teil der Implementierung, also dasvollstandige Programm.
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Globale Anweisungen
#include <i ostream>
#include <f stream>
#include <cmath>
using namespace std ;const int l l = 100 ;
// Prototypen
void n e i b i n i t ( int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] ) ;void f i l l s p i n s ( int sp in [ l l ] [ l l ] ) ;void update ( int nsweeps , int sp in [ l l ] [ l l ] , int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] , double j j ) ;double magnetizat ion ( int sp in [ l l ] [ l l ] ) ;
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Hauptprogtramm
int main ( ){
double mm = 0;double j j = 0 . 6 ;double j j 0 = 0 . 2 ;double dj = 0 . 0 2 ;int nj = 20 ;int nskip = 20 ;int nmeas = 1000;int nequi = 1000;int xneib [ 4 ] [ l l ] [ l l ] , yneib [ 4 ] [ l l ] [ l l ] ;int sp in [ l l ] [ l l ] ;
n e i b i n i t ( xneib , yneib ) ;f i l l s p i n s ( sp in ) ;
of s tream o u t f i l e ( ” con f i g . dat ” ) ;for ( int i j =0; i j <=nj ; i j++){update ( nequi , spin , xneib , yneib , j j ) ;mm = 0 ;j j = j j 0 + i j ∗dj ;cout << j j << endl ;
for ( int imeas =0; imeas < nmeas ; imeas++){
update ( nskip , spin , xneib , yneib , j j ) ;mm = mm + magnetizat ion ( sp in ) ;
}mm = mm / nmeas ;o u t f i l e << j j << ” ” << mm << endl ;}
cout << endl << ” Fe r t i g ! ” << endl << endl ;}
31
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm magnet izat ion//// Schr e i b t Konf igurat ion auf f i l e .
double magnetizat ion ( int sp in [ l l ] [ l l ] ){
double m;for ( int x=0; x< l l ; x++ ){
for ( int y=0; y< l l ; y++ ){
m = m + spin [ x ] [ y ] ;}
}
m = abs ( m )/( l l ∗ l l ) ;return m;
}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm update//// Macht einen nsweeps sweep .
void update ( int nsweeps , int sp in [ l l ] [ l l ] , int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] , double j j ){double rho ;for ( int count = 0 ; count < nsweeps ; count ++){
for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
rho = exp ( −2∗ j j ∗ sp in [ x ] [ y ]∗ ( sp in [ xneib [ 0 ] [ x ] [ y ] ] [ yneib [ 0 ] [ x ] [ y ] ]+ sp in [ xneib [ 1 ] [ x ] [ y ] ] [ yneib [ 1 ] [ x ] [ y ] ]+ sp in [ xneib [ 2 ] [ x ] [ y ] ] [ yneib [ 2 ] [ x ] [ y ] ]+ sp in [ xneib [ 3 ] [ x ] [ y ] ] [ yneib [ 3 ] [ x ] [ y ] ] ) ) ;
double r ;r = rand ( ) / (RANDMAX + 1 . ) ;i f ( r <= rho ){sp in [ x ] [ y ] = −sp in [ x ] [ y ] ;}
}}
}
}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm f i l l s p i n s//// I n i t i a l i s i e r t d i e Spins .
void f i l l s p i n s ( int sp in [ l l ] [ l l ] ){
for ( int x=0; x< l l ; x++){
for ( int y=0; y< l l ; y++){
double r ;r = rand ( ) / (RANDMAX + 1 . ) ;
32
i f ( r <= 0 . 5 ) sp in [ x ] [ y ] = 1 ;i f ( r > 0 . 5 ) sp in [ x ] [ y ] = −1;
}}
}
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−//// Unterprogramm n e i b i n i t//// I n i t i a l i s i e r t das Nachbarfe ld − pe r i od i s c he R.B.
void n e i b i n i t ( int xneib [ 4 ] [ l l ] [ l l ] , int yneib [ 4 ] [ l l ] [ l l ] ){
int xp ,xm, yp ,ym;
for ( int x = 0 ; x < l l ; x++ ){
xp = x + 1 ;xm = x − 1 ;i f ( xp == l l ) xp = 0 ;i f ( xm == −1 ) xm = l l − 1 ;
for ( int y=0; y < l l ; y++ ){
yp = y + 1 ;ym = y − 1 ;i f ( yp == l l ) yp = 0 ;i f ( ym == −1 ) ym = l l − 1 ;
xneib [ 0 ] [ x ] [ y ] = x ;yneib [ 0 ] [ x ] [ y ] = yp ;xneib [ 1 ] [ x ] [ y ] = xp ;yneib [ 1 ] [ x ] [ y ] = y ;xneib [ 2 ] [ x ] [ y ] = x ;yneib [ 2 ] [ x ] [ y ] = ym;xneib [ 3 ] [ x ] [ y ] = xm;yneib [ 3 ] [ x ] [ y ] = y ;
}}
}
Das Herzstuck des Codes bildet das Unterprogramm magnetization. Die Funktion writeconfig wur-de entfernt. Außerdem sind einige Variablen hinzugekommen. Das Programm ist nun in der Lage,den thermischen Erwartungswert fur die Magnetisierung zu berechnen. magnetization berechnetdabei die jeweilige Magnetisierung einer Konfiguration. Im Hauptprogramm wird nach der Equili-brierung durch update eine Schleife betrieben, die den Kopplungsparameter j von 0.20 bis 0.60 inSchritten von 0.02 erhoht. Die Summationsvariable mm wird auf Null gesetzt, und die Funktionmagnetization wird aufgerufen. Sie liefert einen Ruckgabewert des Typs double. Mithilfe dieserFunktion und einer weiteren Schleife, die die Berechnung des Mittelwertes erlaubt, gelangt manschließlich an den Mittelwert, welcher noch durch die Zahl der Schleifendurchlaufe dividiert werdenmuss.Das Programm wurde nun fur unterschiedliche Gittergroßen durchlaufen. Konkret wurden Gitter-abmessungen von 20x20, 40x40, 60x60, 80x80 sowie 100x100 gerechnet. Ein Plot mit der exaktenLosung des Problems (unendliches Gitter, Vgl. Abschnitt 2.3.1) wurde bereitgestellt, die erhalte-nen Werte wurden wieder mit xmgrace visualisiert.
33
0.2 0.3 0.4 0.5 0.6 0.7 0.8J
0.0
0.5
1.0
<M
>
20x20 Gitter40x40 Gitter60x60 Gitter80x80 Gitter100x100 Gitter
Magnetisierung als Funktion von j
Die schwarze Kurve in dem Plot ist die Idealkurve des unendlichen Gitters. Das Konvergenzver-halten der Graphen unterschiedlicher Gittergroßen an die analytische Losung ist deutlich zu sehen.
34
2.8.4 Z2-Flip
Wie ja bereits in Abschnitt 2.7.1 angemerkt kann es aufgrund der Struktur der Wahrscheinlichkeitzum Flippen der Spins kommen. Dieses Verhalten wurde auf einem 8x8 Gitter untersucht, einentsprechender Plot wurde erstellt. Betrachtet wird der Erwartungswert der Magnetisierung alsFunktion der sweeps. Eine solch spontanes Umkippen der Spins ist in folgender Graphik darge-stellt, die wieder mit xmgrace erstellt wurde:
100 200 300 400sweeps
-1.5
-1
-0.5
0
0.5
1
1.5
< M
>
8² Gitter, j=0.46
35
