Physik Per Computer
Physik Per Computer
Der Computer ist heutzutage ein wichtiges Werkzeug der Physik. Die Erfassung und
Auswertung umfangreicher Meßdaten und die Steuerung komplexer Experimente
sind ohne den Einsatz von elektronischen Rechnern kaum mehr vorstellbar. Auch in
der theoretischen Physik hat sich der Computer von einer reinen Rechenmaschine
zu einem umfassenden Hilfsmittel gewandelt. Graphische Darstellungen, numeri-
sche und algebraische Lösungen von Gleichungen und extensive Simulationen von
mikroskopischen Modellen sind wichtige Methoden zur Erforschung physikalischer
Gesetzmäßigkeiten geworden.
Aber der Computer ist nicht nur ein Werkzeug, sondern er liefert der Physik auch
neuartige Betrachtungsweisen, aus denen neue Fragestellungen resultieren. Früher
haben Physiker die Natur hauptsächlich mit Differentialgleichungen beschrieben,
heute werden dazu auch diskrete Algorithmen benutzt. Für manche, scheinbar ein-
fache physikalische Modelle gibt es bisher nur eine numerische Antwort. Wir ken-
nen universelle Gesetzmäßigkeiten, die ein Schüler auf dem Taschenrechner nach-
vollziehen kann, für die es aber (noch?) keine analytische Theorie gibt. Darüber
hinaus erschließt der Computer der Physik neue Disziplinen: Neuronale Netzwer-
ke, kombinatorische Optimierung, biologische Evolution, fraktale Strukturbildung
und Synergetik sind nur einige Schlagworte aus dem wachsenden Gebiet komplexer
Systeme.
Fast jeder Diplomand und Doktorand der Physik nutzt also irgendwann den Com-
puter. Dennoch ist der Einsatz des Rechners in der Lehre und die Ausbildung am
Rechner heute noch keinesfalls selbstverständlich, sondern eher die Ausnahme. Die
Literatur zu diesem Gebiet ist dementsprechend spärlich. Diese Lücke zu füllen,
dazu möchte unser Lehrbuch ein wenig beitragen.
Es entstand aus Vorlesungen an der Universität Würzburg für Studierende der
Physik ab dem 5. Semester, also nach den Grundvorlesungen der theoretischen Phy-
sik, und es soll der Ergänzung der herkömmlichen Physikvorlesungen dienen, in
denen die Möglichkeiten des Computereinsatzes bisher wenig genutzt werden. Wir
möchten die Leser dieses Buches anleiten, physikalische Fragestellungen mit dem
Rechner zu beantworten. Erfahrungen mit Computern und deren Sprachen sind er-
wünscht, aber nicht notwendig, denn wir wollen eine Einführung geben und erste
VI Vorwort
Schritte mit Rechnern und Algorithmen erklären. Dieses Buch enthält keine Details
über numerische Mathematik, es bietet keinen Kurs über Programmiersprachen und
es lehrt keine fortgeschrittenen Methoden der computerorientierten theoretischen
Physik. Aber es führt in eine Vielzahl zum Teil sehr aktueller physikalischer Pro-
bleme ein und versucht, diese mit einfachen Algorithmen zu lösen.
Ein Ziel unseres Buches ist, Anregungen zum eigenen Programmieren zu geben.
Obwohl fertige Programme beiliegen, sind diese nicht als benutzerfreundliche Ex-
perimentierumgebungen gedacht. Wir hoffen, daß man aus ihnen lernen kann, und
ermuntern unsere Leser, sie zu modifizieren, oder besser noch, sie neu und effizi-
enter zu schreiben. Manchmal ergeben sich beim Probieren und aus vermeintlichen
Fehlversuchen sogar neue Fragestellungen. Man sollte aber die Physik und die zu
untersuchenden Gesetzmäßigkeiten nicht aus dem Auge verlieren. Übungsaufgaben
zu jedem Abschnitt ergänzen diese Einführung.
Als Programmiersprachen haben wir Mathematica und C gewählt. Beides sind
moderne Sprachen, die besonders an heutige Arbeitsplatzrechner (z. B. RISC-Work-
stations unter UNIX) angepaßt sind. Diese Auswahl ist subjektiv und keinesfalls
notwendig zur Bearbeitung der Probleme dieses Lehrbuchs. Bei rechenzeitintensi-
ven Computersimulationen wird häufig die Sprache FORTRAN gewählt, deren neue
Version FORTRAN90 Elemente der Sprache C übernommen hat. Für die Compu-
teralgebra ist auch MAPLE recht beliebt. Eine Reihe anderer Programmiersprachen
wäre also ebenso geeignet. Alle unsere Programme laufen nicht nur auf schnellen
Workstations, sondern auch unter DOS oder LINUX auf einem PC.
Von vielen Kollegen und Studenten haben wir Anregungen erhalten, ihnen dan-
ken wir hiermit sehr herzlich. Wir möchten erwähnen: M. Biehl, H. Dietz, A. En-
gel, A. Freking, Th. Hahn, W. Hanke, G. Hildebrand, A. Jung, A. Karch, U. Krey,
J. Nestler, M. Opper, M. Schreckenberg und D. Stauffer. Ganz besonderen Dank
aber möchten wir drei Personen aussprechen: Martin Lüders hat das Programmpa-
ket Xgraphics entwickelt, Martin Schröder hat den Abschnitt über UNIX verfaßt
und Ursula Eitelwein hat dieses Buch in LATEXgeschrieben.
W. Kinzel
G. Reents
Inhaltsverzeichnis
Einleitung 1
1 Mathematica-Funktionen 3
1.1 Funktion versus Prozedur . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Nichtlineares Pendel . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Fouriertransformation . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Daten glätten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5 Nichtlinearer Fit . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6 Multipol-Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . 32
1.7 Wegintegrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.8 Maxwell-Konstruktion . . . . . . . . . . . . . . . . . . . . . . . . 41
1.9 Beste Spielstrategie . . . . . . . . . . . . . . . . . . . . . . . . . 45
2 Lineare Gleichungen 51
2.1 Quantenoszillator . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.2 Elektrisches Netzwerk . . . . . . . . . . . . . . . . . . . . . . . . 56
2.3 Kettenschwingungen . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.4 Hofstadter-Schmetterling . . . . . . . . . . . . . . . . . . . . . . 69
2.5 Hubbard-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3 Iterationen 89
3.1 Populationsdynamik . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.2 Frenkel-Kontorova-Modell . . . . . . . . . . . . . . . . . . . . . 101
3.3 Fraktales Gitter . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
3.4 Neuronales Netzwerk . . . . . . . . . . . . . . . . . . . . . . . . 117
4 Differentialgleichungen 127
4.1 Runge-Kutta-Methode . . . . . . . . . . . . . . . . . . . . . . . . 127
4.2 Chaotisches Pendel . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.3 Stationäre Zustände . . . . . . . . . . . . . . . . . . . . . . . . . 144
VIII Inhaltsverzeichnis
5 Monte-Carlo-Simulationen 173
5.1 Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
5.2 Fraktale Aggregate . . . . . . . . . . . . . . . . . . . . . . . . . . 180
5.3 Perkolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.4 Polymer-Ketten . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
5.5 Ising-Ferromagnet . . . . . . . . . . . . . . . . . . . . . . . . . . 210
5.6 Kürzeste Rundreise . . . . . . . . . . . . . . . . . . . . . . . . . 221
E Programme 272
Dieses Lehrbuch soll den Leser an die Lösung physikalischer Fragestellungen mit
dem Computer heranführen. Die Beispiele sind möglichst einfach gehalten, um sie
mit wenig Aufwand algebraisch, numerisch und graphisch umzusetzen. Die Anwen-
dung von Computern lernt man hauptsächlich durch eigene Arbeit – ohne ständiges
Ausprobieren, ohne spielerische Neugier und ohne den Wunsch zu forschen ist die-
ses Buch nur von geringem Nutzen.
Fast jeder Abschnitt enthält drei Teile mit den folgenden Überschriften: Physik,
Algorithmus und Ergebnisse. Im Physik-Teil wird das Problem formuliert und das
Modell eingeführt. Im mittleren Abschnitt wird das Computerprogramm beschrie-
ben, das die Fragestellungen aus dem ersten Teil lösen soll. Dabei werden nur die
wesentlichen Befehle erklärt, damit der Leser selbst versuchen kann, das Programm
zu vervollständigen. Man kann aber auch den kompletten Computercode aus dem
Anhang entnehmen und damit weiterarbeiten; der Quell- und der ausführbare Code
sind auf der beiliegenden Diskette vorhanden. Im Ergebnisteil werden dann einige
Resultate der Computerrechnungen, meist in Graphikform, erläutert.
Wir haben bewußt eine große Zahl von Beispielen – z.T. auch aus der aktuellen
Forschung – behandelt. Die Darstellung der theoretischen Grundlagen kann deshalb
nur als erste Einführung angesehen werden. Viele Abschnitte könnten zu ganzen
Vorlesungen ausgearbeitet werden, wir müssen auf die weiterführende Literatur ver-
weisen. Dazu haben wir zu jedem Problem einige von uns ausgewählte Lehrbücher
oder Originalliteratur zitiert. Die Auswahl dieser Zitate ist naturgemäß sehr sub-
jektiv und erhebt keinerlei Anspruch auf Vollständigkeit. Am Schluß eines jeden
Abschnittes wird eine Übungsaufgabe gestellt.
Die PC-Programme sind auf 386-Rechnern mit Koprozessor und VGA-Karte ge-
laufen. Dies gilt auch für die Mathematica-Beispiele (Version 2. 1). Auf dem PC
wurde für die C-Programme Turbo C (2.0) von Borland verwendet. Damit kann
man bequem Programme entwickeln und Graphik erzeugen.
Von allen Programmen gibt es auch Versionen für Workstations, getestet sind sie
auf solchen vom Typ Hewlett Packard HP 9000 Serie 700. Leider ist es dort sehr
viel schwieriger als auf dem PC, Graphik zu erzeugen. Schon um nur eine Linie
oder einen Kreis auf den Bildschirm zu zeichnen, müssen Displays gesetzt, Fenster
2 Einleitung
Auf der untersten Ebene der Hierarchie der Programmiersprachen arbeitet der Com-
puter kleine Päckchen von An-Aus-Daten (= Bits) schrittweise ab. Jedes Datenpäck-
chen gibt Anweisungen an elektronische Schalter, wodurch die Ergebnisse von ele-
mentaren Rechenoperationen in Datenspeicher geschrieben und neue Daten gelesen
werden. Auf dieser Ebene des schrittweisen Abarbeitens elementarer Befehle in Bit-
form kann der Mensch allerdings kaum schwierigere Probleme formulieren.
Komplexe Algorithmen sollten daher strukturiert sein. Dementsprechend besteht
eine höhere Programmiersprache aus Funktionen oder Modulen. Um ein Programm
überschaubar zu halten, sollte man Module verwenden, die vom Groben zum Fei-
nen gegliedert sind. Ein guter Programmierstil wird in der Regel mehrere Ebenen
davon benutzen, mit dem Vorteil, daß solche Programme leichter modifiziert werden
können, weil eventuell nur einzelne Funktionen ausgetauscht werden müssen.
Mathematica ist eine Programmiersprache, die eine große Menge an Funktionen
enthält, deren Aufruf aber leichtfällt, da die meisten Parameter Voreinstellungen be-
sitzen und nicht unbedingt angegeben werden müssen. Selbst jede Zeile, die man
in Mathematica eingibt, kann als eine Funktion betrachtet werden, die sofort aus-
geführt wird und für alle folgenden und sogar vorherigen Befehle eine Rolle spielt.
In der Hierarchie der Computersprachen ist Mathematica daher in diesem Sinne
ganz oben anzusiedeln.
Dagegen sind C, FORTRAN, Pascal und Basic zwar ebenfalls höhere Program-
miersprachen mit numerischen und graphischen Funktionen, und schließlich ist Ma-
thematica in C geschrieben, aber der Aufwand, um sich z. B. schnell einmal den
Graphen einer Besselfunktion im Komplexen anzuschauen, ist bei diesen Sprachen
wesentlich größer als bei Mathematica.
Dieses Kapitel soll in die Nutzung von Mathematica-Funktionen einführen. An
einfachen Beispielen werden folgende Anwendungen vorgestellt: elliptische Inte-
grale, Reihenentwicklung, Fouriertransformation, 2 -Verteilung, 3D-Graphik, Vek-
tor-Multiplikation und -Integration, Bestimmung von Nullstellen nichtlinearer Glei-
chungen und lineares Optimieren.
4 1 Mathematica-Funktionen
#include <stdlib.h>
#include <time.h>
main()
{
double average(double *,long), dataset[LIMIT];
clock_t start,end;
long i;
for (i=0;i<LIMIT;i++) dataset[i]=(double)rand()/RAND_MAX;
start=clock();
printf(" average = %f\n",average(dataset,LIMIT));
end=clock();
printf("time= %lf\n",(double)(end–start)/CLOCKS_PER_SEC);
}
Beachten Sie die Unterschiede zwischen Mathematica und C. In C muß alles de-
klariert werden: Bibliotheksroutinen in den Kopfdateien <name.h> und eigene
Variable und Funktionen mit int, char, float, double usw. C benötigt ei-
ne Folge von Anweisungen mit klar definiertem Hauptprogramm und Funktionen,
während Mathematica immer versucht, alle Symbole mit vorhandenen Definitionen
auszuwerten. C ist maschinennah, mit Vor- und Nachteilen. So wird an die Funktion
average die Maschinenadresse des Feldes dataset übergeben, insbesondere ist
dataset ein Zeiger (=Adresse) auf das Feld, und die einzelnen Werte des Feldes
werden mit dataset[0], ..., dataset[999999] angesprochen. Zeiger wer-
den mit * deklariert, also double *data bedeutet, daß data eine Adresse auf
eine double-Variable enthält. Vorsicht: dataset[1000000] ist irgend etwas
6 1 Mathematica-Funktionen
Literatur
B.W. Kernighan, D.M. Ritchie, Programmieren in C, Carl Hanser Verlag, 1990.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.
Physik
Wir beginnen mit dem physikalischen Modell: Eine punktförmige Masse m an ei-
nem masselosen, starren Faden der Länge l schwingt im Schwerefeld. '(t) sei der
1.2 Nichtlineares Pendel 7
Winkel der Auslenkung aus der Ruhelage zur Zeit t, die Reibung sei vernachlässigt.
Nach den Gesetzen der Mechanik ist die Energie E des Pendels konstant, also gilt
wobei '0 der Maximalausschlag mit '_0 = 0 sein soll und '_ = d' dt die Winkel-
geschwindigkeit ist. Aus dieser Gleichung kann man '(t) mit einem kleinen Trick
gewinnen: Man separiert t und ', indem man (1.1) erst nach d'
2
dt und dann nach
dem Differential dt auflöst. Für eine Halbperiode, in der ' mit t zunimmt, erhält
man s
dt = 2lg pcos 'd' cos ' : (1.2)
0
Bei passender Wahl des Zeitnullpunktes ( '(0) = 0; '_ (0) > 0 ) ergibt sich hieraus
durch Integration:
s Z' 0
t(') = 2g l pcos 'd'
0 cos '0 : (1.3)
0
Die Schwingungsdauer T ist offensichtlich viermal die Zeit, die das Pendel bis zum
Maximalausschlag '0 braucht,
T = 4 t('0 ) : (1.4)
Da der Integrand von (1.3) für '0 ! '0 divergiert, ist es sinnvoll, die Substitution
Die Funktion K heißt vollständiges elliptisches Integral erster Art. Sowohl F als
auch K sind in Mathematica vorhanden.
Für kleine Auslenkungen ' ist die potentielle Energie näherungsweise quadra-
tisch. Bekanntlich ist dann die Kraft linear in ', und die Lösung der Bewegungs-
p
gleichung ist eine Sinusschwingung mit Schwingungsdauer T = 2 l=g . Mit
größerem Ausschlag '0 wird die Kraft eine nichtlineare Funktion von ', und T
hängt von '0 ab.
Wir wollen den Einfluß der Nichtlinearität studieren. Um verschiedene Kurven
'(t) vergleichen zu können, skalieren wir ' mit '0 und t mit T . Außerdem be-
trachten wir im Phasenraumdiagramm '_ gegen ' für verschiedene Energien E .
Die Entstehung höherer harmonischer Schwingungen mit wachsender Nichtlinea-
rität wird durch eine Fouriertransformation sichtbar. Schließlich wollen wir T nach
der Größe sin2 '20 entwickeln, die ein Maß für die Nichtlinearität ist.
Algorithmus
Die Funktionen K (k ) und F ( ; k) stehen in Mathematica zur Verfügung und wer-
den aufgerufen als
EllipticK[k2] und EllipticF[ ,k2]
Man muß auf die Argumente achtgeben, weil es diesbezüglich leider mehrere ge-
bräuchliche Konventionen gibt. Es gilt also K (k ) = EllipticK[k2] und ent-
sprechend für die anderen elliptischen Integrale. Die Umlaufzeit erhält man nach
(1.7) einfach mit
p
T[phi0 ] = 4 EllipticK[Sin[phi0/2]ˆ 2]
wobei wir l=g = 1 gesetzt haben. Der Befehl Plot zeichnet die Umlaufzeit als
Funktion von '0 :
Plot[ T[phi0], fphi0, g
0, Pi , PlotRange –> f0,30g ]
Da T für '0 ! divergiert, sollte man PlotRange setzen und sich nicht daran
stören, daß Mathematica vor T ( ) warnt.
t(') erhält man mit EllipticF nach (1.6). Wir wollen jedoch die Umkehr-
funktion '(t) berechnen. Aber auch diese Funktionen sind vorhanden; es gilt (wie-
p
der mit l=g = 1)
psi[t_,phi0_]=JacobiAmplitude[t, Sin[phi0]ˆ2] bzw.
sinuspsi[t_,phi0_]=JacobiSN[t, Sin[phi0]ˆ2]
Nun ersetzen wir mit (1.5) die Variable durch ', skalieren ' mit '0 und t mit T
(wir definieren x = t=T ) und erhalten schließlich die skalierte Funktion
1.2 Nichtlineares Pendel 9
phiscal[x_,phi0_]:=
2 ArcSin[Sin[phi0/2] sinuspsi[x T[phi0],phi0]]/phi0
Ergebnisse
Wir haben untersucht, wie sich die Nichtlinearität, gemessen durch den Maximal-
ausschlag '0 , auf die Bewegung des Pendels auswirkt. Bild 1.1 zeigt die Umlauf-
zeit T als Funktion des Maximalausschlages '0 . Das Pendel braucht eine unendlich
10Pi
8Pi
6Pi
T
4Pi
2Pi
0
1.1 Periodendauer T als Funktion des
0 Pi/4 Pi/2 3Pi/4 Pi
phi0 Maximalausschlages '0 .
0.5
phi/phi0
6
Abs[b(s)]
Das Wechselspiel zwischen Auslenkung ' und Winkelgeschwindigkeit '_ kann man
im Phasenraum ('; '_ ) deutlich machen; dabei wird die Zeit t eliminiert. Bild 1.4
zeigt solche Kurven im Phasenraum für verschiedene Energien E . Für kleine '0
3
1
phidot
-1
-2
erhält man einen Kreis, der sich mit wachsender Energie verformt. Für E > mgl
12 1 Mathematica-Funktionen
schlägt das Pendel über, es bewegt sich nur noch in eine Richtung und hat eine
6
Winkelgeschwindigkeit '_ = 0 auch am oberen Umschlagpunkt.
Mit dem Befehl
tseries = 4 Integrate[g,{psi,0,Pi/2}] /. m –> Sin[phi0/2]ˆ2
erhält man die symbolische Entwicklung von T nach sin2 ('0 =2). Mathematica pro-
duziert die folgende etwas unübersichtliche Bildschirmausgabe:
phi0 2 phi0 4 phi0 6
Pi Sin[––––] 9 Pi Sin[––––] 25 Pi Sin[––––]
2 2 2
2 Pi + ––––––––––––– + ––––––––––––––– + –––––––––––––––– +
2 32 128
phi0 14 phi0 16
184041 Pi Sin[––––] 41409225 Pi Sin[––––]
2 2
> ––––––––––––––––––––– + ––––––––––––––––––––––– +
2097152 536870912
phi0 18 phi0 20
147744025 Pi Sin[––––] 2133423721 Pi Sin[––––]
2 2 phi0 2 11
> –––––––––––––––––––––––– + ––––––––––––––––––––––––– + O[Sin[––––] ]
2147483648 34359738368 2
Wir werden deshalb in Zukunft bei solchen Ergebnissen die entsprechende TEX–
Form angeben, die man sich übrigens mit dem Befehl TeXForm von Mathematica
erzeugen und mit TEX oder LATEX übersetzen lassen kann:
sin2 '2
0
9 sin4 '2 25 sin6 '2 1225 sin8 '2
0 0 0
2 + 2 + 32 + 128 + 8192 +
3969 sin10 ' 53361 sin12 '2 184041 sin14 '2
0 0 0
+ 536870912 2 + 2147483648
2133423721 sin20 '2
+ O(sin2 '20 ) :
0 11
+ 34359738368
1.3 Fouriertransformation 13
Ein Vergleich mit dem exakten T ('0 ) zeigt, daß der Fehler dieser Näherungslösung
höchstens im Prozentbereich liegt, solange '0 kleiner als 120 ist, dann aber deut-
lich ansteigt.
Übung
a) Berechnen Sie die Umlaufzeit T als Funktion von '0 einmal mit EllipticK
und zum anderen mit NIntegrate und vergleichen Sie die Rechenzeiten und
die Genauigkeiten.
b) Welchen Anteil haben die Oberschwingungen in '(t) als Funktion der maxima-
b
len Auslenkung '0 ( = wachsender Nichtlinearität )? Berechnen Sie die Fourier-
j jj j
koeffizienten bs = b2 als Funktion von '0 .
Start: a0 = 1 ; b0 = cos ;
p
Iteration: ai+1 = 2 (ai + bi ) ; bi+1 = ai bi ;
1
Stop: ja n bn < " ; j
Prüfe: EllipticK[sin2 ] ' 2a .
n
Literatur
G. Baumann, Mathematica in der Theoretischen Physik, Springer Verlag, 1993.
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
1.3 Fouriertransformation
Erstaunlich oft kann man physikalische Probleme in guter Näherung durch lineare
Gleichungen beschreiben. In solchen Fällen steht dem Forscher ein mächtiges Werk-
zeug zur Verfügung: die Zerlegung eines Signals in eine Summe von harmonischen
Schwingungen. Dieses Werkzeug, das mathematisch gut erforscht ist, wird Fou-
riertransformation genannt. Mit komplexwertigen Funktionen kann man die Trans-
formation besonders kompakt formulieren. Fast jedes Signal, selbst ein unstetiges,
kann als Grenzwert einer Summe von stetigen Schwingungen dargestellt werden.
Eine wichtige Anwendung der Fouriertransformation ist die Lösung linearer Diffe-
rentialgleichungen. Nicht nur in der Physik, sondern auch in der Bildverarbeitung,
14 1 Mathematica-Funktionen
der Signalübertragung, der Elektronik und in vielen anderen Gebieten spielt die Zer-
legung einer Funktion in einfache Schwingungen eine große Rolle.
Häufig stehen Daten nur zu diskreten Zeit- oder Raumpunkten zur Verfügung. In
diesem Fall sind die numerischen Algorithmen der Fouriertransformation besonders
schnell. Wegen dieses Vorteils wollen wir hier die Fouriertransformation diskreter
Daten untersuchen. In den folgenden Abschnitten werden wir sie zur Glättung von
Daten, zur Berechnung elektrischer Schaltkreise und zur Analyse von Gitterschwin-
gungen benutzen.
Mathematik
Es sei ar ; r = 1; : : : ; N , eine Folge komplexer Zahlen. Dann ist deren Fourier-
transformierte die Folge bs ; s = 1; : : : ; N , mit
X
N
bs = p1 ar e2i(r 1)(s 1)=N : (1.8)
N r=1
Diese Formel hat den Vorteil, fast symmetrisch in ar und bs zu sein, denn die inverse
Transformation ist
X
N
ar = p1 bs e 2i(r 1)(s 1)=N : (1.9)
N s=1
Das Signal fa1; ::: ; aN g ist also in eine Summe von Schwingungen
cs (r) = pbs e i!s (r 1) (1.10)
N
mit den Frequenzen !s = 2 (s 1)=N zerlegt worden. bs = jbs jei's enthält
eine Amplitude und eine Phase. Beide Gleichungen (1.8) und (1.9) können auf alle
ganzen Zahlen r und s erweitert werden. Wegen exp(2ik ) = 1 für k Z sind 2
dann ar und bs periodisch in r bzw. s mit der Periode N :
so daß man in jeder Summe den Index r oder s über jedes Intervall der Länge N
laufen lassen kann. Die kleinste Frequenz der Schwingungen ist !2 = 2=N (= b
Wellenlänge“ N ), und alle anderen Frequenzen sind ganzzahlige Vielfache von
!2 . Die größte Frequenz ist !N = 2 NN 1 , denn cN +1 (r) hat wegen bN +1 = b1
”
dieselben Funktionswerte wie c1 (r ).
1.3 Fouriertransformation 15
Wenn alle Signalwerte ar reell sind, haben deren Fourierkoeffizienten bs die fol-
gende Symmetrie:
X
N
bs = p1 ar e 2i(r 1)(s 1)=N
N r=1
XN
= p1 ar e2i(r 1)( s+2 1)=N =b s+2 :
N r=1
Dabei bedeutet b das konjugiert Komplexe von b. Daraus folgt
bs = b s+2 = bN s+2 ; (1.12)
also sind nur die Werte b1 ; :::; bN=2+1 relevant, bN=2+2 bis bN sind redundant.
Eine nützliche Eigenschaft der Fouriertransformierten ergibt sich bei der Faltung
f g f g
zweier Folgen fr und gr . Bei dieser Operation werden die Folgenelemente fr
aufsummiert und dabei mit den gj gewichtet. Man kann dies als lokale Mittelung
interpretieren und auf diese Weise z. B. den Einfluß von Meßfehlern mathematisch
behandeln. Die Faltung ist folgendermaßen definiert:
X
N
hr = fr+1 j gj : (1.13)
j =1
~ s ; g~s und f~s . Fügt man
Die entsprechenden Fouriertransformierten seien die Folgen h
die Fourierentwicklungen
X
N
h~ s = p1 hr e2i(r 1)(s 1)=N ;
N r=1
X
N
gj = p1 g~ e 2i(m 1)(j 1)=N ;
N m=1 m
X
N
fr+1 j = p1 ~ fn e 2i(n 1)(r j )=N
N n=1
nach Gleichung (1.13) zusammen, ergibt sich
3 X
h~ = 1
s p g~ f~ e 2Ni [(r 1)(s 1) (m 1)(j 1) (n 1)(r j)] :
N r;j;m;n m n
Die Summen über r und j lassen sich mit
X
N
e2i lq=N = N q;kN ; k 2 Z ;
l=1
16 1 Mathematica-Funktionen
X
N
hr = g~s f~s e 2i(s 1)(r 1)=N : (1.15)
s=1
Wir werden die Faltung im nächsten Abschnitt zur Glättung von Meßdaten benut-
zen.
Algorithmus
In Mathematica erhält man eine Liste der Fourierkoeffizienten b1 , f : : :, g
bN mit
Fourier[ a1 , f : : :, aN ]g
und deren Inverses mit
InverseFourier[ b1, f : : :, g
bN ]
Trotzdem ist es vielleicht interessant, sich einmal den Algorithmus der schnellen
Fouriertransformation (Fast Fourier Transform = FFT) anzuschauen. Um alle Fol-
genglieder bs aus Gleichung (1.8) zu berechnen, kann man sich vorstellen, daß eine
Matrix der Form
W (N ) = 1 e2i(r 1)(s 1)=N
s;r p
N
a
mit einem Vektor = (a1 ; :::; aN ) multipliziert wird; dies erfordert N 2 Rechen-
schritte. Die FFT kann dies aber in einer Anzahl von Schritten berechnen, die nur
wie N log N anwächst. Dazu wird die Summe (1.8) in ungerade und gerade r -Werte
aufgespalten:
X
N=2 X
N=2
bs (N ) = Ws;2t 1(N ) a2t 1 + Ws;2t (N ) a2t
t=1 t=1
X
N=2 X
N=2
= p1 Ws;t(N=2) a2t 1 + e2i(s 1)=N p1 Ws;t(N=2) a2t
t=1 2 t=1 2
= p1 bus (N=2) + e2i(s 1)=N bg (N=2) :
s (1.16)
2
1.3 Fouriertransformation 17
f
Dabei sind bus (N=2) und bgs (N=2) die Fouriertransformierten der Koeffizienten a1 ;
g f g
a3; : : : ; aN 1 bzw. a2 ; a4 ; : : : ; aN , zweier Folgen also mit N=2 Gliedern (g
und u stehen für gerade und ungerade). Wiederholt man die Aufspaltung für je-
den der beiden Teile, so erhält man buu s ; bs ; bs und bs . Diesen Prozeß wiederholt
ug gu gg
man solange, bis noch jeweils ein ar -Wert übrig bleibt, der dann irgendeinem Wert,
z. B. bgugguguu
s entspricht; die letzte Zuordnung kann angegeben werden. Mit ei-
nigen zusätzlichen Buchhaltungstricks läßt sich damit ein schneller Algorithmus
programmieren.
Weil dieser Algorithmus nur dann optimal funktioniert, wenn N eine Potenz von
2 ist, gehen wir im folgenden davon aus, daß N von der Form N = 2j ist. Was die
Anzahl F (N ) der Rechenschritte betrifft, die benötigt wird, um die Fouriertransfor-
mation einer N -gliedrigen Folge zu berechnen, so liest man von Gleichung (1.16)
die folgende Rekursionsbeziehung ab:
F (N ) = 2 F (N=2) + k N : (1.17)
Der Term 2 F (N=2) ist unmittelbar klar wegen bus (N=2) und bgs (N=2). Der Index
s in Gleichung (1.16) läuft von 1 bis N , wobei anzumerken ist, daß wegen der
Periodizität mit N=2 die Werte von bus (N=2) und bgs (N=2) dabei zweimal durch-
laufen werden. Ein zu N proportionaler Anteil kommt hinzu, weil N Phasenfak-
toren e2i(s 1)=N zu berechnen sind und außerdem N Multiplikationen und Ad-
f g
ditionen auszuführen sind. Auch das Sortieren der ar in gerade und ungerade
kann man hier unterbringen. Es ist eine leichte Übung zu zeigen, daß F (N ) =
N [F (1) + k log2 N ] die Lösung der Rekursionsgleichung (1.17) ist, mit F (1) =
0 als Startwert also F (N ) = k N log2 N .
Anwendung
Als Beispiel wollen wir uns die Fouriertransformation eines Rechteckimpulses der
Breite 2 anschauen,
Die Funktion f sei zunächst im Intervall [ T2 ; T2 ] mit T2 > definiert und soll
periodisch mit der Periode T fortgesetzt werden. Deren Fourierentwicklung lautet
X
1
f (t ) = f~n ein!t (1.19)
n= 1
18 1 Mathematica-Funktionen
mit ! = 2T , wobei die f~n durch Integrale über f (t) bestimmt werden:
ZT=2
f~n = T1 f (t ) e in!t dt : (1.20)
T=2
Dieses Integral läßt sich für den Rechteckimpuls leicht ausführen, mit dem Ergebnis
n! ) :
f~n = T2 sin(n! (1.21)
Je nach Länge der Periode wird die Funktion sin(x)=x an verschiedenen Punkten
2n=T berücksichtigt, und die Koeffizienten f~n verschwinden, wenn 2n=T eine
ganze Zahl ist.
Nun tasten wir f (t) innerhalb einer Periode an N diskreten Werten tr = T=2+
f
r T=N ab, wenden Fourier auf die Folge der Zahlen ar = f (tr ) Nr=1 an und g
f g
erhalten deren Fouriertransformierte b1 ; b2 ; : : : ; bN . Wir wollen den Zusammen-
hang zwischen den exakten Fourierkoeffizienten f~n und den bs aus der diskreten
Fouriertransformation klären. Dazu ersetzen wir in Gleichung (1.8) die Funktions-
werte ar = f (tr ) durch die unendliche Fourierreihe (1.19) mit ! = 2T . Die r -
Summation ergibt Kronecker-Deltas, und für gerades N erhalten wir die folgende
X
Beziehung:
1
pbs = ei (N 2)(s 1)=N f~1 s+k N : (1.22)
N k= 1
Der Vergleich der Beträge liefert also:
X
1
pjbs j = f~1 s+k N : (1.23)
N k= 1
p
Weil f~n
j pj! 0 geht für n ! 1p j j
, ist bs = N f~1 s für s = 1; 2; : : : ; N2 .
j j
Ob bs = N < f~1 s oder bs = N > f~1 s gilt, wie sich also das sogenann-
j j j j j j j j
te aliasing auswirkt, läßt sich nicht generell beantworten. Es hängt von der Pha-
senbeziehung zwischen f~1 s und im wesentlichen f~1 sN ab. Gerade in dem hier
betrachteten Fall kann man durch Variation des Parameters =T in (1.18) sowohl
den einen als auch den anderen Fall realisieren. Bild 1.5 zeigt für N = 64 und
=T = 1=10 den Betrag von f~1 s als durchgezogene Linie und die Beträge der
p
bs = N als Punkte.
Die Rücktransformation von den bs -Koeffizienten zu den ursprünglichen Werten
ar = f (tr ) erfolgt mit Gleichung (1.9) und r = N tTr + 21 . Diese Gleichung gibt
die exakten Werte des Rechteckimpulses an den diskreten Stellen tr . Sie kann aber
1.3 Fouriertransformation 19
0.2
0.15
0.1
1.5 Kontinuierliche und dis-
krete Fouriertransformation
0.05 eines Rechteckimpulses.
Die durchgezogene Linie ist
0 jf~1 s als Funktion von s,
j
5 10 15 20 25 30 die Punkte sind die Werte
s j j 1
von bs N 2 :
auch als Näherung für die gesamte Funktion f (t) aufgefaßt werden, wenn tr durch
kontinuierliche t-Werte ersetzt wird. Bild 1.6 zeigt, daß dies kein gutes Ergebnis
liefert. Der Grund für die schlechte Qualität der Näherung ist der stark oszillatori-
sche Beitrag der hohen Frequenzen für s zwischen N=2 und N . Im mathematischen
Teil (1.11) wurde gezeigt, daß man die Summe über jedes beliebige Intervall der
1.25
1
1
0.8
0.75
0.5 0.6
0.25 0.4
0 0.2
-0.25 0
-0.5
-4 -2 0 2 4 -4 -2 0 2 4
1.6 Links die ungünstige und rechts die bessere Fortsetzung der diskreten Fourier-Rück-
transformation auf kontinuierliche t-Werte.
Länge N laufen lassen kann. Diese Freiheit nutzen wir, indem wir das Intervall
symmetrisch zum Ursprung legen und nur die kleinsten Frequenzen verwenden:
X
N=2
f (tr ) = p1 bs e 2i(r 1)(s 1)=N
N s= N=2+1
X
N=2
= p1 bs e 2i(r 1)(s 1)=N +
N s=1
20 1 Mathematica-Funktionen
X
N=2
+ p1 bs0 N=2 e
2i(r 1)(s0 N=2 1)=N
N s0=1
X
N=2
= p1 bs e 2i(r 1)(s 1)=N
N s=1
X
N=2
+ p1 bN=2 s0 +2 e
2i(r 1)(s0 N=2 1)=N :
N s0=1
Wird diese Version auf kontinuierliche t-Werte erweitert, so sieht man in Bild 1.6,
daß die Stufe wesentlich besser approximiert wird. Allerdings können die Sprung-
stellen des Rechteckimpulses f (t) nur durch starke Oszillationen auf beiden Seiten
dargestellt werden.
Übung
1. Spitzenspannung
Eine zeitabhängige Spannung wird an N = 64 diskreten Zeitpunkten abgeta-
stet und liefert die Werte U1 ; : : : ; UN . Die Fouriertransformierte davon sei die
f g j j
Folge b1 ; : : : ; bN mit dem Leistungsspektrum bs 2 = bN s+2 2 = 1 fürj j
f
s = 9; 10; : : : ; 17 und bs = 0 sonst. Damit das Spannungssignal U1; : : : ; UN g
reell ist, muß bN s+2 = bs gelten.
f g
a) Wie sieht das Spannungssignal U1 ; : : : ; UN aus, wenn die Fourierkoeffizi-
enten bs konstante Phasen haben, z. B. bs = 1; falls bs = 0 ? 6
b) Wählen Sie für die von Null verschiedenen bs zufällige Phasen, also bs = ei's
mit zufälligen 's . Wie sieht das Signal jetzt aus?
c) Wettbewerb: Gesucht sind die Phasen 's möglichst geringer Spitzenspan-
j j
nung, also min max Ur .
f's g r
2. Aperiodischer Kristall
Gegeben sei eine Kette von Atomen mit periodischer Anordnung
1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0:
Mit Röntgenstreuung erhält man den Betrag der Fourierkoeffizienten jbs j der
Funktion ar mit
1.4 Daten glätten 21
1 1 am Ort r
ar = 0
Atom
sonst
Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Paul L. DeVries, Computerphysik: Grundlagen, Methoden, Übungen, Spektrum
Akademischer Verlag, 1995.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.
wird als Gewicht eine Gaußglocke“ verwendet. Die Daten werden also mit einer
”
Gaußfunktion gefaltet, eine Glättungsoperation, bei der die Fouriertransformation
aus dem vorigen Abschnitt verwendet werden kann.
Physik
Es sei f (t) eine physikalische Größe, die an diskreten Zeitpunkten ti gemessen
wird. Die exakten Werte fi = f (ti ) sollen mit Zufallszahlen ri überlagert sein, so
daß die Meßdaten durch
gi = fi + ri ; i = 1; 2; 3; :::; N ; (1.24)
gegeben sind. Zu jedem i wollen wir neue Werte g i berechnen, die den Mittelwert
über eine Nachbarschaft von i bilden. Die Folge der g i ist dann viel glatter als
diejenige der gi -Werte und verdeutlicht besser die ursprüngliche Funktion f (t).
Zur Berechnung von g i könnte man nun einfach die gj -Werte in einem Inter-
vall um i aufsummieren. Aber es gibt eine bessere Methode, die keine zusätzlichen
unerwünschten Strukturen erzeugt. Dabei wird ein gewichtetes Mittel benutzt, das
j j
Nachbarn entsprechend ihrem Abstand j i vom Platz i berücksichtigt. Weit ent-
fernte Nachbarn werden nur schwach gewichtet. Als Gewichtsfunktion, auch Kern
genannt, wird eine Gaußglocke“ verwendet. Sei also kj eine solche Gewichtsfunk-
tion, die wie vorher auf die Werte j = 1; ::; N beschränkt wird. Die kj -Werte für
”
j < 1 werden durch die Symmetrie (1.11) ausgedrückt. Der Kern muß natürlich
X
normiert sein:
N
kj = 1 : (1.25)
j =1
Dann wird g r folgendermaßen konstruiert:
X
N
gr = gr j +1 kj ; (1.26)
j =1
g ist also die diskrete Faltung der Funktionen g und k, die schon in Abschnitt 1.3
besprochen wurde. Daher läßt sie sich einfach als Fouriertransformation darstellen,
X
N
gr = g~s k~s e 2i(s 1)(r 1)=N ; (1.27)
s=1
~ die Fouriertransformierten von g und k sind.
wobei g~ und k
1.4 Daten glätten 23
Algorithmus
Die Daten, die wir glätten wollen, erzeugen wir mit Mathematica als Liste data,
und zwar als Werte der Besselfunktion J1 (x), die durch Zufallszahlen verrauscht
wurden:
data=
Table[N[BesselJ[1,x]+0.2(Random[]–1/2)],{x,0,10,10/255}]
Allerdings stehen jetzt die größten Funktionswerte in der Mitte der Liste kern. Wir
müssen deshalb diese Liste zyklisch rotieren, so daß das Maximum an den Beginn
der Liste, also nach kern[[1]] verschoben wird. Dies geschieht mit dem Befehl
kern = RotateLeft[kern,127]
Nach (1.25) muß dieser Kern noch normiert werden:
kern = kern/Apply[Plus, kern]
Die geglätteten Daten (1.27) erhält man dann mit (1.14) ganz einfach durch den
Ausdruck
Sqrt[256] InverseFourier[Fourier[data] Fourier[kern]]
Das Produkt zweier Listen gibt dabei die Liste der Produkte der Elemente, ganz wie
Gleichung (1.27) verlangt.
Ergebnisse
Bild 1.7 zeigt das Ergebnis der Rechnungen für = 0:4 . Die geglätteten Daten
werden mit den verrauschten Daten und mit der ursprünglichen Funktion vergli-
chen. Die Kurve g i ist tatsächlich glatt und hat eine etwas kleinere Amplitude als
die Originalkurve. Das muß natürlich so sein, da die geglättete Kurve über die Nach-
barschaft mittelt und damit immer kleiner als die Maximalwerte der Daten ist. Ins-
besondere die bei Anwendung der Fouriertransformation stillschweigend vorausge-
setzte Periodizität der Daten führt hier zu einer Verfälschung an den Rändern.
Wir möchten erwähnen, daß genau dieses Beispiel im Abschnitt 3.8.3 des Mathe-
p
matica-Handbuches vorgeführt wird. Allerdings werden dort gleich mehrere Fehler
gemacht: Der Kern wird nicht normiert, der Faktor N wird bei der Faltung verges-
sen und als Kern wird nur die rechte Hälfte der Gaußglocke“ genommen. Während
”
24 1 Mathematica-Funktionen
0.6
0.4
0.2
0
1.7 Ausgangsfunktion (dünne
-0.2 Linie) und verrauschte Da-
ten (Punkte). Die Punkte der
-0.4 geglätteten Daten erscheinen
0 2 4 6 8 10 als fette Linie.
sich die ersten beiden Fehler bei den gewählten Parametern gerade aufheben, ver-
schiebt der dritte die geglättete Kurve etwas nach rechts zu größeren x-Werten hin.
Abschließend wollen wir noch darauf hinweisen, daß man bei der Mittelung vor-
sichtig sein muß. Wählt man die Breite des Kerns zu klein, dann erhält man of-
fenbar die ursprünglichen Daten ohne Glättung. Läßt man dagegen eine zu breite
Gewichtsfunktion zu, dann wird nicht nur die Streuung weggemittelt, sondern es
werden auch kurzwellige Strukturen in der ungestörten Funktion zerstört. Im Ex-
tremfall eines unendlich breiten Kerns besteht die geglättete Funktion nur aus einer
einzigen Konstanten. Die Breite der Gewichtsfunktion muß daher sorgfältig an die
zu glättenden Daten angepaßt werden.
Falls die Statistik der Streuung bekannt ist, so gibt es theoretische Ansätze, mit
denen man den optimalen Kern berechnen kann. Alternativ kann man auch eine
möglichst glatte Kurve durch die Daten legen, die den korrekten Wert von 2 hat
(siehe nächsten Abschnitt). Zum Beispiel kann man durch benachbarte Stützpunkte
Polynome legen und minimale Krümmungen fordern. Dieses umfangreiche Gebiet
der statistischen Analyse von Daten können wir hier nicht behandeln, sondern wir
müssen auf die entsprechenden Lehrbücher verweisen.
Übung
Das Ergebnis des oben vorgestellten Algorithmus zum Datenglätten hängt von der
gewählten Breite des Kerns ab. Berechnen sie die geglätteten Daten für einen
großen Bereich von -Werten. Wenn die Breite des Kerns kleiner als der Abstand
der Datenpunkte ist, erhält man fast die ursprünglichen Daten. Wenn dagegen die
Breite größer als das ganze x-Intervall ist, sind die geglätteten Punkte fast konstant.
Bestimmen sie einen -Wert, der Ihnen geeignet erscheint.
1.5 Nichtlinearer Fit 25
Literatur
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.
Theorie
f g a
Es seien N Datenpaare Yi ; ti gegeben, an die eine Modellfunktion g ( ; ti ) mit
a
unbekanntem Parametervektor mit M Komponenten angepaßt werden soll. Da-
bei soll bekannt sein, daß zu jedem ti die Daten Yi mit einem Fehler "i gemessen
werden, der im Mittel über viele Experimente verschwindet und eine Varianz i2
h i h i a
hat, also "i = 0 und "2i = i2 . Als besten“ Parametersatz definiert man
a
diejenigen Werte 0 , die die quadratische Abweichung 2 minimieren, wobei 2
”
26 1 Mathematica-Funktionen
a
Wenn g ( 0 ; ti ) ein angemessenes Modell ist und wenn die Fehler "i = Yi
a
g( 0 ; ti) unkorreliert und gaußverteilt sind, dann ist die Verteilung von 2 ( 0 ) be- a
kannt. Wie man durch häufige Wiederholung des Experiments überprüfen könnte,
ist die Wahrscheinlichkeit dafür, daß 2 kleiner ist als 20 , durch
1 Z
20 =2
PN M (0 ) =
2
N M e t tN 2
M 1 dt (1.29)
2 0
gegeben. Das Integral ist in der mathematischen Literatur als unvollständige Gam-
a
mafunktion ((N M )=2 ; 20 =2) bekannt. 2 ( 0 ) hat nur N M unabhängige
Variable, da M Freiheitsgrade durch die Minimumbedingung fixiert sind. Für große
Werte von N M gilt der zentrale Grenzwertsatz: 2 ist gaußverteilt mit Mittelwert
h i
2 = N M und Varianz 2(N M ).
Was bedeutet nun die 2 -Verteilung (1.29) für die Genauigkeit des Fits? Neh-
a
men wir an, unser Experiment gibt den Wert 20 = 2 ( 0 ) für das Minimum von
Gleichung (1.28). Ferner sei der Wert P (20 ) = 0:99. Das heißt, wenn das Modell
richtig ist, würde in 99% aller Experimente der Wert 2 kleiner als 20 sein. Das
könnten wir noch als gültigen Fit akzeptieren, denn wir können nicht ausschließen,
daß unser Experiment zu den 1% der Fälle gehört, bei denen 2 größer als 20 ist.
Wäre aber P = 0:9999, dann wäre unser Fit nur dann richtig, wenn er zu den
0:01% der Experimente mit 2 > 20 gehören würde. In diesem Fall würde man
sicher schließen, daß 20 viel zu groß ist und daß deshalb unsere Voraussetzungen,
insbesondere unser Modell, nicht richtig sind. Andererseits darf der Wert von 20
nicht zu klein sein, denn unsere Daten haben einen statistischen Fehler. Die Wahr-
scheinlichkeit, daß ein Experiment einen kleineren Wert als unser 20 hat, ist wieder
durch die Verteilung (1.29) gegeben. Das Intervall für den Wert von 20 , den wir
akzeptieren wollen, nennt man Vertrauensintervall. Wo wir die Schranke setzen,
bei 1% oder bei 0:01%, hängt von uns selbst und unserer Erfahrung mit ähnlichen
Problemen ab.
Nehmen wir nun an, daß wir mit der Qualität unseres Fits zufrieden sind, d.h.
a a
2 ( ) hat ein Minimum bei den Parametern 0 , und der Wert von 2( 0) liegt a
in unserem Vertrauensintervall. Könnten wir das Experiment mehrmals wiederho-
len, so würden wir selbstverständlich andere Meßfehler "i und damit einen anderen
a
Parametervektor 0 erhalten. Wir machen aber nur ein Experiment und wollen den-
a
noch aus den Daten den Fehler von 0 abschätzen.
1.5 Nichtlinearer Fit 27
Hierbei hilft uns wieder die 2 -Verteilung (1.29), denn Konturen im M -dimen-
a a
sionalen -Raum mit konstantem Wert von 2 ( ) sind ein Maß für den Fehler von
a 0 . Bei kleinen Abweichungen ja a j0 sind diese Konturen Ellipsoide mit M
a
Hauptachsen, deren Länge ein Maß dafür ist, wie weit man 0 in dieser Richtung
ändern kann, bis der Fit nicht mehr akzeptabel ist.
Diese Aussage kann man sogar quantifizieren. Dazu erzeugen wir uns künstli-
a
che Daten Yi , indem wir zum Modell g ( 0 ; ti ) einen gaußverteilten Fehler "i mit
h i a
"2i = i2 addieren: Yi = g( 0; ti ) + "i. Mit diesen Daten lassen wir wiederum die
Fitprozedur laufen, suchen also mit den simulierten Daten erneut ein Minimum 1 a
a a a
von 2 ( ). Mehrmals wiederholt liefert dies die Parametervektoren 1 ; 2 ; : : :, und
a
aus der Breite der Verteilung der Komponenten der k gewinnen wir Fehlerbalken
a
für die Fitparameter 0 .
Falls die Abweichung ja a j a
0 so klein ist, daß man die Entwicklung von ( )
2
a
(aus den experimentellen Daten) um 0 nach den quadratischen Gliedern abbre-
a a
chen kann, so läßt sich zeigen, daß die Größe = 2 ( ) 2 ( 0 ) wieder mit
der Verteilungsfunktion P aus (1.29) verteilt ist, in diesem Fall mit M statt mit
N M Freiheitsgraden. Fordern wir daher wie vorher, daß unser Fit zu den 99%
aller möglichen Fits beim korrekten Modell gehören soll, dann bestimmt die Un-
gleichung
a
PM (2 ( ) 2( 0)) 0:99a (1.30)
a
ein Gebiet mit erlaubten Werten von . Im Parameterraum sind die Gebiete mit
konstantem Ellipsoide. Die Projektion dieser (M 1)-dimensionalen Fläche auf
die Achse i gibt dann das Fehlerintervall für den Parameter ai .
Algorithmus
Auch beim nichtlinearen Fit ist es am einfachsten, die vorhandenen Mathematica-
a
Funktionen zu nutzen. Zum Auffinden des Minimums von 2 ( ) verwenden wir
die Funktion NonlinearFit im Paket Statistics’NonlinearFit’. Es
gibt dort verschiedene Möglichkeiten, Daten und Startbedingungen einzugeben, au-
ßerdem kann man die Methode der Minimumsuche ändern und sich die Zwischen-
a
ergebnisse anzeigen lassen. Natürlich kann man auch 2 ( ) selbst definieren und
mit FindMinimum den Wert 0 finden.a
Zur Erzeugung der Daten und als Modell wählen wir eine gedämpfte Sinus-
schwingung
f[t ]:= a Sin[om t + phi] Exp[–b t]
a f g
mit 4 Parametern = a, om, phi, b . Diese Schwingung wird für den Pa-
a f g
rametersatz = 1,1,0,0.1 an 11 Zeitpunkten ti gemessen, und die Daten
werden durch gleichverteilte Zufallszahlen verrauscht:
28 1 Mathematica-Funktionen
daten =
Table[{t,Sin[t]Exp[–t/10.]+0.4*Random[]–0.2}//N,
{t,0,3Pi,0.3Pi}]
Für die (nicht gaußverteilten) Fehler "i gilt
1 Z0:2 2 :
h"i i = 0; 2
i = h" 2 i =
i 0:4 x2 dx = 150
0:2
Die Suche nach dem Minimum wird erleichtert, wenn wir einen ungefähren Wert
a
von 0 angeben können. Nach dem Laden der benötigten Statistik-Pakete mit
Needs["Statistics’Master’"]
rufen wir die Minimumsuche auf:
NonlinearFit[daten,f[t],t,
{{a,1.1},{om,1.1},{phi,.1},{b,.2}},
ShowProgress–>True]
Auch die 2 -Verteilung ist in Mathematica vorhanden, und zwar im Paket
Statistics’ContinuousDistributions’. Sie hat den selbsterklärenden
Namen ChiSquareDistribution[..]. Als Argument ist die Zahl der Frei-
heitsgrade einzusetzen, die hier mit N = 11 Daten und M = 4 Parametern durch
N M = 7 bestimmt ist. Mit PDF erhält man die Dichte der Verteilung, also den
Integranden von P7 (20 ), Gleichung (1.29), während CDF das Integral, also P7 (20 )
selbst, ergibt. Mit Quantile wird die Funktion P7 (20 ) invertiert.
Quantile[ChiSquareDistribution[7], 0.95]
gibt also dasjenige 20 , für das in 95% aller Experimente der Wert von 2 kleiner
als 20 ist. Fixiert man zwei Parameter, so kann man für die übrigen zwei die Fläche
a a
in der Parameterebene, für die 2 ( ) = 2 ( 0 ) + ist, durch ContourPlot
darstellen.
Ergebnisse
Bild 1.8 zeigt die Funktion f[t] für a=1, om=1, phi=0 und b=0.1 und die
11 Daten, die aus f[t] mit dem Zufallsfehler "i gewonnen wurden. Nach dem
Start mit a=1.1, om=1.1, phi=0.1 und b=0.2 findet NonlinearFit das
a a
Minimum 0 von 2 ( ) in etwa fünf Schritten. Das Ergebnis wird von Mathematica
in Form einer Regel ausgegeben.
fa –> 0.825, om –> 0.976, phi –> 0.024, b –> 0.069 g (1.31)
1.5 Nichtlinearer Fit 29
0.8
0.6
0.4
0.2
f[t]
0
-0.2
-0.4
-0.6
0 2 4 6 8 1.8 Gedämpfte Schwingung
t und verrauschte Meßdaten.
Die Dichte der 2 -Verteilung ist im Bild 1.9 gezeigt. Die Verteilung (1.29) gilt
zwar streng genommen nur für gaußverteilte Fehler "i , aber wir erwarten keinen
großen Unterschied für unsere gleichverteilten Streuungen "i . Für den richtigen
0.12
0.1
0.08
Dichte
0.06
0.04
0.02
0
0 5 10 15 20 1.9 Dichte der 2 -Verteilung
chi2 mit 7 Freiheitsgraden.
Parametersatz gibt diese Dichte die Verteilung von 20 für verschiedene Experimen-
te, d. h. für verschiedene Realisierungen der "i .
Das Vertrauensintervall für den Wert von 20 erhalten wir mit
grenze[x_] = Quantile[ChiSquareDistribution[7],x]
f
und das Ergebnis von grenze[0.05], grenze[0.95] ist 2:2; 14:1 . Das g f g
heißt, für sehr viele Experimente sollten (mit den korrekten Parametern) 5% davon
einen Wert 20 14:1 und 5% einen Wert 20 2:2 haben. In unserem Fall erhalten
wir mit 20 = 9:4 einen Wert weit im Innern des Vertrauensintervalls; wir haben
daher keinen Grund, an dem Ergebnis des Fits zu zweifeln.
30 1 Mathematica-Funktionen
a a
Konturen mit P4 (2 ( ) 20 ) = 0:68 und P4 (2 ( ) 20 ) = 0:90 sind in der
Abbildung 1.10 zu sehen. Es sind dreidimensionale Flächen im vierdimensionalen
Parameterraum, deshalb können wir nur Schnitte zeichnen. Der optimale Parame-
tersatz liegt natürlich genau im Zentrum aller Konturflächen. Der (a,b)-Schnitt
0.2
0.14
0.15 0.12
0.1
0.1
0.08
b
b
0.05 0.06
0.04
0 0.02
0
0.4 0.6 0.8 1 1.2 0.9 0.92 0.94 0.96 0.98 1 1.02 1.04
a om
1.10 Konturen mit konstantem 2 (a). Links: Schnitt mit der a-b-Parameter-Ebene. Rechts:
Schnitt mit der om-b-Ebene.
zeigt, daß Änderungen in der Amplitude a durch eine Änderung der Zeitkonstan-
ten b 1 der Dämpfung kompensiert werden können, ohne die Qualität des Fits zu
verschlechtern. Daher darf man als Fehler für a nicht den Schnitt beim optimalen
b angeben, sondern man muß die Projektion auf die a-Achse verwenden. Insbeson-
dere zeigt Bild 1.10 (links), daß es nicht möglich ist, eine obere Schranke für die
Zeitkonstante b 1 zu bestimmen, da die Kontur der äußeren Vertrauensfläche durch
den Punkt b=0 (also b 1 = ) geht. 1
Variiert man die Frequenz om anstatt der Amplitude a, so tritt die obige Kompen-
sation nicht auf, wie Bild 1.10 (rechts) zeigt. Der wahre Punkt om=1 und b=0.1
liegt dicht am Rand der inneren Vertrauensfläche; das Vertrauensintervall sollte
daher nicht zu eng gewählt werden. Zeichnet man f[t] für zwei Extrema aus
Bild 1.10, nämlich a=1.3, b=0.15 und a=0.5, b=0, so sieht man in Bild 1.11,
daß beide Kurven die Daten noch relativ gut wiedergeben. Die wenigen Daten
(N = 11) und der große Fehler erlauben keinen besseren Fit.
Wie im Theorie-Teil erläutert wurde, gibt es eine alternative Methode, um den
Fehler für die Parameter abzuschätzen. Man nimmt für ein Experiment den optima-
a
len Parametersatz 0 und erzeugt sich damit neue, künstliche Daten, die wiederum
a
gefittet werden. Wird dies mit demselben 0 wiederholt, so erhält man einen Satz
a
von Parametervektoren i . Bild 1.12 zeigt das Ergebnis für 100 Iterationen mit dem
a 0 aus Gleichung (1.31) zusammen mit den Konturlinien von Bild 1.10. Man sieht,
daß die Werte in der (a, b)-Projektion sogar zu mehr als 90% innerhalb des äußeren
1.5 Nichtlinearer Fit 31
1
0.75
0.5
0.25
f[t]
0
-0.25
-0.5
1.11 Zwei Fitkurven mit Para-
0 2 4 6 8 metern aus der äußeren Kontur
t von Bild 1.10 (links).
a
Konturschnitts liegen. Um die Fehlergrenzen von 0 angeben zu können, berechnen
f g
wir mit dem ursprünglichen Datensatz Yi zu jedem der 100 Parametervektoren i a
a a
das zugehörige 2 ( i ) und sortieren die i nach wachsendem 2 . Für ein Vertrau-
0.15
0.1
b
0.05
0
1.12 Parameterwerte a und b aus den Fits
0.5 0.6 0.7 0.8 0.9 1 1.1 1.2 zu den künstlichen Daten zusammen mit
a den Konturlinien von Bild 1.10 (links).
ensniveau von z. B. 68% betrachten wir dann nur noch die ersten 68 dieser Vektoren,
a
von denen der letzte eine 2 -Grenze 268 = 2 ( 68 ) festlegt. Alle noch verbleiben-
a a
den i liegen dann innerhalb des Quasi-Ellipsoids 2 ( ) 268 . Wir projizieren die
a
Punkte i auf die Achsen des Parameterraumes und erhalten so die äußeren Abmes-
sungen des Ellipsoids. Auf diese Weise können wir schließlich die Aussage treffen,
a
daß mit einer Sicherheit von 68% der wahre Vektor true in einem Quasi-Ellipsoid
liegt, das in dem Quader
enthalten ist. Natürlich gehört wegen der erwähnten Korrelationen nicht jeder Punkt
a des Quaders zu dem 68%-Bereich. Ob er dazugehört, läßt sich an seinem 2 ( ) a
feststellen.
Übung
Die Daten fxi ; f (xi )g im File twinpeak.dat sind das Ergebnis der Funktion
f (x i ) = e x2i =2 + a e (xi b)2 =(22 ) + r
i;
wobei die ri normalverteilte Zufallszahlen mit Mittelwert 0 und Breite 0 = 0:05
sind. Die Daten können Sie mit
Literatur
S. Brandt, Datenanalyse: Mit statistischen Methoden und Computerprogrammen,
BI Wissenschaftsverlag, 1992.
J. Honerkamp, Stochastische Dynamische Systeme: Konzepte, numerische Metho-
den, Datenanalysen, VCH Verlagsgesellschaft, 1990.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Stephen Wolfram, Mathematica: A System for Doing Mathematics by Computer,
Addison Wesley, 1991.
1.6 Multipol-Entwicklung
Ein mächtiges analytisches Werkzeug des Theoretikers ist die Entwicklung einer
physikalischen Gleichung nach einer kleinen Größe. Dabei entstehen manchmal
Ausdrücke, die kompliziert und unanschaulich sind. Oft hat man kein Gefühl dafür,
wie stark die Entwicklung vom wahren Wert abweicht.
Die Multipol-Entwicklung eines elektrostatischen Potentials, ein beliebtes Kapi-
tel aus der Elektrodynamik-Vorlesung, ist ein einfaches Beispiel dafür. Von ferne
sieht eine Ladungsverteilung wie eine Punktladung aus. Kommt der Beobachter
1.6 Multipol-Entwicklung 33
näher, so bemerkt er das Dipolmoment, bei größerer Annäherung auch das Qua-
drupolmoment. Diese approximative Beschreibung läßt sich kompakt durch einen
Skalar, einen Vektor und einen Tensor mathematisch formulieren. Jetzt – mit Ma-
thematica – können wir dies ebenso kompakt programmieren, aber auch graphisch
darstellen und uns die Abweichung vom exakten Potential ansehen.
Physik
r
Für N punktförmige Ladungen ei an den Orten (i) ist das elektrostatische Potential
r
( ) gegeben durch
X
N
ei
(r) = jr r(i) j : (1.32)
i=1
Das elektrische Feld ist durch den Gradienten von bestimmt:
@ @ @
E= r(r) ; r =
@x ; @y ; @z : (1.33)
Betrachtet man nun dieses Potential von weiter Ferne, also für jr r(i) j ! 1, so
r
kann man ( ) entwickeln:
(r) = rq + pr3r + 12 r15 r Qb r + O r14 (1.34)
b der Quadru-
mit r = jr j. Dabei ist q die Gesamtladung, p das Dipolmoment und Q
poltensor:
X
N X
N X N
q= p
ei ; = ei r (i) ; Qbkl = ei 3rk(i) rl(i) kl r(i) 2 ; (1.35)
i=1 i=1 i=1
(i)
wobei rk die k -te Komponente von (i) ist.r
Algorithmus
Wir wollen diese Entwicklung am Beispiel von fünf positiven und fünf negativen
Einheitsladungen untersuchen, die wir in die x-y -Ebene legen, und zwar zufällig
verteilt innerhalb eines Quadrats mit Mittelpunkt im Ursprung. Wir erzeugen uns
also zehn Vektoren mit
rpunkt:={2 Random[]–1, 2 Random[]–1, 0}
Do[r[i] = rpunkt, {i,10}]
34 1 Mathematica-Funktionen
Jeder Vektor r[i] ist eine Liste von drei Zahlen. An den ersten fünf Punkten
sollen sich positive, an den letzten fünf negative Ladungen befinden. Wir wollen
nun die Ladungen graphisch darstellen. Dazu werden zunächst mit der Funktion
Line[: : :] an den entsprechenden Stellen Plus- und Minussymbole gezeichnet,
wobei man mit Drop[r[i],–1] die z -Koordinate beseitigt:
p1 = Graphics[Table[Line[{Drop[r[i],–1]–{0.08,0},
Drop[r[i],–1]+{0.08,0}}],{i,5}]]
p2 = Graphics[Table[Line[{Drop[r[i],–1]+{0,0.08},
Drop[r[i],–1]–{0,0.08}}],{i,5}]]
p3 = Graphics[Table[Line[{Drop[r[i+5],–1]–{0.08,0},
Drop[r[i+5],–1]+{0.08,0}}],{i,5}]]
Dann wird mit Circle[ ] jeweils ein Kreis um die Symbole gezeichnet,
p4 = Graphics[{Thickness[0.001],
Table[Circle[Drop[r[i], –1], 0.1],{i,10}]}]
und danach werden mit Show[p1,p2,p3,p4,Optionen] alle vier Graphikob-
jekte zusammen gezeichnet. Bild 1.13 zeigt das Ergebnis.
2
1.5
1
0.5
0
y
-0.5
-1
-1.5
-2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2 1.13 Positive und negative Ladungen zufällig
x verteilt in der x-y -Ebene.
Um das Potential angeben zu können, definieren wir zunächst den Abstand zwi-
schen zwei Vektoren,
dist[r ,s ]=Sqrt[(r–s).(r–s)]
Der Punkt zwischen zwei Listen von Zahlen – die volle Mathematica-Form davon
ist Dot[l1,l2] – bewirkt ein Skalarprodukt der beiden Vektoren, also die Summe
der Produkte der jeweiligen Komponenten der Vektoren. Ohne den Punkt hingegen
würden die Vektoren elementweise miteinander multipliziert werden mit einer Liste
r
als Ergebnis. Nun kann man ( ) aus Gl. (1.32) direkt eingeben (ei = 1):
1.6 Multipol-Entwicklung 35
pot[rh_]:=Sum[1/dist[rh,r[i]]–1/dist[rh,r[i+5]],{i,5}]
Wir präsentieren drei Möglichkeiten, wie man sich dieses Ergebnis veranschauli-
chen kann: Zunächst zeichnen wir mit Plot3D das Potentialgebirge über der x-y -
Ebene, dann mit ContourPlot die Höhenlinien dieses Gebirges, und schließlich
berechnen wir das elektrische Feld und zeichnen es mit PlotVectorField aus
dem Paket Graphics‘PlotField‘. Allerdings sieht man im letzten Fall nur
etwas, wenn man das Feld normiert, also nur die Richtung anzeigt.
Das Dipol- und Quadrupolmoment kann man ebenso einfach in Mathematica
formulieren. Nach Gl. (1.35) gilt
dipol = Sum[r[i] – r[i+5],{i,5}]
quadrupol[r_]:=
Table[3 r[[k]] r[[l]] – If[k==l,r.r,0],{k,3},{l,3}]
qsum = Sum[quadrupol[r[i]]–quadrupol[r[i+5]],{i,5}]
Dabei wurde das Delta-Symbol kl durch folgenden Ausdruck beschrieben
If[k==l,1,0]
r
Den Betrag eines Vektors , den wir zwar als dist[r,0] ausdrücken könnten,
berechnen wir mit der Funktion
betrag[r ]=Sqrt[r.r]
r
Damit läßt sich die Entwicklung (1.34) des Potentials ( ) direkt definieren. In
unserem Beispiel gibt es keine Gesamtladung (q = 0), daher ist der erste Beitrag
pot1 der Dipolterm, und pot2 enthält zusätzlich den Quadrupolbeitrag:
pot1[r_] = dipol.r / betrag[r]ˆ3
pot2[r_] = pot1[r]+1/2/betrag[r]ˆ5 r.qsum.r
qsum ist eine Liste von Listen, in diesem Fall also eine 3 3-Matrix. r ist eine Liste
von Zahlen, also ein Vektor. Die Funktion Dot[ , ] oder kurz mit dem Punkt
(.) bezeichnet, berechnet Kontraktionen von Tensoren mit beliebig vielen Indizes
(= geschachtelten Listen). Hier läßt sich daher die quadratische Form Vektor mal
”
Matrix mal Vektor“ sehr einfach als r.qsum.r schreiben. In einer herkömmlichen
Programmiersprache wie C müßte man dagegen zwei for-Schleifen ineinander-
schachteln:
sum = 0;
for(i=0; i<3; i++) {
for(j=0; j<3; j++) {
sum = sum + r[i]*qsum[i][j]*r[j] }}
Das elektrische Feld E erhält man nach Gleichung (1.33) wie folgt:
36 1 Mathematica-Funktionen
efeld =
–{D[pot[{x,y,z}],x],D[pot[{x,y,z}],y],D[pot[{x,y,z}],z]}
und seine Richtung erhält man durch Division durch jE j :
richtung = efeld/betrag[efeld]
5
2
Φ
0
1
-5
-2 0 y
-1
10 Einheitsladungen in
x
1
2 -2 der Ebene z = 0.
Ergebnisse
In unserem einfachen Beispiel sind fünf positive und fünf negative Ladungen ei = j j
1 zufällig in der x-y-Ebene verteilt (Bild 1.13). Sie erzeugen in dieser Ebene das
f g
Potential pot[ x,y,0 ], das in Bild 1.14 als Gebirge und in 1.15 durch seine
Höhenlinien ( = const.) dargestellt ist.
-1
Wir wollen nun die Dipol- und Quadrupolnäherung mit dem exakten Potential ver-
gleichen. Dazu betrachten wir in der x-y -Ebene (z = 0) einen Weg mit x = 0:6
parallel zur y-Achse, der dicht an zwei positiven Ladungen bei y '1, einer nega-
'
tiven Ladung und einem Dipol bei y 0 vorbeiläuft. Bild 1.16 zeigt das Ergebnis.
Die durchgezogene Kurve ist das exakte Potential. Der Dipolterm (kurz gestrichelt)
2
Potential
-2
10
-5
beim Dipol um den Ursprung. In der Nähe der Ladungen zeigt sich dagegen eine
komplizierte Struktur.
Übung
I
Es soll das Magnetfeld berechnet werden, das eine vom Strom durchflossene
kreisförmige Leiterschleife erzeugt. Die Leiterschleife liege in der x-y -Ebene mit
A
Mittelpunkt im Ursprung und habe den Radius a. Das Vektorpotential , aus dem
man das Magnetfeld B =r A berechnet, hat in Kugelkoordinaten (r; ; )
e e e
mit den Einheitsvektoren r ; ; eine besonders einfache Form. Nur seine -
Komponente ist von null verschieden, und im Lehrbuch von J. D. Jackson findet
man dafür den Ausdruck
A(r; ) = 0 2 2I a
p (2 k2 )K (k) 2E (k)
k2
a + r + 2ar sin
mit
k2 = a2 + 4rar sin
2 + 2ar sin :
K (k) = EllipticK[k2] und E (k) = EllipticE[k2] sind die vollständigen
elliptischen Integrale erster und zweiter Art.
B
Berechnen Sie das Magnetfeld (x; y; z ) und zeichnen Sie in der x-z -Ebene mit
B
der Funktion PlotVectorField[: : :] die Richtung des -Feldes. Versuchen
Sie, durch Integration einer geeigneten Differentialgleichung das Feldlinienbild von
B in der x-z -Ebene zu zeichnen.
Hinweis: Die Schwierigkeit, daß Mathematica mit den Ableitungen EllipticK’
und EllipticE’ nichts anzufangen weiß, läßt sich beheben, weil die Ableitungen
der elliptischen Integrale wiederum durch elliptische Integrale ausgedrückt werden
können. Die zwei Zeilen
EllipticK’[x_]=1/(2x)*(EllipticE[x]/(1–x)–EllipticK[x])
EllipticE’[x_]=1/(2x)*(EllipticE[x]–EllipticK[x])
in Ihrem Programm lösen das Problem.
Literatur
I.S. Gradshteyn, I.M. Ryzhik, Table of Integrals, Series, and Products, Academic
Press, 1980.
J. D. Jackson, Classical Electrodynamics, John Wiley & Sons, 1975.
R. Schaper, Grafik mit Mathematica, Addison Wesley, 1994.
1.7 Wegintegrale 39
1.7 Wegintegrale
Physik
Arbeit = Kraft Weg. Diese scheinbar einfache Gleichung aus der Schulphysik
wird sofort schwieriger, wenn man sich klarmacht, daß die Kraft ein Vektorfeld
Kr r
( ) ist, also jedem Punkt im Raum einen Vektor zuordnet, und daß der Weg W
r
eine Kurve (t) im Raum ist, die durch eine Zeit t parametrisiert werden kann. Die
Arbeit A ist damit das Wegintegral
Z Zt
A = K dr = K (r(t)) ddtr dt :
e
(1.36)
W ta
Das Skalarprodukt Kraft Geschwindigkeit wird also über das Zeitintervall [ta ; te ]
Kr
integriert. Dieses Integral wird einfach, wenn ( ) der Gradient eines Potentials
r
( ) ist,
K
= r ; (1.37)
r r
dann gilt A = ( (te )) ( (ta )). Im allgemeinen kann die Auswertung des
Wegintegrals allerdings mühsam sein.
Mathematica bietet die Möglichkeit, Vektoranalysis bequem auszuführen, sogar
in symbolischer Form. Wir wollen dies an einem Wegintegral demonstrieren und
verweisen für weitergehende Rechnungen und Vektoroperationen in anderen Koor-
dinatensystemen auf das Package Calculus‘VectorAnalysis‘.
1
0.75
z 1
0.5
0.25 0.5
0
-1 0 y
-0.5
0 -0.5
x
0.5
-1
1
1.18 Drei verschiedene Integrationswege.
v[r ]:=D[r,t]
Das Wegintegral kann sogar als Funktion definiert werden, die auf Wege wirkt:
int[r ]:=Integrate[k[r].v[r], t,0,1 ] f g
Wir geben nun int[r1], int[r2] und int[r3] ein und erhalten für alle drei
Wege dasselbe Ergebnis, nämlich den Wert 1. Die Unabhängigkeit des Integrals
vom Weg läßt vermuten, daß K
der Gradient eines Potentials ist. Dann muß nach
Sätzen der Vektoranalysis die Rotation von K
verschwinden, die definiert ist als
f
rot[ kx , ky , kz g]:= f D[kz,y] – D[ky,z],
D[kx,z] – D[kz,x],
D[ky,x] – D[kx,y] g
f g
rot[k[ x,y,z ]] gibt tatsächlich den Nullvektor 0,0,0 . f g
r
Wie findet man das Potential ( ), das bis auf eine Konstante eindeutig bestimmt
ist? Nach Gl. (1.36) gilt
Zr Z1
(r) = K ds = K ddts dt ; (1.38)
0 0
f
wobei wir s(t) = r4 = t x,y,z als Weg von g 0 bis r wählen. int[r4] liefert
das Potential (x; y; z ) = x2 y + xz 3 .
1.8 Maxwell-Konstruktion 41
Wir können nun das Feld K (r) ein wenig verändern, z. B. durch
k[{x,y,z}] = {2x yˆ2 + zˆ3, xˆ3, 3x zˆ3}
und erhalten dann für jeden Weg ein anderes Ergebnis: Nach dem Anwenden von
Simplify liefert int[r1]
1 + 43 2 + 34 ;
int[r2] gibt 3=4 und int[r3] den Wert 3=4 + 9=256 . Berechnen wir jetzt
erneut die Rotation, so ergibt rot[k[{x,y,z}]] in Übereinstimmung mit der
0
Abhängigkeit des Integrals vom Integrationsweg einen von verschiedenen Wert.
Übung
Literatur
S. Großmann, Mathematischer Einführungskurs für die Physik, Teubner Studienbü-
cher Physik, 1991.
1.8 Maxwell-Konstruktion
In der Physik treten häufig implizite nichtlineare Gleichungen für die gegenseitige
Abhängigkeit von Größen auf, die nur noch numerisch gelöst werden können. Ein
Beispiel dafür sind die p(V; T )-Kurven des van-der-Waals-Gases mit der Tempera-
tur T als Parameter, die durch die sogenannte Maxwell-Konstruktion eine physika-
lische Bedeutung erlangen.
Die Isothermen der Zustandsgleichung, die als van-der-Waals-Gleichung bekannt
ist, haben bei tiefen Temperaturen Schleifen, die aus thermodynamischen Gründen
verboten sind. Sie müssen durch Geraden ersetzt werden, die die Schleifen in einem
42 1 Mathematica-Funktionen
Physik
Die Theorie der Wärme gibt für ein ideales Gas aus N wechselwirkungsfreien, klas-
sischen Teilchen ohne innere Freiheitsgrade einen einfachen Zusammenhang zwi-
schen Volumen V , Druck p und Temperatur T :
p V = Nk T : B (1.39)
@p (V; T ) = 0 @ 2 p (V; T ) = 0 ;
@V und
@V 2 (1.41)
Tc = 27Nk8a ; V = 3 b ; p = a :
b c
B
c
27 b2 (1.42)
Skaliert man nun jeweils p; V und T mit pc ; Vc und Tc , so erhält man eine Glei-
x = x=xc ):
chung, die keine Parameter mehr enthält (~
p~ + ~32 3V~ 1 = 8T~ : (1.43)
V
1.8 Maxwell-Konstruktion 43
Für T~ < 1 gibt die Gleichung also die unphysikalische Schleife, d. h. für einen
gewissen Bereich gibt es für jeden Druckwert p~ drei Volumina V~1 ; V~2 und V~3 . Der
Übergang vom Gas mit großem Volumen V~3 zur Flüssigkeit mit kleinem Volumen
V~1 findet aus thermodynamischen Gründen bei demjenigen Druck p~t statt, bei dem
gilt:
Z
V~3
p~(V~ )dV~ = p~t V~3 V~1 : (1.44)
V~1
Bei p~t sind Gas und Flüssigkeit für alle Volumina V~ mit V~1 V~ V~3 gleich-
zeitig vorhanden, man beobachtet ein Zweiphasengemisch. Geometrisch bedeutet
die obige Gleichung, daß die Fläche zwischen der p~(V~ )-Kurve und der Geraden
p~t = const. im Bereich von V~1 bis V~2 genauso groß ist wie die entsprechende
Fläche zwischen V~2 und V~3 (siehe Bild 1.19). Die Kurve p~t = const., die man
Maxwell-Gerade nennt, wollen wir mit Mathematica konstruieren.
p[v ]=8t/(3v–1)–3/vˆ 2
Für die Maxwell-Gerade benötigen wir zwei Gleichungen, um die beiden unbekann-
1.75
1.5
1.25
1
p
0.75
0.5
0.25
0
1 2 3 4 5
v
1.19 Maxwell-Konstruktion für die van-der-Waals-Gleichung. Isothermen zu den skalierten
Temperaturen T~ = 1:05; 1:0; 0:95; 0:92; 0:85 (von oben nach unten).
ten Volumina v1 und v3, zwischen denen Gas und Flüssigkeiten koexistieren, zu
bestimmen. Die erste Gleichung sagt, daß Koexistenz Gleichheit der Drücke ver-
langt:
gl3=p[v1]==p[v3]
Die zweite Gleichung setzt die beiden Flächen nach Gleichung (1.44) gleich:
gl4=p[v1]*(v3–v1)==Integrate[p[v], v,v1,v3 ] f g
Ein Versuch mit Solve zeigt an, daß Mathematica keine analytische Lösung fin-
det. Wir werden deshalb FindRoot benutzen, um eine numerische Lösung zu er-
halten. Allerdings müssen die Startwerte der (v1,v3)-Suche ziemlich genau an-
gegeben werden, damit ein vernünftiges Ergebnis gefunden wird. In der Funktion
plot[T_] werden deshalb für Temperaturen T < 1 zunächst diejenigen v-Werte
bestimmt, an denen p[v] ein relatives Minimum bzw. Maximum hat, und dar-
aus wird das arithmetische Mittel vtest gebildet. Mit dem Mathematica-Befehl
1.9 Beste Spielstrategie 45
Übung
Betrachten Sie ein Quantenteilchen der Masse m in einem eindimensionalen Poten-
tialtopf
V (x) = 0V0 für sonst :
a x a;
Aus der Quantenmechanik-Vorlesung wissen Sie, daß die Energieniveaus E der ge-
bundenen Zustände durch folgende Gleichungen bestimmt sind:
p
= VE = xq 2 1 mit x = ~a 2mV0 und q Lösung der transzendenten Gleichung
2
0
px2 q2 px2 q2
tan q = q oder cot q = q :
Berechnen und zeichnen Sie alle Energieniveaus n als Funktion des Parameters x.
Literatur
T. Fließbach, Statistische Physik, Spektrum Akademischer Verlag, 1995.
E. W. Schmid, G. Spitz, W. Lösch, Theoretische Physik mit dem Personal Computer,
Springer, 1987.
Mathematik
Es spielen zwei Personen gegeneinander. Nach jedem Zug muß ein Spieler dem
anderen einen Betrag bezahlen, der aus einer Tabelle abgelesen wird. Jeder Spieler
versucht, seine Züge so zu wählen, daß die Summe seiner Gewinne und Verluste
nach vielen Zügen eine positive Bilanz aufweist.
Für das Spiel wird eine Gewinntabelle K = (Kij ) benötigt, z. B.
0 0 1 3 1
1
K=@ 1 10 4 2 A:
7 2 3 7
Der Spieler Z kann bei jedem Zug eine der drei Zeilen i = 1; 2; 3 wählen, während
Spieler S vier Wahlmöglichkeiten für die Spalten j = 1; :::; 4 hat. Ein Zug besteht
darin, daß Spieler Z sich für eine Zeilennummer i und Spieler S sich für eine Spal-
tennummer j entscheidet, ohne daß der eine von der Wahl des anderen weiß. Dann
wird aufgedeckt, und danach erhält Spieler Z gemäß dem Paar (i; j ) den Betrag
j j
Kij vom Spieler S , bzw. zahlt Kij für Kij < 0. Da der Gewinn von Z der Verlust
von S ist und umgekehrt, nennt man dieses Spiel Zwei-Personen-Nullsummen-Spiel.
Diese Prozedur wird viele Male wiederholt. Am Ende hat Z im Mittel pro Zug den
Betrag K erhalten. Z sucht also eine Strategie, die einen möglichst großen mittleren
Gewinn K ergibt.
Natürlich möchte auf der anderen Seite S seine Verluste minimieren, er sucht al-
so das Minimum von K . Für jede Wahl i von Z sucht er also minj Kij . Da er aber
nicht weiß, welche Zeile Z wählen wird, könnte er auf die Idee kommen, diejenige
Spalte zu wählen, die im schlechtesten Fall den geringsten Verlust ergibt. Für jede
Wahl j verliert S im schlechtesten Fall den Wert maxi Kij . Er wählt also dasje-
nige j , das zu minj maxi Kij gehört, hier die Spalte j = 3. Bei entsprechender
Überlegung würde Z die Zeile zum Wert maxi minj Kij wählen, also i = 1. Bei
dieser Strategie würde nach jedem Zug an Spieler Z der Betrag K13 = 3 ausge-
zahlt werden. Die von den jeweiligen Spielern ins Auge gefaßten Grenzen haben
1.9 Beste Spielstrategie 47
unterschiedliche Werte:
0 = max
i
min
j
Kij 6= min
j
max
i
Kij = 4 : (1.45)
Was bedeutet nun ein Gewinn von 3 für Spieler Z , der bei dieser Strategie einen
Mindest- Gewinn“ von 0 erwarten konnte? Und sollte Spieler S , der im ungün-
stigsten Fall mit einem Verlust von 4 hatte rechnen müssen, mit der 3 zufrieden
”
sein? In der Tat hat Spieler Z allen Grund, seine Strategie zu überdenken. Eine ge-
nauere Inspektion der Gewinntabelle sagt ihm nämlich, daß für jede Wahl von S
sein Gewinn im Mittel mindestens 3 sein wird, wenn er die Zeilen 2 und 3 zufällig
wechselnd gleich häufig auswählt. Und wenn er Zeile 3 dabei ein wenig bevorzugt,
wird er den Gewinn von 3 sogar übertreffen. Man sieht an dieser Überlegung, daß
es zweckmäßig ist, die Zeilen und Spalten mit einer gewissen Wahrscheinlichkeit pi
bzw. qj zu wählen. Eine Strategie für den Spieler Z besteht also aus den 3 Häufig-
keiten p1 ; p2 und p3 (mit p1 + p2 + p3 = 1), mit denen er unkorreliert die Zeilen
X
wählt. Im Mittel erhält er den Betrag
K= pi qj Kij : (1.46)
i;j
Wenn Z nun eine Strategie p1 ; p2 , und p3 wählt, bekommt er im schlechtesten Fall
P
minq :::q i;j pi Kij qj . Z wird daher ein p1 ; p2 ; p3 wählen, das den Gewinn im
0 0 0
1 4
X
ungünstigsten Fall maximiert, er sucht also
max min
p :::p q :::q
pi Kij qj : (1.47)
1 3 1 4
i;j
S sucht analog eine Strategie q10:::q40 , die den Wert
X
min max
q :::q p :::p
pi Kij qj (1.48)
1 4 1 3
i;j
liefert. Entgegen dem deterministischen Spiel (1.45) geben die optimalen stochasti-
X X X
schen Strategien (1.47) und (1.48) denselben Wert:
max
p
min
q
pi Kij qj = min
q
max
p
pi Kij qj = p0i Kij qj0 = K0 :
ij ij ij
(1.49)
Dies ist das berühmte Minimax-Theorem, das J. von Neumann 1926 im Alter von
23 Jahren bewiesen hat. Wir wollen die Bedeutung von (1.49) noch in Worte fassen:
Wenn Spieler Z eine optimale Strategie p01 ; : : : ; p03 wählt, so ist sein Gewinn für jede
Strategie q1 ; : : : ; q4 des Spielers S nach sehr vielen Spielzügen mindestens K0 . Es
gilt also für jede Wahl q1 ; : : : ; q4 mit qi 0 und q1 + q2 + q3 + q4 = 1 :
X
p0i Kij qj K0 : (1.50)
i;j
48 1 Mathematica-Funktionen
P
Aus dieser Ungleichung kann man ein System von 4 Bedingungen ableiten, denn
mit q1 = 1 und q2 = q3 = q4 = 0 wird daraus i p0i Ki1 K0 und analog:
X
p0i Kij K0 für alle j : (1.51)
i
Nehmen wir an, daß K0 > 0 gilt, so wird dies mit x0i = p0i =K0 zu
X
x0i Kij 1 für alle j : (1.52)
i
Nach Sätzen der linearen Optimierung ist nun die optimale Strategie p01 ; p02 ; p03
durch den maximalen Wert K0 im Gleichungssystem (1.51) bestimmt, oder wegen
P P
i xi = 1=K0 durch das Minimum von i xi .
0 0
Dieser Sachverhalt läßt sich in Vektorschreibweise noch kompakter formulieren:
Es seien K die Matrix (Kij ) und KT die Transponierte von K, = (x1 ; x2 ; x3 )T x
mit xi c b
0; = (1; 1; 1)T ; = (1; 1; 1; 1)T . Dann ist die optimale Strategie
p x
0 = K0 0 und deren mittlerer Gewinn K0 durch ein Minimum von unter cx
der Nebenbedingung KT xb bestimmt, wobei letzte Vektorungleichung kompo-
nentenweise gemeint ist. Es gilt K0 = 1=( 0 ). cx
Nach dem Dualitätssatz der linearen Optimierung kann man K0 auch aus folgen-
dem Problem gewinnen:
Suche das Maximum von by
unter der Nebenbedingung K für den Vektoryc
y
= (y1 ; :::; y4 )T mit yj 0.
y
Die Lösung 0 dieser Aufgabe gibt aber gerade die optimale Strategie für den
q y
Spieler S . Denn mit 0 = K0 0 erhält man
X
Kij qj0 K0 für alle i (1.53)
j
und damit analog zu (1.50) und (1.51) für jede Strategie p von Z :
X
pi Kij qj0 K0 : (1.54)
i;j
Im schlechtesten Fall verliert also der optimal spielende S den Betrag K0 . Spielt S
q
nicht mit der Strategie 0 , kann er allerdings höher verlieren.
Ein nützlicher Satz soll noch erwähnt werden: Addiert man zu jedem Matrixele-
p q
ment die Konstante d, so bleiben 0 und 0 optimale Strategien mit dem Spielwert
K0 + d. Die obigen Aussagen zu (1.51) gelten streng nur für Matrizen mit positiven
Werten Kij . Wegen des Verschiebungssatzes kann aber jede Matrix K ins Positive
verschoben werden; danach wird das Optimierungsprogramm angewendet.
1.9 Beste Spielstrategie 49
Übung
Das wohlbekannte Knobelspiel mit den drei Symbolen Schere, Stein, Papier wollen
wir auf die vier Symbole Schere, Stein, Papier und Brunnen erweitern. Zwei Spieler
setzen dabei jeweils auf eine dieser vier Möglichkeiten und gewinnen, bzw. verlieren
einen Punkt nach folgenden Regeln:
Brunnen verschluckt Stein, Brunnen verschluckt Schere,
Papier deckt Brunnen zu, Papier umhüllt Stein,
Schere zerschneidet Papier,
Stein zerschlägt Schere.
Formulieren Sie für dieses Spiel eine Auszahlungsmatrix und berechnen Sie damit
die optimale Strategie der beiden Spieler.
Literatur
John von Neumann, Collected Works, Volume VI : Zur Theorie der Gesellschafts-
spiele, Seite 1, Pergamon Press, 1963.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
W. Vogel, Lineares Optimieren, Akademische Verlagsgesellschaft, 1967.
Kapitel 2
Lineare Gleichungen
Viele Phänomene der Physik können durch lineare Gleichungen beschrieben wer-
den. Doppelte Ursache gibt doppelte Wirkung – dieser Sachverhalt erlaubt es, solche
Probleme mathematisch zu lösen. Häufig lassen sich lineare Systeme durch Vekto-
ren beschreiben, Vektoren mit manchmal wenigen, manchmal sehr vielen Kompo-
nenten. In den Bewegungsgleichungen tauchen dann Matrizen auf, deren Eigen-
werte und Eigenvektoren die Energien und die stationären Zustände des Systems
beschreiben. Jede andere Form der Bewegung ist eine Überlagerung dieser Eigen-
zustände.
Es gibt eine Vielzahl von numerischen Methoden, lineare Gleichungen zu lösen.
Diese weit entwickelten Standard-Algorithmen werden in den Lehrbüchern zur nu-
merischen Mathematik ausführlich erklärt. Wir haben in diesem Kapitel, abgesehen
vom Hofstadter-Schmetterling, die Beispiele so gewählt, daß sie sich mit vordefi-
nierten Funktionen untersuchen lassen. Beim elektrischen Netzwerk geht es darum,
ein lineares Gleichungssystem zu lösen, und außerdem können wir noch einmal die
Fouriertransformation anwenden. Andere Fragestellungen, die sowohl der Mecha-
nik als auch der Quantenphysik entstammen, führen uns auf Eigenwertgleichungen,
also auf das Problem, Eigenwerte und Eigenvektoren von eventuell großen Matrizen
zu bestimmen.
2.1 Quantenoszillator
Die Bewegungsgleichung der Quantenmechanik, die Schrödinger-Gleichung, ist li-
near: Jede Überlagerung von Lösungen ist wieder eine Lösung. Deshalb hat man Er-
folg mit dem Verfahren, die Gleichung in Raum und Zeit durch einen Produktansatz
zu separieren und später diese Produktlösungen zu überlagern. Der räumliche Anteil
ist die sogenannte stationäre Schrödinger-Gleichung – eine Eigenwertgleichung, die
in der Ortsdarstellung die Form einer linearen Differentialgleichung hat. Die Lösun-
r r
gen dieser Gleichung sind Wellenfunktionen ( ), die jedem Ort eine komplexe
Zahl zuordnen, und zwar beschreiben sie diejenigen Zustände des physikalischen
Systems, deren Aufenthaltswahrscheinlichkeit j rj
( ) 2 sich zeitlich nicht ändert.
Zur numerischen Lösung der Schrödinger-Gleichung kann man entweder die linea-
re Differentialgleichung näherungsweise diskretisieren und in Matrixform bringen,
52 2 Lineare Gleichungen
r
oder man kann ( ) nach einem vollständigen Satz von Wellenfunktionen 'n ( ) r
entwickeln und nur endlich viele davon betrachten. In beiden Fällen führt die stati-
onäre Schrödinger-Gleichung auf eine Eigenwertgleichung einer endlichen Matrix.
Wir wollen den zweiten Ansatz am Beispiel des anharmonischen Oszillators studie-
ren.
Physik
Wir behandeln ein eindimensionales Problem, nämlich ein Teilchen der Masse m
im quadratischen Potential V (q ) = 12 m! 2 q 2 . Dabei ist q die Ortskoordinate des
Teilchens. Der Hamiltonoperator dazu lautet in dimensionsloser Form
H0 = 12 p2 + q2 :
(2.1)
p
Dabei werden Energien in Einheiten von ~! , Impulse in Einheiten von ~m! und
p
Längen in Einheiten von ~=(m! ) gemessen. Die Eigenzustände j von H0 fin- ji
det man in jedem Lehrbuch der Quantenmechanik, sie lauten in der Ortsdarstellung:
'j (q) = 2j j !
p e 1
2
1 2
2 q Hj (q) ; (2.2)
H = H0 + q4; (2.3)
hj ji
und suchen die Matrix j H k . Dazu ist es zweckmäßig, q als Summe von Erzeu-
gungs- und Vernichtungsoperatoren ay und a zu schreiben:
q = p1 (ay + a) ; (2.4)
2
wobei a und ay die folgenden Eigenschaften haben:
p
ay jj i = pj + 1 jj + 1i ;
aj0i = 0 und ajj i = j jj 1i fur j > 0 : (2.5)
2.1 Quantenoszillator 53
Die Matrixdarstellung von q im Raum der ungestörten Zustände jj i liefert also die
Tridiagonalmatrix
p p p
Qjk = hj jqjki = p1 k + 1 j;k+1 + p1 k j;k 1 = 21 j + k + 1 jk jj;1 :
2 2
(2.6)
Die Näherung, die wir jetzt vornehmen, besteht darin, diese unendlich-dimensionale
Matrix nur für j; k = 0; 1; :::; n 1 zu definieren. Der Hamiltonoperator H =
H0 + q4 , bzw. seine Matrixdarstellung, soll ebenfalls als n n-Matrix genähert
werden, wobei H0 durch die Diagonalmatrix mit den Elementen j + 12 und q 4 durch
das vierfache Matrixprodukt von Qjk mit sich selbst dargestellt wird. Den Fehler
der Approximation kann man abschätzen, indem man die Eigenwerte von H für
verschiedene n-Werte miteinander vergleicht.
Algorithmus
Die obigen Matrizen lassen sich in Mathematica besonders kompakt definieren.
hjji
j q k ist nach Gleichung (2.6)
q[j_,k_]:= Sqrt[(j+k+1)]/2 /; Abs[j–k]==1
q[j_,k_]:= 0 /; Abs[j–k] != 1
Die Konstruktion lhs := rhs /; test bedeutet, daß die Definition nur dann
benutzt wird, wenn der rechte Ausdruck wahr ist, also den Wert True hat. Die
Matrix q wird als Liste von Listen definiert
q[n ]:= Table[q[j,k], fj,0,n–1g, fk,0,n–1g]
und H0 ergibt sich gemäß Gleichung (2.2) zu
h0[n ]:= DiagonalMatrix[Table[j+1/2, fj,0,n–1g]]
Damit läßt sich H schreiben als
h[n ]:= h0[n] + lambda q[n].q[n].q[n].q[n]
Die Eigenwerte von H erhält man mit Eigenvalues[...], entweder algebra-
isch (nur für kleine n-Werte) oder numerisch mit Eigenvalues[N[h[n]]],
wobei lambda zuvor ein numerischer Wert zugewiesen werden muß.
54 2 Lineare Gleichungen
Ergebnisse
Der Aufruf h[4] // MatrixForm liefert die Hamiltonmatrix
0 1 + 43 0 p32 1
BB 2 q03 C
BB 0 3 + 15
2 4 0 3 2 C
C:
@ p32
q0 5 + 27
2 4 0 CA
(2.7)
0 3 32 0 7 15
2 + 4
Deren Eigenwerte lauten
p p p p
6 + 15 2 2 2 + 12 + 272 und 10 + 15 2 2 2 + 272 : (2.8)
4 4
Diese vier Eigenwerte sind in Abbildung 2.1 als Funktion von zu sehen. Ohne
9
8
7
6
Energie
5
4
3
2 2.1 Näherungswerte für die un-
1 tersten vier Energie-Eigenwerte
des Quantenoszillators mit
0 0.2 0.4 0.6 0.8 1 der Anharmonizität q 4 in
lambda Abhängigkeit von .
0.55915
0.55914
E0(n)
0.55913
2.2 Näherungswerte für die
0.55912 Grundzustandsenergie des an-
harmonischen Oszillators als
0.55911
Funktion der Matrixdimension
0.06 0.08 0.1 0.12 0.14 n für n = 7; 8; : : : ; 20, aufge-
1/n tragen über 1=n.
"10(20) = 17:333 : : : ;
"10(40) = 17:351 : : : ;
also nur eine Genauigkeit von drei Stellen.
Im Bild 2.1 haben wir nur vier Niveaus für unsere Näherung berücksichtigt. Da-
10
9
8
7
Energie
6
5
4
3
2
1 2.3 Die fünf niedrigsten
Energie-Eigenwerte als Funk-
0 0.2 0.4 0.6 0.8 1 tion des Vorfaktors der
lambda Anharmonizität.
56 2 Lineare Gleichungen
her sind die oberen zwei Energien völlig falsch dargestellt. Im Bild 2.3 dagegen ha-
ben wir zwanzig Niveaus mitgenommen. In diesem Fall gibt die numerische Lösung
der Eigenwertgleichung ein sehr genaues Ergebnis für die fünf niedrigsten Energi-
en. Sowohl die Energien als auch deren Abstände wachsen mit dem Vorfaktor der
Anharmonizität.
Übung
Wir betrachten ein Quanten-Teilchen in einer Dimension im Doppelmuldenpotenti-
al. Der Hamiltonoperator sei in dimensionsloser Form
H = p2 q :
2 4
2q2 + 10
1. Zeichnen Sie das Potential.
2. Berechnen Sie die vier tiefsten Energieniveaus.
3. Zeichnen Sie die Wellenfunktionen der vier tiefsten Niveaus zusammen mit dem
Potential.
4. Man kann auch die Matrixelemente von q 2 und q 4 direkt angeben, indem man die
Operatoren analog zu (2.4) durch a und ay ausdrückt. Verbessert das die Ergeb-
nisse?
Literatur
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
F. Schwabl, Quantenmechanik, Springer Verlag, 1988.
Physik
Wir betrachten eine Wechselspannung V (t), den zugehörigen Wechselstrom I (t)
und schreiben beide als komplexwertige Funktionen:
V (t) = V0 ei!t ;
I (t) = I0 ei!t ; (2.9)
wobei V0 und I0 komplexe Größen sind, deren Phasendifferenz gerade angibt, wie
stark die Strom- der Spannungsschwingung vor- oder nacheilt. Eigentlich hat nur
der Realteil von (2.9) eine physikalische Bedeutung, aber die Phasenbeziehungen
sind in komplexer Schreibweise besonders leicht zu formulieren. Das Ohmsche Ge-
setz lautet damit
V0 = Z I0 (2.10)
mit einem komplexen Widerstand Z . Für einen ohmschen Widerstand R, für eine
Kapazität C und für eine Induktivität L gilt
1 ; Z = i!L ;
Z = R ; Z = i!C (2.11)
wobei R; C und L reelle Größen sind, z. B. in den Einheiten Ohm, Farad und Hen-
ry. Für ein elektrisches Netzwerk gelten die folgenden Erhaltungssätze, auch als
Kirchhoffsche Regeln bekannt:
1. Wegen der Ladungserhaltung ist an jedem Knoten die Summe der einlaufenden
Ströme ist gleich der Summe der auslaufenden Ströme.
2. Entlang eines jeden Weges addieren sich die Teilspannungen über jedem Bau-
element zu der Gesamtspannung über den Weg.
Diese beiden Bedingungen ergeben zusammen mit dem Ohmschen Gesetz ein Glei-
chungssystem, das alle unbekannten Ströme und Spannungen bestimmt.
Als einfaches Beispiel betrachten wir einen L-C -Schwingkreis, der mit einem
Widerstand R in Serie geschaltet ist (Bild 2.4). Ve und Va seien die komplexen
Amplituden der Eingangs- und Ausgangswechselspannung mit der Kreisfrequenz
!, und IR; IC und IL seien die Amplituden der Ströme, die nach dem Einschwin-
gen dieselbe Frequenz ! wie die Eingangsspannung haben. Damit gelten folgende
Gleichungen:
Spannungsaddition : VR + Va = Ve ;
Stromerhaltung : IR = IC + IL ;
Ohmsches Gesetz : VR = R IR ; (2.12)
1 I ;
Va = i!C C
Va = i!L IL :
58 2 Lineare Gleichungen
R IR
IC IL
Ve C L Va
C L
R
Ve C L Va
wobei das Ohmsche Gesetz schon eingefügt wurde. Überraschenderweise ist das
Ergebnis für Va (! ) ganz anders als das, was wir (als Nichtelektroniker) erwar-
tet haben. Es entstehen nämlich zwei neue Resonanzen ober- und unterhalb von
! = pLC 1 , dort wird V bei kleinen Widerständen R sehr viel größer als V . Das
a e
kann man sich durch folgende Überlegung plausibel machen: Für kleine Frequen-
2.2 Elektrisches Netzwerk 59
zen wird das Verhalten des Parallelkreises durch die Induktivität dominiert. Ver-
nachlässigen wir die Kapazität im Parallelkreis einmal völlig, so haben wir es mit
einer Serienschaltung aus den Elementen R-C -L-L zu tun. Weil die gesamte Induk-
tivität jetzt 2L beträgt, erhalten wir eine Resonanz bei !1 = p21LC . Wird dagegen
für hohe Frequenzen im Parallelkreis nur die Kapazität betrachtet, so ergibt sich
eine R-C -L-C Serienschaltung mit einer Gesamtkapazität von C=2 und dement-
q
sprechend eine Resonanzfrequenz von !2 = 2
LC . Im Ergebnisteil werden wir
diese Näherung mit den exakten Resultaten vergleichen.
Bisher haben wir nur monofrequente sinusförmige Spannungen und Ströme be-
trachtet. Nun wollen wir ein beliebiges periodisches Eingangssignal Ve (t) an die
Schaltung anlegen. Das Netzwerk ist linear, also erhält man aus überlagerten Ein-
gangssignalen die entsprechend überlagerten Ausgangsspannungen. Insbesondere
kann man jede periodische Eingangsspannung Ve (t) mit der Periode T in eine Fou-
rierreihe entwickeln:
X
1
Ve(t) = Ve(n) e2 i n t=T : (2.14)
n= 1
Für jeden Summanden mit der Amplitude Ve(n) erhält man aus der Gleichung (2.13)
für die Frequenz !n = 2 n=T eine Ausgangsspannung Va (!n ) = Va(n) , so daß
das gesamte Ausgangssignal gegeben ist durch
X
1
Va (t) = Va(n) e2 i n t=T : (2.15)
n= 1
Algorithmus
In Mathematica können die Gleichungen (2.12) und (2.13) direkt eingegeben wer-
den. Obwohl man beide Systeme sofort per Hand lösen kann, wollen wir das Prinzip
doch an den einfachen Beispielen demonstrieren. Mit der Normierung Ve = 1 lauten
die Gleichungen (2.12) daher
gl1 = {vr + va == 1, ir == ic + il, vr == ir r,
va == ic/(I omega c), va == I omega L il}
Man beachte, daß das erste Gleichheitszeichen = eine Zuordnung bedeutet, während
== einen logischen Ausdruck ergibt. Der Variablen gl1 wird also eine Liste von
Gleichungen zugeordnet. Mit
Solve[gl1, {va, vr, ir, ic, il}]
60 2 Lineare Gleichungen
wird das Gleichungssystem nach den angegebenen Variablen aufgelöst. Weil Glei-
chungssysteme im allgemeinen mehrere Lösungen haben, liefert Solve eine Li-
ste mit Listen von Regeln. Da es hier aber nur eine Lösung gibt, greifen wir mit
Solve[...][[1]] davon die erste – und in diesem Fall die einzige – heraus.
Als Anwendung für eine nicht-sinusförmige Eingangsspannung Ve (t) wählen wir
eine Sägezahnspannung mit der Periode T , die wir an N äquidistanten Zeitpunkten
abtasten, um die diskrete Fouriertransformation benutzen zu können. Wir definieren
also diskrete Spannungswerte durch
X
N
ar = p1 bs e2i(s 1)(r 1)=N
N s=1
X
bzw.
N
V (t ) = p1
e r bs ei T (s
2
1)tr :
N s=1
Nicht die Fouriertransformation direkt sondern deren Inverses müssen wir hier be-
nutzen, damit das Vorzeichen im Exponenten der e-Funktion mit Gleichung (2.9)
übereinstimmt. Obwohl die Autoren von Mathematica erklären, sie wollten, was
diese Vorzeichenwahl bei der Fouriertransformation angeht, der Konvention der
p
Physiker folgen, haben sie doch genau das Gegenteil verwirklicht.
Die Amplitude bs = N gehört also zur Frequenz !s = 2T (s 1). Am Ausgang
wird jede Amplitude bs mit der Ausgangsspannung Va (!s ) multipliziert, die wir
vorher mit Solve[...] aus den obigen Gleichungen erhalten haben. Allerdings
gilt das nur für s = 1; :::; N=2. Höhere Frequenzen geben eine schlechte Näherung
für Ve (t), wie im Abschnitt 1.3 ausführlich gezeigt wurde. Man muß durch bs =
bs N die hohen Frequenzen in niedrige negative verschieben, bevor man mit Va(!s )
transformieren darf. Die transformierten Fourierkoeffizienten sind also
Ergebnisse
Die Lösung des Gleichungssystems (2.12), das die in der Abbildung 2.4 gezeig-
te Serienschaltung aus ohmschem Widerstand und L-C -Schwingkreis beschreibt,
steht im Mathematica-Programm in der Variablen vas ; in lesbarer Form lautet sie
1 1.5
0.8 1
Phase(Va)
0.5
0.6
|Va|
0
0.4 -0.5
0.2 -1
-1.5
0 20000 30000 40000
20000 30000 40000
omega omega
2.6 Frequenzabhängigkeit von Betrag und Phase der Ausgangsspannung Va (! ) für das
Netzwerk aus Abbildung 2.4. Die Kurven entsprechen den Widerständen R = 100 ,
300 , 900 , und 2700 . Je größer der Widerstand, um so schärfer ist die Resonanz.
Legen wir nun die Sägezahnspannung Ve (t) an dieses Filter an, so wird das Er-
gebnis natürlich von der Schärfe der Resonanz bei !r und von dem Verhältnis der
Grundfrequenz der Sägezahnspannung zur Resonanzfrequenz abhängen. Wir para-
metrisieren die Periode T von Ve (t) deshalb in der Form 2T = f !r ; f gibt also
das Verhältnis von Eingangsgrundfrequenz zu Resonanzfrequenz an. Für f = 1
und einer entsprechend schmalen Resonanzkurve sollte aus der sägezahnförmigen
Schwingung gerade eine Sinusschwingung mit der Frequenz ! = !r herausgefiltert
werden.
Für f < 21 und z. B. R = 200 wird im wesentlichen nur das Vielfache von 2T in
der Nähe von !r herausgefiltert. Dagegen werden für f > 1 und breiter Resonanz
62 2 Lineare Gleichungen
1 0.6
0.4
0.5
0.2
Va(t)
Ve(t)
0 0
-0.2
-0.5
-0.4
-1 -0.6
0 0.5 1 1.5 2 2.5 3 0 0.5 1 1.5 2 2.5 3
t/T t/T
2.7 Links die ursprüngliche Sägezahnspannung Ve (t) und rechts die Spannung Va (t) am
Ausgang des Filters für f = 1 und R = 2700 .
0.3 0.8
0.2 0.6
0.1 0.4
Va(t)
Va(t)
0 0.2
0
-0.1
-0.2
-0.2
-0.4
-0.3 -0.6
0 0.5 1 1.5 2 2.5 3 0 0.5 1 1.5 2 2.5 3
t/T t/T
2.8 Links die Ausgangsspannung für f = 1=3 und R = 200 , rechts das verzerrte Ein-
gangssignal, das sich mit f = 3 und R = 5 ergibt.
Für das zweite Beispiel, die Serienschaltung von R-C -L-Glied und L-C -Schwing-
kreis, liefert das Mathematica-Programm, wiederum mit Ve = 1, die Lösung:
R
CL! 2
L
C
Va =
CL! 2 + (CL! 2 1)(1 CL!2 + iCR!)
Ve C L Va
Für R = 0, wenn also der ohmsche Widerstand gleich null und damit die Schaltung
2.2 Elektrisches Netzwerk 63
s
verlustfrei ist, verschwindet der Nenner bei
p
! = 3 2LC 5 :
Mit den Werten L = 1mH , C = 1F divergiert Va also bei den Frequenzen ! =
19544 s 1 und ! = 51166:7 s 1 . Wir p
p sehen, daß unsere vorherige Abschätzung
der beiden Resonanzen bei !1 = 1= 2LC = 22360 s 1 bzw. !2 = 2=LC =
44720 s 1 nicht ganz falsch war.
3
2.5
2
|Va|
Abbildung 2.9 zeigt Va (! ) für R = 10; 30 und 90 . Für jeden Wert des Widerstan-
des R ist bei der Frequenz ! = pLC 1 die Ausgangsspannung gleich dem Eingangs-
signal, Va = Ve . Erst bei kleinen Widerständen werden die beiden Resonanzen
sichtbar.
Abschließend wollen wir die Leistung berechnen, die bei der Frequenz ! vom
Widerstand R in Wärme umgesetzt wird. Auch hierbei erweist sich die komplexe
Darstellung von Strom und Spannung als sehr vorteilhaft. Die Rechnung – zunächst
für ein allgemeines Bauelement mit komplexem Widerstand Z , das vom Strom
I (t) = IZ ei!t durchflossen wird und an dem die Spannung V (t) = VZ ei!t abfällt
– verläuft folgendermaßen: Die Leistung P ist das Zeitmittel des Produktes aus den
Realteilen des Stroms und der Spannung, also P = Re I (t) Re V (t). Wegen der
rein harmonischen Zeitabhängigkeit gilt aber Re I (t) = Im I (t + 2! ) und analog
für V (t). Damit erhalten wir
P = 12 Re I (t) Re V (t) + Im I (t) Im V (t)
= 14 I (t) V (t) + I (t) V (t)
= 41 (IZ VZ + IZ VZ )
= 21 jIZ j2 Re Z ; (2.16)
64 2 Lineare Gleichungen
0.8
0.6
P/P0
Übung
Fügen Sie im zweiten R-C -L-Netzwerk (Bild 2.5) einen ohmschen Widerstand R
zum parallelen L-C -Kreis hinzu, und zwar parallel zu Kondensator und Spule.
2. Welche Form hat eine periodische Rechteckspannung nach dem Durchgang durch
dieses Filter?
3. Wie groß ist die Verlustleistung an den beiden Widerständen als Funktion von ! ?
Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
2.3 Kettenschwingungen 65
2.3 Kettenschwingungen
Die Bewegung eines Teilchens im quadratischen Potential wird bekanntlich durch
eine besonders einfache lineare Differentialgleichung beschrieben. Wenn mehre-
re Teilchen durch solche linearen Kräfte miteinander wechselwirken, kann deren
Bewegung ebenfalls aus linearen Bewegungsgleichungen berechnet werden. Aller-
dings erhält man dann mehrere solcher Gleichungen, die miteinander verkoppelt
sind. Dieses lineare Gleichungssystem läßt sich durch Diagonalisierung einer Ma-
trix lösen. Ein schönes Beispiel dafür ist die lineare Kette mit verschiedenen Mas-
sen. Sie ist ein einfaches Modell für die Berechnung von Gitterschwingungen in ei-
nem Kristall. Die Eigenwerte einer Matrix geben die Energiebänder der Phononen
an, während die Eigenvektoren Aussagen über die Schwingungsformen der Kri-
stallbausteine machen. Durch Überlagerung solcher Eigenschwingungen kann jede
mögliche Bewegung des Modell-Festkörpers dargestellt werden.
Physik
Wir betrachten eine Kette, bestehend aus punktförmigen Massen m1 und m2 , die
wir der Einfachheit halber als leichte bzw. schwere Atome bezeichnen. Die Teilchen
seien so angeordnet, daß auf jeweils drei leichte Atome ein schweres folgt. Die Ele-
mentarzelle der Länge a enthält also vier Atome. Es sollen nur nächste Nachbarn
miteinander wechselwirken. Wir beschränken unsere Betrachtung auf kleine Aus-
lenkungen, das heißt, die Kräfte sollen lineare Funktionen der Massenverschiebun-
gen sein wie in dem nachfolgend abgebildeten Federmodell.
a
m1 m1 m1 m2
..... .....
u n-1 rn sn tn un rn+1
2.11 Lineare Kette, bestehend aus zwei Atomsorten, die durch elastische Kräfte untereinan-
der verbunden sind.
= f (sn + un 1 2rn ) ;
m1 sn = f (tn + rn 2sn) ; (2.17)
m1 tn = f (un + sn 2tn ) ;
m2 un = f (rn+1 + tn 2un ):
f ist die Federkonstante. In einer unendlich langen Kette gelten diese Gleichungen
2
für jede Elementarzelle n Z. Für die endlich lange Kette aus N Elementarzellen
nehmen wir periodische Randbedingungen an, d. h. wir stellen uns eine ringförmige
Anordnung aus N identischen Zellen vor. Da sich die Energie der Kette bei Ver-
schiebung um die Länge a nicht ändert und folglich die Bewegungsgleichungen
f
invariant sind gegenüber den Translationen rn ; sn ; tn ; un g!f
rn+k ; sn+k ; tn+k ;
g
un+k , k = 1; 2; : : : ; N , kann eine Lösung der Gleichung (2.17) durch Fourier-
transformation gefunden werden. Wir machen daher den Ansatz
0 rn(t) 1
@ stnn((tt)) C
xn(t) = B A = S(q) eiqani!t ; (2.18)
u n (t )
wobei wegen der periodischen Randbedingungen q nur die Werte q 2
N + 1; : : : ; N annehmen kann. Dann gilt
= Na ; =
2 2
x n = !2 xn; xn1 = eiqa xn : (2.19)
FS = MS : (2.21)
Dabei ist M die Massenmatrix, und wir suchen bei vorgegebenem q die Eigenwerte
S
(q) = !2(q) und die zugehörigen Normalmoden (q). In unserem Fall läßt sich
die Massenmatrix leicht invertieren, und Gleichung (2.21) ist offensichtlich äquiva-
lent zu
M 1F = : S S (2.22)
Allerdings ist M 1 F keine hermitesche Matrix. Daß die Eigenwerte dennoch
reell und nichtnegativ sind, erkennt man durch folgende Umformung von Gleichung
2.3 Kettenschwingungen 67
(2.21). Wir multiplizieren sie von links mit M , der zu M 2 inversen Matrix, und
1 1
2
erhalten
M FM M S = M S :
1
2
1
2
1
2
1
2 (2.23)
Das ist eine gewöhnliche Eigenwertgleichung für die hermitesche und positiv semi-
definite Matrix M 2 F M 2 mit dem Eigenvektor M 2 .
1 1 1
S
x S
Die so gewonnenen Eigenschwingungen n (t) = ` (q ) eiq ani!` t sind spe-
zielle komplexwertige Lösungen der Bewegungsgleichungen (2.17). Analog zu den
elektrischen Filtern (Abschnitt 2.2) erhält man die allgemeine Lösung durch Über-
lagerung der Eigenschwingungen. Die zu (2.20) konjugiert komplexe Gleichung lie-
fert mit q! S S
q , daß mit (q) auch ( q) Eigenvektor zu demselben Eigenwert
ist. Die allgemeine reelle Lösung von (2.17) hat deshalb die Form
X :
xn (t) = S `(q ) eiq an c` ei! t + c ` e
` i!` t (2.24)
;`
Die noch freien Koeffizienten c` werden durch die Anfangsbedingungen festgelegt.
massmat = DiagonalMatrix[{m1,m1,m1,m2}]
Damit bilden wir das Produkt mat2 = Inverse[massmat].mat1 . Mathe-
matica ist zwar in diesem Fall noch in der Lage, mit Eigenvalues[mat2] die
Eigenwerte allgemein anzugeben, die Rechnung ist aber langwierig und das Er-
gebnis besteht aus verschachtelten zweiten und dritten Wurzeln, so daß wir eine
numerische Berechnung vorgezogen haben.
eigenlist = Table[{x, Chop[Eigenvalues[
mat2 /.{f–>1.,m1–>0.4,m2–>1.0,q–>x}]]},
{x,–Pi,Pi,Pi/50}]
68 2 Lineare Gleichungen
Dieser Befehl liefert in kurzer Zeit eine Liste von q -Werten und den zugehörigen
vier Frequenzquadraten.
Flatten[ Table[
Map[{#[[1]],Sqrt[#[[2,k]]]}&, eigenlist],
{k,4}], 1]
macht daraus eine Liste von (q -! )-Paaren, die in Abbildung 2.12 mit ListPlot
gezeichnet wurden. Es entstehen also vier Bänder von erlaubten Frequenzen der Git-
3
2.5
2
omega
1.5
1
0.5
0 2.12 Wellenzahl q und die zugehörigen
-Pi -Pi/2 0 Pi/2 Pi vier Frequenzen der Eigenschwingungen
q der linearen Kette aus Bild (2.11).
S4 (0)
S3 (0)
S2 (0)
S1 (0)
Übung
Betrachten Sie die zweidimensionalen Vibrationen Ihres Einfamilienhauses. Fünf
gleiche Massen m sind durch Spiralfedern gekoppelt, und das Potential zwischen
V (ri ; rj ) = D2 (jri rj j ai j )2 ;
wobei aij der jeweilige Ruheabstand sein soll, also aij = l für die Kanten und das
p
Dach und aij = 2 l für die beiden Diagonalen.
Berechnen Sie für kleine Auslenkungen die Frequenzen der Vibrationen und zeich-
nen Sie die Eigenschwingungen. Besonders eindrucksvoll ist es, wenn Sie eine Ani-
mation der Eigenschwingungen herstellen.
Literatur
H. Goldstein, Classical Mechanics, Addison Wesley, 1980.
W. Ludwig, Festkörperphysik, Akademische Verlagsgesellschaft, 1978.
2.4 Hofstadter-Schmetterling
Lineare Gleichungen können faszinierende Lösungen haben. Das wird besonders
deutlich beim Kristall-Elektron im homogenen magnetischen Feld. Das Spektrum
der Energien des Elektrons hat als Funktion der Stärke des Magnetfeldes eine kom-
plizierte Struktur, die an einen Schmetterling erinnert. Es war Douglas Hofstadter,
der 1976 dieses Problem untersucht hat. Erstaunlicherweise werden in diesem Spek-
trum die Unterschiede zwischen rationalen und irrationalen Zahlen sichtbar. Wir
wollen die quantenmechanische Gleichung für die Energien des Elektrons herlei-
ten und numerisch lösen. Ein kleines Computerprogramm liefert den faszinierenden
Schmetterling.
70 2 Lineare Gleichungen
Physik
Wir modellieren ein Elektron auf einem quadratischen Gitter durch lokalisierte Wel-
lenfunktionen und Hüpfmatrixelemente zwischen nächsten Nachbarn. In solcher
tight-binding Näherung haben die Einteilchenenergien die Form
und mit den dimensionslosen Variablen m = x=a und = a2 eB=hc erhält man
schließlich für m (m) die Harper-Gleichung
Dabei wird die Energie E in Einheiten von "0 =2 gemessen. Diese diskrete Schrö-
dinger-Gleichung enthält nur noch die Parameter und . bestimmt den Impuls
in y -Richtung, während der Quotient aus magnetischem Fluß a2 B durch die Ein-
heitszelle und einem Flußquantum hc=e ist.
Ein zweidimensionales Gitterelektron im Magnetfeld wurde also auf ein Teilchen
abgebildet, das auf einer Kette im periodischen Cosinus-Potential springt. ist die
Phase des Potentials und spielt keine große Rolle, während das Verhältnis der
Periodenlänge zur Gitterkonstanten (= 1 in den m-Variablen) angibt. Hier sieht man
2.4 Hofstadter-Schmetterling 71
schon den Unterschied zwischen rationalem und irrationalem -Wert: Ist rational,
also = p=q mit ganzen Zahlen p und q , dann ist das Potential kommensurabel
zum Gitter mit der Periode q . Die Wellenfunktion hat in diesem Fall nach dem
Bloch-Theorem die Eigenschaft
Die Eigenzustände und die zugehörigen Energien werden durch k und klassifi-
ziert. Schreibt man Gleichung (2.29) in folgender Weise in Matrixform:
m+1 = M1 (m; E ) m (2.31)
m m 1
mit
M1(m; E ) = E 2 cos(21m + ) 01 ; (2.32)
Algorithmus
Die numerische Auswertung der Spurbedingung (2.34), die auf eine Nullstellen-
bestimmung eines Polynoms q -ten Grades hinausläuft, erweist sich als ziemlich
schwierig. Wir wählen deshalb einen etwas anderen Weg, der dieses Problem um-
geht. Für einen festen Wert von k und , und zwar für k = 0 und = 0, wollen
wir die Harper-Gleichung (2.29) numerisch lösen und das Ergebnis graphisch als
72 2 Lineare Gleichungen
Funktion von rationalen Werten = p=q darstellen. Dazu wählen wir ein festes
q, das eine gerade Zahl sein soll, und lassen p von 1 bis q 1 laufen. Wir nutzen
aus, daß der Potentialterm Vm = 2 cos(2mp=q ) in m gerade ist, so daß man von
q 1
f g
den Eigenvektoren m m=0 der Harper-Gleichung voraussetzen kann, daß sie ent-
weder gerade oder ungerade in m sind. Die Periodizität m+q = m reduziert in
der Tat das Eigenwertproblem (2.29) auf q unabhängige Komponenten. Durch die
erwähnte gerade-ungerade Symmetrie läßt sich dieses Problem auf zwei etwa halb
so große Eigenwertaufgaben zurückführen.
f g
Die Voraussetzung, m sei z. B. ungerade in m, also m= m , liefert uns
zunächst 0 = 0 und zusammen mit der Periodizität
q 1:
q+
2 r = q
2 r = q
2 r für r = 0; 1; : : : ; 2 (2.35)
0 V1 1 0 0 0 1
BB 1 V2 1 ... 0 C
C
BB C
C
mit Au = B C
..
BB 0.. .1.
.. .. ..
Au u=E u
. . . .
C
C (2.36)
BB . . ..
.
..
. 1 0 C
C
@0 . 1 Vq 2
..
1 A
0 0 0 1 Vq
2
2 1
q 1:
q+
2 r = q
2 r = q
2 r für r = 1; 2; : : : ; 2 (2.37)
folgendermaßen aus:
0 V0 2 0 0 0 1
BB 1 V1 1 ... 0 C
C
BB C
C
mit Ag = B C
..
BB 0.. .1.
.. .. ..
Ag g=E g
. . . .
C
C (2.38)
BB . . ..
.
..
. 1 0 C
C
@0 . 1 Vq 1
..
1 A
0 0 0 2 Vq
2
Wie im Fall der ungeraden m bleibt als Aufgabe, die Eigenwerte einer tridiagona-
len Matrix, hier diejenigen von Ag zu bestimmen.
Die Berechnung des charakteristischen Polynoms einer tridiagonalen Matrix läßt
sich auf folgende Weise rekursiv formulieren. Wir betrachten z. B. die Matrix u A
1 A
E mit u aus Gleichung (2.36) und davon wiederum die linke obere Ecke, die
aus n Zeilen und Spalten bestehen möge. Bezeichnen wir deren Determinante mit
pn (E ), so erhalten wir durch Entwickeln nach der letzten Zeile
pn(E ) = (Vn E ) pn 1 (E ) pn 2 (E ) : (2.39)
p1 (E ) = V1 E und p0 (E ) = 1 (2.40)
p0(E ); p1 (E ); p2(E ); : : : ; p q 1 (E )
2
zu finden sind, läßt sich durch den Satz von Gerschgorin eingrenzen: Für jeden
Eigenwert E einer n n-Matrix A = (aij ) gibt es ein i, so daß gilt:
X
n
jE aii j jaij j : (2.41)
j =1; j 6=i
Pn
Weil in unserem Fall j =1; j 6=i aij j j j jj j
2 und aii Vi 2 gilt, schließen wir,
daß die Eigenwerte zwischen 4 und 4 liegen.
Für die Matrix Ag , die sich leicht von Au unterscheidet, lautet der den Gleichun-
gen (2.39, 2.40) entsprechende Algorithmus:
Wir wollen noch darauf hinweisen, daß die Gleichungen (2.39) bzw. (2.42) für die
Sturmschen Ketten fast identisch zur Harper-Gleichung selbst sind. Denn aus (2.29)
folgt für die ungeraden Wellenfunktionen m= m mit den Startwerten 0 =
0; 1 = 1:
= (E V1 ) ; 3 = (E V2 ) 2 1 ; 4 = (E V3 ) 3 2 ; : : :
2
Die Wahl von 1 = 1 ist beliebig und ändert höchstens die Normierung der Wel-
lenfunktion, nicht aber deren Eigenwert. 0 = 0 folgt aus der Symmetrie. Der
Vergleich mit (2.39) und (2.40) ergibt
1 = p0 (E ) ; 2 = p 1 (E ) ; 3 = p 2 (E ) ;
= p3 (E ) ; : : : 4
Ändert sich nun die Anzahl der Vorzeichenwechsel in der Folge fpn (E )g, so ändert
sich die Anzahl der Vorzeichenwechsel in der Folge f g
n ebenfalls, und zwar
um denselben Betrag. Die Anzahl der Eigenwerte im Intervall [E1 ; E2 ] ist also
durch den Unterschied in der Anzahl der Vorzeichenwechsel von n (E1 ) und f g
f (
n 2 E g
) bestimmt. Dies erinnert an den Knotensatz der eindimensionalen Quan-
tenmechanik, den wir im Abschnitt 4.3 noch beim anharmonischen Oszillator be-
nutzen: Die Anzahl der Vorzeichenwechsel einer stationären Wellenfunktion (x)
bestimmt die Nummer des Energieniveaus über dem Grundzustand.
Der obige Algorithmus läßt sich in wenigen Programmzeilen schreiben. Wir ha-
ben in der Abbildung 2.14 eine Diskretisierung des kompletten Energieintervalls
j j
E 4 in 500 Intervalle gewählt. Nach rechts ist der Parameter = p=q für
q = 500 und p = 1; 2; : : : ; 499 aufgetragen. Die Gesamtzahl der Rechenschritte
läßt sich mit etwa 500 500 500 10 '
109 abschätzen, wobei wir zehn Re-
chenoperationen für die innerste Schleife angenommen haben. Weil Mathematica
dafür zu langsam wäre, haben wir das Programm in C geschrieben. Es besteht –
2.4 Hofstadter-Schmetterling 75
Unter dem obigen aktion ist ein C-Befehl zu verstehen, mit dem z. B. ein Punkt
auf den Bildschirm gezeichnet wird oder die entsprechenden ( -E )-Werte in ein
Datenfile geschrieben werden.
Ergebnis
Das Resultat dieses Programmes ist in der Abbildung 2.14 zu sehen. Die vertikale
Achse markiert die Energie und die horizontale den Parameter , jeweils in 500 Pi-
xel unterteilt. Die Energie wird in Pixelschritten erhöht. Immer wenn es Eigenwerte
in diesem kleinen Intervall gibt, wird der Bildpunkt gezeichnet.
76 2 Lineare Gleichungen
2
Energie
-2
-4
0.0 0.2 0.4 0.6 0.8 1.0
Fluss pro Einheitszelle
2.14 Eigenwerte der Harpergleichung als Funktion von = Ba2 =( hc e ) , d. i. der magneti-
sche Fluß durch die Einheitszelle in Einheiten des elementaren Flußquantums.
größer werdendem Nenner approximiert werden. Also liegen dicht neben einem ir-
rationalen -Wert immer unendlich viele Energiebänder. Das ergibt die kunstvolle
Zeichnung, die sich bei unendlich feiner Auflösung unserer Vorstellung widersetzt.
Übung
Schreiben Sie ein Programm, das möglichst schnell einen Hofstadter-Schmetterling
auf einem 500 500 Fenster mit = p=500 (p = 1; :::; 500) zeichnet. Nutzen Sie
die Symmetrien des Schmetterlings aus und überlegen Sie sich einen Algorithmus,
der die vielen großen Löcher überspringt.
Literatur
D. R. Hofstadter, Energy levels and wave functions of Bloch electrons in rational
and irrational magnetic fields, Physical Review B14, 2239 (1976).
J. Stoer, Numerische Mathematik 1, Springer Verlag, 1994.
J. Stoer, R. Bulirsch, Numerische Mathematik 2, Springer Verlag, 1990.
2.5 Hubbard-Modell
Quantenmechanik gehört sicherlich nicht zu den leichten Gebieten der Physik. Ort
und Impuls, Welle und Teilchen verlieren ihre anschauliche Bedeutung. Einzelne
Meßergebnisse besagen in der Regel wenig, denn die Quantenmechanik ist im Kern
eine statistische Theorie, deren Aussagen als Wahrscheinlichkeitsaussagen formu-
liert sind. Dazu kommt ein erheblicher mathematischer Apparat, in dem Zustände
eingeführt und Operatoren erklärt werden müssen.
Noch schwieriger wird die mathematische Beschreibung, wenn man die Quanten-
mechanik wechselwirkender Teilchen untersuchen will, z. B. Supraleitung in einem
Festkörper durch wechselwirkende Elektronen. Da die einzelnen Elektronen prinzi-
piell nicht unterscheidbar sind, muß man den Vielteilchenzustand geeignet aus der
Überlagerung von Produkten von Einteilchenzuständen aufbauen. Für Elektronen
führt dies zum Pauli-Prinzip: Jeder Einteilchenzustand darf nur einmal besetzt sein.
In diesem Raum der Vielteilchenwellenfunktionen läßt sich der Hamiltonoperator
als Matrix darstellen, deren Eigenwerte die Energien der stationären Zustände an-
geben.
Nur in wenigen Fällen kann man diese Matrix mit analytischen Methoden dia-
gonalisieren. Aber auch eine numerische Lösung ist nicht leicht zu gewinnen. Die
Größe des Systems und das Anwachsen der Zahl der Freiheitsgrade erweisen sich
78 2 Lineare Gleichungen
Physik
Im Prinzip werden die Vielteilchenzustände aus Produkten von Einteilchenzustän-
den aufgebaut. Es gibt aber einen Formalismus, der es erlaubt, ohne die explizite
Darstellung der Produktwellenfunktionen auszukommen; es ist die sogenannte zwei-
te Quantisierung (eine etwas irreführende Bezeichnung). Sie benutzt Erzeugungs-
und Vernichtungsoperatoren, und die Zustände können durch Anwenden von Ope-
ratoren auf das Vakuum erzeugt werden. Dabei wird der Fermionen-Charakter durch
die Operatoralgebra berücksichtigt. Der Hamiltonoperator wird ebenfalls durch Er-
zeugungs- und Vernichtungsoperatoren dargestellt, so daß die Hamiltonmatrix sich
schließlich algebraisch konstruieren läßt.
Zunächst muß man die Einteilchenzustände numerieren und eine Reihenfolge
ji
festlegen. 0 sei das Vakuum. Ein Vielteilchenzustand mit N Teilchen hat dann die
Form
cyk1 cyk2 ::: cykN 0 ;
ji (2.43)
wobei (k1 ; k2 ; : : : ; kN ) ein geordnetes N -Tupel von Indizes und ki der Index der
entsprechenden Einteilchenwellenfunktion ist. Dieser Zustand läßt sich als Deter-
r
minante von Einteilchenwellenfunktionen 'k ( ) darstellen. So gilt beispielsweise
für zwei Teilchen
hr1 ; r2jcy1 cy2 j0i = (r1; r2 ) = p1 ['1(r1)'2 (r2 ) '2 (r1)'1 (r2)] : (2.44)
2
Wie schon erwähnt, ist diese explizite Darstellung gar nicht erforderlich. Bei ortho-
normalen Einteilchenzuständen ist allein die Antisymmetrie fermionischer Zustände
wichtig, die durch folgende Operatoralgebra dargestellt wird:
und
cM # jf1; 0; : : : ; 0g; f0; : : : ; 0; 1gi = cM # cy1" cyM # j0i = cy1" cM # cyM # j0i
= cy1" j0i + cy1" cyM # cM # j0i
= cy1" j0i = jf1; 0; : : : ; 0g; f0; : : : ; 0gi :
Allgemein gilt bei Anwendung von cyk oder ck auf einen Zustand
n
Sie produziert gerade so oft einen Faktor 1 wie es in von 0 verschiedene Ein-
träge vor der Position k gibt. Damit können wir die Wirkung der Erzeuger und
Vernichter folgendermaßen schreiben:
Die 1 steht an der Position k , und der Faktor (1 nk ) sorgt dafür, daß es keine
Doppelbesetzung desselben Zustands gibt. Analog gilt:
Algorithmus
Wir wollen wieder Mathematica benutzen, um die Darstellung der Operatoralgebra
(2.45) durch die Gleichungen (2.51) und (2.52) kompakt zu formulieren. Statt des
j i
Symbols : : : verwenden wir in Mathematica den Kopf z und notieren die Viel-
teilchenzustände in der Form
und nk 2f g0; 1 . Wir brauchen den Kopf z, da wir die Zustände addieren und mit
Zahlen multiplizieren müssen. Würden wir dies nur mit der Liste arg ausführen, so
würden wir falsche Ergebnisse erhalten. Die wesentlichen Manipulationen betreffen
aber das Argument von z. So erhält man z. B. nk aus arg[[sigma, k]] mit k
"
= k und sigma = 1 für = bzw. sigma = 2 für = . #
Nach Vorgabe der Zahlen M; N" und N# erzeugen wir mit den Funktionen Per–
mutations[..] und Table[..] die Liste index, die alle überhaupt mögli-
chen Zustände enthält. Der dabei benutzte Befehl Flatten[..] beseitigt eine
Klammerebene. Für M = 3; N" = 2 und N# = 1 erhalten wir z. B.
index = {{{1,1,0}, {1,0,0}}, {{1,1,0}, {0,1,0}}, {{1,1,0}, {0,0,1}},
Der Operator cyk muß in dem Argument von z eine 1 an der richtigen Stelle erzeu-
gen. Dies geschieht durch die Funktion plus :
plus[k_,sigma_][arg_]:= ReplacePart[arg,1,{sigma,k}]
Entsprechend erzeugt minus eine 0. Unter Verwendung der oben eingeführten Vor-
zeichenfunktion (2.50) können wir jetzt analog zu (2.51) und (2.52) den Operator
cyk durch seine Wirkung auf Zustände definieren:
cdagger[k_,sigma_][factor_.*z[arg_]]:= factor*
(1 – arg[[sigma,k]])*
sign[k,sigma,arg]*
z[plus[k,sigma][arg]]
Der Parameter factor_. wird in Mathematica auf den Wert 1 gesetzt, falls der
Zustand keinen zusätzlichen Faktor hat. Da durch diese Operatoren auch immer der
Wert 0 erzeugt werden kann, z. B. ist cy1" 1; : : : ; : : : = 0, muß cdagger auch
jf g f gi
für die Zahl 0 definiert werden:
cdagger[k_,sigma_][0]:= 0
82 2 Lineare Gleichungen
Analog wird ck durch c[k_,sigma_] definiert. Außerdem brauchen wir noch
n
die Operatoren k :
n[k_,sigma_][0]:= 0
n[k_,sigma_][factor_.*z[arg_]]:= factor*
arg[[sigma,k]]*z[arg]
Der Hamiltonoperator (2.48) der Hubbard-Kette lautet dann einfach
H[vector_]=Expand[
–t*Sum[cdagger[k,sigma][c[k+1,sigma][vector]]+
cdagger[k+1,sigma][c[k,sigma][vector]],
{k,sites},{sigma,2} ]+
u*Sum[n[k,1][n[k,2][vector]] ,{k,sites}]
]
Die Länge M der Kette ist hier mit sites bezeichnet. Um die Hamiltonmatrix zu
hn j jn i
bekommen, brauchen wir die Skalarprodukte i H j zwischen i und H j .jn i jn i
Da unsere Vielteilchenzustände jni orthonormiert sind, müssen wir nur noch die
Linearität des Skalarproduktes definieren:
scalarproduct[a_,0]:= 0
scalarproduct[a_,b_ + c_]:= scalarproduct[a,b] +
scalarproduct[a,c]
scalarproduct[z[arg1_],factor_. z[arg2_]]:=
factor*If[arg1==arg2,1,0]
Die Antilinearität im ersten Argument wird hier nicht benötigt. Man beachte, daß
der Vergleich zweier Zustände, in diesem Fall also der Vergleich zweier geschachtel-
ter Listen, in Mathematica durch arg1==arg2 sehr kompakt geschrieben werden
kann.
hn j jn i
Die folgende Tabelle liefert die gesuchte Hamiltonmatrix i H j :
h = (hlist = Table[H[z[index[[j]]]], {j, end}];
Table[ scalarproduct[ z[index[[i]]], hlist[[j]]],
{i,end}, {j,end}])
Die obere Grenze der Laufindizes ist vorher durch end = Length[index] be-
stimmt worden.
Mit Eigenvalues[..] und Eigensystem[..] erhält man dann die Ener-
gien und die stationären Zustände des Vielteilchenproblems. Den Grundzustand fil-
tern wir heraus mit der Befehlskombination
g[uu_]:= Sort[Thread[ Eigensystem[
N[ h /. {t –> 1.0, u –> uu} ]]]][[1,2]]
2.5 Hubbard-Modell 83
1 X
M X
M X
M hgjnk"nk# jgi = M1 jgnj2 nk"(n) nk# (n) : (2.54)
k=1 k=1 fng
Das Mathematica-Äquivalent von Gleichung (2.54) ist
Sum[Sum[Abs[g[u][[j]]]ˆ2*index[[j,1,k]]*index[[j,2,k]],
{j,end}], {k,sites}] / sites
Dies läßt sich, da die Summen vertauschbar sind und als Skalarprodukte angesehen
werden können, auf folgende Weise sehr kompakt formulieren:
(Abs[g[u]]ˆ2).Map[#[[1]].#[[2]]&, index] / sites
Ergebnisse
Für M = 3 Plätze und N" = 2; N# = 1 findet Mathematica die Energien noch
analytisch. Dazu schreiben wir mit
TeXForm[Eigenvalues[h]] >> hubbard.tex
das Ergebnis in TEX-Form in eine Datei, fügen die mathematische Umgebung und
einige Zeilenumbrüche hinzu und übersetzen sie mit TEX bzw. LATEX. Das Ergebnis
sehen Sie auf der nächsten Seite.
Abbildung 2.16 zeigt diese Energien als Funktion des Verhältnisses U=t von
Coulomb- und kinetischer Energie. Für U = 0 gibt es keine
8
6
Energie/t
4
2
0
-2
0 1 2 3 4 5 6
2.16 Energie-Eigenwerte des Hubbard-
Modells in Abhängigkeit von U=t für
U/t
M = 3; N" = 2 und N# = 1.
84 2 Lineare Gleichungen
f0; u; u; 1
23 27 t2 u2
2u +
3 r 3 2 ! 13
3 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
r 3 2 ! 31
162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
323
1
23 27 t2 u2
2u +
3 r 3 2 ! 13
3 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
r 3 2 ! 31
162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
323
1+i
p3 27 t2 u2
2u +
3
2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
p3 r 3 2 ! 31
1 i 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
623
1+i
p3 27 t2 u2
2u +
3 2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
p3 r 3 2 ! 31
1 i 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
623
i 3
1
p
27 t2 u2
2u +
3
2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
p3 r 3 2 ! 31
1+i 162 t2 u+16 u3 18 u 9 t 2 + u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 ;
623
p
1 i 3 27 t2 u2
2u +
3
2 r 3 2 ! 31
323 162 t2 u+16 u3 18 u 9 t2 +u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
p3 r 3 2 ! 31
1+i 162 t2 u+16 u3 18 u 9 t 2 + u2 + 4 27 t2 u2 + 162 t2 u+16 u3 18 u 9 t2 +u2
1 g
623
2.15 Eigenwerte einer 9 9-Hubbard-Matrix, die von Mathematica wegen der Symmetrie der
Matrix nicht nur numerisch, sondern allgemein als Funktion von U und t gefunden werden
können. Umwandlung in die obige Form mit der Funktion TeXForm[..].
Wechselwirkung zwischen den Elektronen, also können wir die Energieniveaus da-
durch berechnen, daß wir Einteilchenniveaus auffüllen. Bei periodischen Randbe-
2.5 Hubbard-Modell 85
X
M
jk i = p1 e i k l cy j0i ;
l
M l=1
E = 2 t cos k :
Für M = 3 erhalten wir als Einteilchen-Energien 2 t; t und nochmal t. In diese
" #
Niveaus können 2 Spin - und 1 Spin - Teilchen gesetzt werden, wobei allerdings
"
die Doppelbesetzung zweier -Spins verboten ist. Dies ergibt folgende 9 Niveaus,
in Übereinstimmung mit Abbildung 2.16 :
zweifach entartet: "1 = 3 t ;
fünffach entartet: "2 = 0 ;
zweifach entartet: "3 = 3 t :
6
Daß auch für U = 0 außer dem einen Niveau mit " = 0 alle anderen zweifach
entartet sind, liegt an der Translations- und Spiegelsymmetrie dieses Modells. Die
mittlere Doppelbesetzung im Grundzustand für M = 4 Plätze und sogenannter
Halbfüllung, d. h. N" + N# = M , hier für N" = 2 und N# = 2, zeigt Ab-
bildung 2.17. Für U !1
ist Doppelbesetzung natürlich verboten. Die nächsten
0.18
0.16
Doppelbesetzung
0.14
0.12
0.1
0.08
0.06
0 1 2 3 4 5 6 2.17 Mittelwert der Doppelbesetzung im
Grundzustand in Abhängigkeit von U=t
für M = 4, N" = 2 und N# = 2.
U/t
20
15
10
Energie/t
-5
0 1 2 3 4 5 6
U/t
N N
läßt sich, wenn außerdem noch M" = M# = 12 gilt, im Limes M die Grund- !1
zustandsenergie pro Platz für beliebiges U=t in geschlossener Form angeben. Es
gilt:
-0.4
Energie pro Platz/t
-0.6
-0.8
-1
2.19 Grundzustandsenergie pro Platz für
-1.2 das halbgefüllte Band. Die gestrichelte
Kurve ist das exakte Resultat für M !
0 1 2 3 4 5 6
1 , die durchgezogene Linie beschreibt
U/t die Werte für M = 6 .
2.5 Hubbard-Modell 87
Übung
Die z -Komponente des Spinoperators am Platz i läßt sich durch die Teilchenzahl-
n n
operatoren i " und i # ausdrücken: Siz = 1=2 ( i"n n
i# ). Berechnen Sie für den
P hj ji
Grundzustand g mit M = 4 Plätzen und N" = N# = 2 die Spinkorrelationen
P hj
M ji M ji
M i=1 g Si Si+1 g und M i=1 g Si Si+2 g in Abhängigkeit von U=t.
1 z z 1 z z
Literatur
J. E. Hirsch, Two-dimensional Hubbard model: Numerical simulation study, Physi-
cal Review B31, 4403 (1985).
H. Q. Lin, J. E. Gubernatis, Exact diagonalization methods for quantum systems,
Computers in Physics 7, 400 (1993).
A. Montorsi [ed.], The Hubbard model: A Reprint Volume, World Scientific, 1992.
Kapitel 3
Iterationen
Eine Funktion besteht aus einer Menge von Anweisungen, die gegebene Eingabe-
in Ausgabewerte umwandeln. Gehört nun die Ausgabe selbst zur Definitionsmen-
ge der betrachteten Funktion, so kann sie selbst wieder zur Eingabe werden, und
die Funktion liefert neue Ausgabewerte. Dies kann dann beliebig oft wiederholt
werden. Während es oft keine analytischen Möglichkeiten gibt, die strukturellen Ei-
genschaften solcher Iterationen von der Form xt+1 = f (xt ) zu berechnen, sind sie
im Computer leicht zu realisieren. Man muß offenbar nur dieselbe Funktion f (x)
immer wieder auf das Ergebnis anwenden. Wir wollen dies an einigen Beispielen
demonstrieren.
3.1 Populationsdynamik
Die wohl bekannteste Iteration einer nichtlinearen Funktion ist die sogenannte logi-
stische Abbildung. Sie ist eine einfache Parabel, die die reellen Zahlen des Einheits-
intervalls in sich selbst abbildet. Wir wollen sie hier vorstellen, weil jeder Wissen-
schaftler die Eigenschaften einer so elementaren Iteration kennen sollte.
Ein einfacher Mechanismus führt zu komplexem Verhalten – dies ist das Ergebnis
der wiederholten Anwendung einer quadratischen Abbildung. Obwohl es nur we-
nige analytische Ergebnisse dazu gibt, kann jeder die Iteration leicht auf einem Ta-
schenrechner nachvollziehen. Bei gewissen Parameterwerten der Parabel findet man
ein unregelmäßiges Umherspringen der iterierten Zahlen im Einheitsintervall. Die
Zahlenfolge ist dann extrem empfindlich auf Änderungen des Startwertes der Iterati-
on. Eine wohldefinierte Abbildungsvorschrift liefert eine Zahlenfolge, die schon bei
geringer Anfangsungenauigkeit praktisch unvorhersagbar ist. Ein solches Verhalten
nennt man deterministisches Chaos.
Einige Größen, die man mit dem Computer berechnet, sind nicht nur das Er-
gebnis einer mathematischen Spielerei, sondern man findet diese Zahlen in vielen
Experimenten beim Übergang vom regelmäßigen zum chaotischen Verhalten wie-
der. Solche Universalität quantitativer Größen ist ein weiterer faszinierender Aspekt
dieser Gleichung.
90 3 Iterationen
Physik
Wir betrachten die Iteration
dx ;
xn+1 xn ' dn
so wird Gleichung (3.1) zur Näherung der Differentialgleichung
dx = (4r 1)x 4r x2
dn
mit der Lösung
4r 1
x(n) = 4r + const :
e(1 4r)n
Für r < 14 ist x1 = 0 ein Attraktor, während für r > 41 alle Startwerte x(0) > 0
zum Wert x1 = 1 41r laufen. Wie in der diskreten Iteration hat diese Gleichung
3.1 Populationsdynamik 91
Für r > r0 = 14 hat die Gleichung (3.1) den Fixpunkt x = f (x ) mit x = 1 41r .
Wir betrachten nun eine kleine Abweichung x + "0 vom Fixpunkt und iterieren
'
diese. Wegen f (x + "0 ) f (x ) + f 0 (x )"0 = x + f 0 (x )"0 gilt für kleine "n :
Daher explodiert die Störung "0 für jf 0 (x )j > 1, was r > r1 = 34 entspricht. Wir
werden sehen, daß dann die xn nach einigen Schritten zwischen den Werten x1 und
x2 hin- und herspringen:
x1 = f (x2 ) ; x2 = f (x1 ) ;
(3.3)
also xi = f (f (xi )) für i = 1; 2 :
Die iterierte Abbildung f (2) (x) = f (f (x)) hat demnach für gewisse r -Werte zwei
stabile Fixpunkte. p
j j
Nun gilt f (2)0 (xi ) > 1 für r > r2 = (1 + 6)=4. Daher zeigt dasselbe
Argument wie oben, daß der Zweierzyklus für r > r2 instabil wird, die xn laufen in
einen Viererzyklus. Diese Verdoppelung der Perioden setzt sich bis ins Unendliche
'
bei r1 0:89 fort.
Eine Verdoppelung der Periodenlänge bedeutet eine Halbierung der Frequenz; es
entstehen also Subharmonische im Frequenzspektrum. Bei rl wird der 2l 1 -Zyklus
instabil und ein 2l - Zyklus entsteht. Für l!1 drängen sich die rl -Werte immer
dichter an r1 heran, und zwar mit folgender Gesetzmäßigkeit:
rl r1 cl : (3.4)
Daraus folgt
= llim rl rl 1 :
!1 rl+1 rl
(3.5)
Die Zahl heißt Feigenbaumkonstante und hat den Wert = 4:66920::: Sie ist des-
halb so wichtig, weil sie eine universelle Größe ist; sie wird für viele verschiedene
Funktionen f (x) beobachtet. Auch Experimente an realen nichtlinearen Systemen,
die durch Periodenverdoppelung ins Chaos übergehen, zeigen dieselbe Zahl.
Für größere r -Werte erhält man chaotische Bänder: xn scheint zufällig in einem
oder mehreren Intervallen ohne Periode hin- und herzuspringen. Dies gilt, obwohl
die xn -Werte nicht zufällig, sondern durch die wohldefinierte Parabel f (x) aus Glei-
chung (3.1) erzeugt werden. Ein solches Verhalten nennt man, wie schon erwähnt,
deterministisches Chaos.
92 3 Iterationen
Im chaotischen Bereich kann man an der einfachen Parabel eine wesentliche Ei-
genschaft des deterministischen Chaos studieren: die Empfindlichkeit auf Anfangs-
bedingungen. Zwei extrem dicht benachbarte Startwerte trennen sich schon nach
wenigen Iterationen und springen scheinbar unabhängig voneinander in den chao-
tischen Bändern umher. Zur quantitativen Charakterisierung kennzeichnen wir die
beiden Trajektorien durch xn und xn + "n . Dann gilt für "0 0 !
"n ' "0 e n : (3.6)
heißt Ljapunow-Exponent; er mißt die Empfindlichkeit auf den Anfangszustand.
Ein positiver Exponent > 0 bedeutet Chaos. Es gilt
j j'
f (n) (x0 + "0 ) f (n)(x0 ) "0 e n : (3.7)
Im Limes "0 ! 0 gibt dies gerade die Ableitung der n-fach Iterierten f (n)(x0 ) =
f (f ( f (x0)) ). Mit der Kettenregel erhält man sofort
1 n 1X
= nlim
!1 n i=0
ln f 0 (xi ) :
j j (3.8)
f g
Um zu bestimmen, muß also nur eine Bahn xi berechnet und dabei der Loga-
rithmus der Steigung von f an den Stellen xi aufsummiert werden.
Algorithmus
Mit Mathematica kann man die Funktion f[x ] = 4 r x (1–x) einfach mit
iterf[n ]:= Nest[f,x,n]
n-mal iterieren. Wesentlich schwieriger ist aber die genaue Bestimmung der Ver-
zweigungspunkte rl und damit der Feigenbaumkonstanten . r1 und r2 kann man
durch Lösen der beiden Gleichungen f (l) (x ) = x und j dfdx (x )j = 1 für
l ( )
die Unbekannten x und rl finden, entweder per Hand oder mit der Mathematica-
Funktion FindRoot. Aber höhere rl -Werte konnten wir damit nicht bestimmen.
Es genügt jedoch, sogenannte superstabile periodische Bahnen zu betrachten. Dies
sind Bahnen, die bei x0 = 21 starten und nach 2l Schritten dort wieder ankom-
men. Wegen f 0 21 = 0 konvergieren Abweichungen von x0 sehr schnell gegen
den 2l -Zyklus. In jedem Intervall [rl ; rl+1 ] gibt es nun eine superstabile Bahn der
Periode 2l bei einem Wert Rl . Die Rl -Werte skalieren dabei wie die rl -Werte mit
der Feigenbaumkonstanten gegen r1 (siehe Gleichung (3.5)).
1
Nun ist es wiederum nicht einfach, die Gleichung
f (2l ) 1
2 =2
3.1 Populationsdynamik 93
die man durch Iteration oder mit FindRoot lösen kann. Die Sequenz CRLR be-
stimmt die Vorzeichen der geschachtelten Wurzeln in Gleichung (3.9). Nach dem
anfänglichen CR, das nicht in der obigen Gleichung auftritt, gibt ein L ein positives
und ein R ein negatives Vorzeichen. Dies gilt für sämtliche superstabilen periodi-
schen Bahnen. Die Periode 5 mit der Sequenz CRLRR, die zwischen chaotischen
Bändern liegt, findet man also bei einem -Wert, der folgender Gleichung genügt:
s r q
= + p :
Die Erzeugung der Sequenz haben wir mit Mathematica folgendermaßen program-
miert: Für das Symbol R (L) schreiben wir die Zahlen 1 (0), die Sequenz der Länge
2n wird als Liste periode[n] gespeichert. Am Anfang wird für n = 1 die Li-
ste periode[1]= {c,1} gesetzt, und die Verdoppelung der Sequenz geschieht
durch
periode[n_]:= periode[n]=
Join[periode[n–1], correct[periode[n–1]]]
Dabei muß noch das Symbol c durch 0 oder 1 ersetzt werden, je nachdem, ob die
Häufigkeit, mit der die Zahl 1 auftaucht (= Summe der Listenelemente), ungerade
oder gerade ist.
correct[list_]:=Block[{sum=0,li=list,l=Length[list]},
Do[sum+=li[[i]],{i,2,l}];
If[OddQ[sum],li[[1]]=0,li[[1]]=1];
li]
Die vielfach verschachtelte Wurzel der Bestimmungsgleichung für erhält man mit
g[n_,mu_]:=Block[{x=Sqrt[mu],l=Length[periode[n]]},
Do[x=Sqrt[mu+(–1)ˆ(periode[n][[i]]) x],{i,l,3,–1}];
x]
Schließlich wird diese Gleichung numerisch gelöst, wobei die Genauigkeit, mit der
FindRoot die Lösung berechnet, heraufgesetzt werden muß:
genau=30
maxit=30
fr[n_]:=fr[n]=(find=FindRoot[g[n,mu]==mu,
{mu,{15/10,16/10}},
AccuracyGoal–>genau,
WorkingPrecision–>genau,
MaxIterations–>maxit];
mu/.find)
3.1 Populationsdynamik 95
Wenn man sich die Bahnen x0 ; x1 ; x2 ; x3 ::: für alle Parameter r (bzw. ) erzeugen
und graphisch darstellen will, so sollte man möglichst eine schnelle Programmier-
sprache verwenden, da für jeden r -Wert etwa 1000 Iterationen notwendig sind. Im
Prinzip ist dies aber sehr einfach: Als r -Wert wählt man z. B. die x-Koordinate der
Pixel auf dem Bildschirm. Zu jedem r -Wert berechnet man zunächst etwa 100 xn -
Werte, bis die xn dem Attraktor sehr nahe gekommen sind. Danach berechnet man
weitere 1000 xn -Werte, rechnet sie in y -Koordinaten der Pixel um und zeichnet
einen Bildpunkt am Pixel (x; y ). In der Sprache C lautet dies:
xit = 4.*r*xit*(1.–xit);
putpixel( r*MAXX, (1.–xit)*MAXY,WHITE);
Dabei wird der Parameter r über Tastendruck schrittweise erhöht oder erniedrigt.
Auch die Dichte der xn -Werte ist interessant. Um sie darzustellen, unterteilt man
die x-Achse in kleine Intervalle, z. B. von der Größe der Pixelabstände. Jedes Inter-
vall erhält eine y -Koordinate, die am Anfang auf den Wert y = 0 gesetzt wird. Bei
der Iteration der Parabel für einen festen r -Wert fällt jeder xn -Wert in ein solches
Intervall, wobei die jeweilige y -Koordinate um eine Pixeleinheit erhöht wird und
am entsprechenden (x; y )-Pixel ein Punkt gezeichnet wird. Somit erhält man ein
Histogramm der xn -Werte, das der Dichte der Punkte auf dem Attraktor entspricht.
Dies geschieht mit folgender Funktion:
void kanal( double r)
{
double xit=.5;
int x,y[600],i;
clearviewport();
for (i=0;i<MAXX;i++) y[i]=0;
rectangle(0,0,MAXX,300);
while(!kbhit())
{ xit=4.*r*xit*(1.–xit);
x=xit*MAXX;
y[x]++;
putpixel(x,300–y[x],WHITE);
}
getch();getch();clearviewport();return;
}
Ergebnisse
Abbildung 3.1 zeigt die Iteration von x0 = 0:65 für r = 0:87. Die xn -Werte laufen
in einen Attraktor mit der Periode 4, der durch die Fixpunkte der vierfach iterierten
96 3 Iterationen
Abbildung f (x) beschrieben wird. Diese sind in Abbildung 3.2 zu sehen. f (4) (x)
schneidet die Gerade y = x achtmal, nur vier davon aber sind stabile Fixpunkte.
0.8
0.7
x(n)
0.6
0.8
0.6
0.4
0
ihre Iterierten f (2) und f (4) .
0 0.2 0.4 0.6 0.8 1 Die vierfach iterierte Funktion
x hat acht Fixpunkte.
Erhöht man r , so entstehen Attraktoren mit den Perioden 8; 16; 32; :::; bis bei r1 =
0:89::: der Übergang ins Chaos stattfindet. Dies sieht man deutlich in den Abbil-
dungen 3.3 und 3.4, in der 1000 xn -Werte nach einer Übergangszeit von etwa 100
Schritten als Funktion von r aufgetragen sind. Attraktoren der Periode p sind also
als p Punkte zu sehen, während chaotische Bahnen mehrere Intervalle auf der Ver-
tikalen füllen. Da nur höchstens 1000 Punkte für jeden r -Wert gezeichnet wurden,
bekommt man auch einen Eindruck von der Dichte der xn -Werte. Diese ist aber
deutlicher in dem Histogramm in Abbildung 3.5 zu sehen. Periodische Bahnen mit
der Periode p erscheinen als Linienschar mit p Spitzen, während chaotische Bahnen
zwischen verschiedenen Bändern mit jeweils stetigen Dichten hin- und herspringen.
Die Abbildung 3.5 zeigt die chaotische Bewegung dicht unterhalb eines Fünferzy-
klus; dort gibt es zwar nur ein Band, man sieht aber noch die fünf Spitzen des be-
3.1 Populationsdynamik 97
3.4 Ein Ausschnitt aus der vorigen Abbildung für r = 0:88 bis r = 1.
nachbarten Zyklus. Es läßt sich zeigen, daß für r = 1 nur ein Band mit der Dichte
(x) = 1 p 1
x(1 x)
existiert. In Abbildung 3.4 sieht man im chaotischen Bereich viele Fenster mit
98 3 Iterationen
periodischen Bahnen. Das größte Fenster hat die Periode 3, das beim Parameter
p
r = ( 8 + 1)=4 beginnt. In diesem Fenster gibt es wieder Periodenverdoppelung:
Mit wachsendem r erhält man die Perioden 3; 6; 12; 24; :::, bis ein chaotischer Be-
reich erscheint. Tatsächlich kann man zeigen, daß alle Perioden vorkommen.
Einen weiteren Eindruck der logistischen Abbildung xn+1 = f (xn ) erhält man,
indem man in der x-y -Ebene die aufeinanderfolgenden Parabelpunkte (xn ; f (xn ));
(xn+1 ; f (xn+1 )); : : : geometrisch konstruiert. Man gewinnt den jeweils nächsten
Punkt dadurch, daß man vom aktuellen Punkt horizontal bis zur Winkelhalbierenden
y = x geht und von dort aus senkrecht bis zur Parabel y = 4 r x(1 x). Die
nächsten zwei Abbildungen zeigen diese Konstruktion, die sich mit Mathematica
relativ leicht ausführen läßt.
Die Skalengesetze (3.4) und (3.5) bestimmen die universelle Feigenbaumkonstante
. Dazu berechnen wir die Parameter Rl, bei denen es superstabile Bahnen mit der
Periode 2l gibt. Mit der Methode der symbolischen Dynamik und der inversen Ite-
ration finden wir mit 30 Stellen Genauigkeit, von denen wir hier nur 12 ausdrucken:
R10 = 0:892486338871
R11 = 0:892486401027
R12 = 0:892486414339
R13 = 0:892486417190
R14 = 0:892486417801
R15 = 0:892486417932
3.1 Populationsdynamik 99
0.8
0.6
0.4
0.2
0.8
0.6
0.4
0.2
3.7 Drei chaotische Bänder für r =
0
0:9642 kurz oberhalb des großen Fen-
0.2 0.4 0.6 0.8 1 sters mit dem Dreierzyklus.
Bemerkenswert ist, daß der letzte Wert aus der Lösung einer Gleichung mit einer
32768 fach verschachtelten Wurzelfunktion gewonnen wird!
Mit
l = RRl 1 RRl 2
l l 1
finden wir folgende Näherungswerte für :
10 = 4:669201134601
11 = 4:669201509514
100 3 Iterationen
12 = 4:669201587522
13 = 4:669201604512
14 = 4:669201608116
15 = 4:669201608892
Daraus schätzen wir ab, daß wir bis auf 9 Stellen genau berechnet haben. Dem
Leser sei es als Übungsaufgabe überlassen, l für l !1
zu extrapolieren.
Zum Schluß wollen wir noch eine scheinbar einfache Frage untersuchen: Gege-
ben seien x0 = 1=3 und r = 97=100. Was ist der Wert von x100 ? Dies scheint sich
leicht beantworten zu lassen; mit
h[x ]:= 97/25 x(1–x)
gibt
Nest[h, N[1/3],100]
den Wert x100 = 0:144807. Dieser Wert aber ist falsch, der richtige Wert ist x100 =
0:410091.
Die Lösung des Widerspruchs liegt im chaotischen Verhalten der logistischen
Abbildung für den gegebenen Parameterwert. Der Ljapunow-Exponent, definiert in
den Gleichungen (3.6) bis (3.8), ist positiv. Also führen kleine Ungenauigkeiten in
der Rechnung schon nach wenigen Iterationen zu großen Fehlern. Wegen des Be-
40
Ergebnisgenauigkeit
30
Wert 0 gesetzt werden. Der Befehl Precision[x] fragt die Genauigkeit von x
ab. Abbildung 3.8 zeigt das Ergebnis. Für genau=16 wird gerundet, also ändert
sich die Genauigkeit scheinbar nicht. Die richtige Berechnung zeigt aber, daß man
erst bei mehr als 60 Stellen Rechengenauigkeit das korrekte Ergebnis erhält. Der
Grund für den linearen Zusammenhang zwischen Rechen- und Ergebnisgenauigkeit
ist uns nicht bekannt.
Übung
1. Berechnen Sie für die logistische Abbildung (3.1) den Ljapunow-Exponenten als
Funktion des Parameters r .
2. Im chaotischen Bereich gibt es in jedem r -Intervall Fenster mit superstabilen pe-
riodischen Bahnen. Jede solche Bahn beginnt mit der symbolischen Dynamik CRL.
Für einen Fünferzyklus gibt es daher höchstens die vier Möglichkeiten CRLRR;
CRLRL; CRLLR und CRLLL. Eine dieser Möglichkeiten kommt aber nicht
vor. Berechnen Sie die Parameterwerte der drei verbleibenden Bahnen mit der Peri-
ode fünf.
Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
Hao Bai-Lin, Chaos, World Scientific, 1984.
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
H. O. Peitgen, D. Saupe, The Science of Fractal Images, Springer Verlag, 1988.
M. Schröder, Fraktale, Chaos und Selbstähnlichkeit, Spektrum Akademischer Ver-
lag, 1994.
H. G. Schuster, Deterministic Chaos, Physik Verlag, 1984.
Physik
Unser System ist eine eindimensionale Anordnung von unendlich vielen Punktmas-
2
sen, deren Ruhelagen durch die Plätze xn (n Z) gekennzeichnet seien. Die Kräfte
auf die Teilchen sollen zum einen von einem äußeren periodischen Potential V (x)
und zum anderen von einem Wechselwirkungspotential W (xn xn 1 ) zwischen
benachbarten Teilchen herrühren, so daß die Energie eines langen Teilstückes der
Kette, das die Plätze xM +1 ; xM +2 ; : : : ; xN umfaßt, durch
X
N
HMN = [V (xn ) + W (xn xn 1 )] (3.10)
n=M +1
gegeben ist. Alle Längen x werden in Einheiten der Periode des äußeren Potentials
gemessen. Das bedeutet
V (x + 1) = V (x) : (3.11)
In der Ruhelage kompensieren sich alle Kräfte auf jedes Teilchen, es gilt also
0 = @H MN 0 0 0
@x = V (xn) + W (xn xn 1 ) W (xn+1 xn) : (3.12)
n
Mit der Definition
pn = W 0(xn xn 1 ) (3.13)
folgt hieraus
pn+1 = pn + V 0 (xn) ;
xn+1 = xn + (W 0) 1 (pn+1 ) ; (3.14)
xn 1 = xn (W 0 ) 1 (pn ) ;
pn 1 = pn V 0 (xn 1 ) : (3.15)
3.2 Frenkel-Kontorova-Modell 103
Aus (x0 ; p0 ) – äquivalent dazu ist die Vorgabe von (x 1 ; x0 ) – erhält man die Paare
(x1 ; p1 ) und (x 1 ; p 1 ), daraus die Werte (x2 ; p2 ) und (x 2 ; p 2 ) und so fort. Die
Gleichungen (3.14) beschreiben daher eine nichtlineare Iteration in der x-p-Ebene.
f
Jeder Startpunkt (x 1 ; x0 ) bestimmt eindeutig einen Zustand : : : ; x 2 ; x 1 ; x0 ;
g
x1 ; x2 ; : : : der gesamten Kette, bei dem sich jedes Teilchen in Ruhelage befindet.
Die Funktionaldeterminante der Abbildung (xn ; pn ) ! (xn+1 ; pn+1 ) hat den
@ (x n+1 ;pn+1 )
= 1; die Abbildung ist daher flächenerhaltend. Obwohl
Wert eins, @ (xn ;pn )
ein Ausschnitt aus der x-p-Ebene durch die Abbildung deformiert wird, hat sein
Bild denselben Flächeninhalt wie der ursprüngliche Ausschnitt. Flächenerhaltender
Fluß im Phasenraum ist aus der klassischen Mechanik bekannt (Satz von Liouville),
und tatsächlich kann man (3.14) als Momentaufnahmen (Poincaré-Schnitt, siehe
Abschnitt 4.2) einer kontinuierlichen Dynamik in einem dreidimensionalen Phasen-
raum auffassen.
Bisher wurden die Potentiale V und W noch nicht spezifiziert, doch nun sollen
sie auf ein äußeres Cosinus-Potential und lineare Federkräfte beschränkt werden:
K bestimmt die Stärke des periodischen Potentials, und ist der Abstand der Teil-
chen für K = 0 in Einheiten der Periodenlänge des Potentials. Wir modifizieren
Gleichung (3.13), die pn = xn xn 1 liefert, geringfügig und setzen
pn = xn xn 1 : (3.17)
Statt (3.14) erhalten wir dann
Für gegebene Parameter K und ist die mittlere Energie pro Teilchen
h = N lim 1 H :
M !1 N M MN
(3.20)
104 3 Iterationen
h ist eine Funktion von x0 und p0 , wobei der Grundzustand durch den Punkt (x0; p0 )
mit der kleinsten Energie h bestimmt ist.
Eine interessante Eigenschaft eines Zustandes wird durch die sogenannte Win-
dungszahl w beschrieben, die als mittlerer Abstand benachbarter Teilchen definiert
ist:
w = hxn+1 xn i = N lim xN xM :
M !1 N M
(3.21)
Falls ein Zustand relativ zum Gitter periodisch ist (ein kommensurabler Zustand),
so gibt es ganze teilerfremde Zahlen P und Q mit xn+Q = xn + P . Daraus folgt
P:
w = xn+QQ xn = Q (3.22)
Algorithmus
Die Programmierung der Abbildung (3.18) ist sehr einfach. In Mathematica definie-
ren wir, weil es um numerische Manipulationen geht, pi=N[Pi] und die Funktion
t durch
list[x0_,p0_]:= NestList[t,{x0,p0},nmax]
Das Ergebnis von list[ ] ist eine Liste von nmax+1 Punkten in der x-p-Ebene
und beschreibt damit den physikalischen Zustand für die gegebenen Startwerte x0
und p0 = x0 x 1 . Nach Vorgabe der Lagen x0 und x 1 zweier benachbarter
Teilchen liefert list[] also die Positionen der weiteren Teilchen.
Ein anschauliches Bild der resultierenden Zustände erhalten wir, indem wir auf
f g
die Kurve V (x) die Teilchen mit den Koordinaten xn ; V (xn ) legen und diese
Punkte mit ListPlot zeichnen. Die Koordinaten xn werden aus dem Ergebnis
von list[..] mit dem Befehl
xlist[x0_,p0_]:= Map[First,list[x0,p0]]
3.2 Frenkel-Kontorova-Modell 105
herausgezogen.
Schon beim Pendel haben wir gesehen, daß es nützlich ist, anstatt der Funktion xn
das Phasenraumdiagramm in der x-p-Ebene zu betrachten (beim Pendel statt '(t)
das '_ (')-Diagramm). Wir brauchen dazu aber nur x und p jeweils im Intervall
[0; 1] darzustellen, denn die Abbildung (3.18) gibt dieselben Werte (modulo 1),
wenn zu xn oder pn jeweils der Wert 1 addiert wird.
Die Modulo-Abbildung kann man mit Map in eine Liste hineinziehen und auf die
einzelnen Koordinaten wirken lassen:
tilde[{x_,p_}]:= {Mod[x,1],Mod[p,1]}
listt[x0_,p0_]:= Map[tilde,list[x0,p0]]
Mit ListPlot wird das Phasenraumdiagramm erzeugt. Die Energie und die Win-
dungszahl sind leicht aus dem Zustand ll1 = list[x0,p0] zu berechnen:
de[{x_,p_}]:=k/(2 pi)ˆ2 (1–Cos[2 pi x])+(p–sigma)ˆ2/2
h[x0_:.0838,p0_]:=
( ll1=list[x0,p0];
ll2=Map[de,ll1];
Apply[Plus,ll2]/Length[ll2])
wind[x0_:.0838,p0_]:=
( w1=xlist[x0,p0]; (w1[[–1]] – w1[[1]])/nmax)
Allerdings dauert die Berechnung mit Mathematica wieder sehr lange. Deshalb wol-
len wir uns das Phasenraumdiagramm mit einem C-Programm noch einmal auf dem
Bildschirm direkt erzeugen. Außerdem sollen die Energie und die Windungszahl be-
rechnet werden. Der Startpunkt wird vom Programm zufällig ausgewählt.
Die Funktion (3.18) lautet in C:
pneu= p+K/2./pi*sin(2.*pi*x);
xneu= x+pneu;
Eigentlich sollten in dieser innersten Schleife, in der diese Befehle sehr oft aus-
geführt werden, die Ausdrücke K/2./pi und 2.*pi nicht jedesmal neu berech-
net, sondern durch Konstanten ersetzt werden. Bei unserem Programm benötigt die
Graphik aber so viel Computerzeit, daß wir auf die Optimierung des Algorithmus
verzichten. Die x-p-Werte werden nun in Bildkoordinaten umgerechnet:
xb=fmod(xneu,1.)*xmax+10;
yb=fmod(pneu,1.)*ymax+100;
und es wird ein Bildpunkt an die Stelle (xb,yb) gezeichnet; z. B. auf dem PC mit
106 3 Iterationen
putpixel(xb,yb,color);
Bei jedem Aufruf wird die Farbe neu gewählt:
color= random(getmaxcolor())+1;
So erhält man auf dem Bildschirm eine Graphik mit verschiedenen Trajektorien,
deren jede einen Zustand repräsentiert, in jeweils unterschiedlichen Farben.
Ergebnisse
Abbildung 3.9 zeigt die Ergebnisse der Iteration der Gleichung (3.18) für K = 1 .
Dabei wurden die Startwerte (x0 ; p0 ) zufällig im Einheitsquadrat gewählt, und es
3.9 Trajektorien in der x-p-Ebene. Auf der Workstation kann ein neuer Startwert mit der
Maus angeklickt werden, und die Trajektorie wird in einer neuen Farbe gezeichnet.
wurden jeweils 10000 Werte für (xn ; pn ) mit dem C-Programm berechnet und ge-
zeichnet. Dieses Bild ist unabhängig von dem Verhältnis der konkurrierenden
3.2 Frenkel-Kontorova-Modell 107
0.5
0.475
0.45
p 0.425
0.4
0.375
3.10 Die Startwerte (x0 ; p0 )
= (0:08; 0:34) ergeben eine
0.35
Wir wollen uns dies mit Mathematica für w = 2 ansehen. Zunächst lösen wir mit
5
FindRoot die Gleichung
Mod[t[t[t[t[t[{x0,p0}]]]]],1] == {x0,p0}
Allerdings muß man den Startwert ziemlich dicht bei der Lösung angeben, sonst fin-
det die Routine keine Lösung. Wir erhalten z. B. für (x0 ; p0 ) den Wert (0:0838255;
0:336171) als einen der Q = 5 Fixpunkte der fünffach iterierten Funktion t[x,p].
Abbildung 3.10 zeigt nun einen inkommensurablen Zustand mit (x0 ; p0 ) = (0:08;
0:34), also dicht beim periodischen Zustand in der Mitte der fünf Inseln. Er hat die-
selbe Windungszahl w = 0:4 und eine etwas höhere Energie als der periodische Zu-
stand. Abbildung 3.11 zeigt den fastperiodischen Zustand im Ortsraum. Man sieht
108 3 Iterationen
beim Teilchen in der Potentialmulde, daß die Tallage ein wenig um das Minimum
oszilliert. Etwa dieselbe Tallage wird nach Q = 5 Iterationen wieder erreicht. Man
sieht die Oszillation noch besser in Abbildung 3.12, in der die xn -Werte direkt ge-
gen n aufgetragen sind. Neben der Periode mit Q = 5 gibt es noch eine Welle mit
'
Q 30.
0.05
0.04
0.03
0.02
3.11 Dieselbe fastperiodische
0.01
Trajektorie wie in Abbildung
3.10, jedoch auf das Potential
V (x) gezeichnet.
0
0 1 2 3 4
0.8
0.6
x(n)
0.4
0.2
3.12 Wie in den Abbildungen
0 3.10 und 3.11, jedoch als Aus-
0 20 40 60 80 100 lenkung x (modulo 1) des n-ten
n Atoms gezeichnet.
Neben den null- und eindimensionalen Bahnen gibt es in Abbildung 3.9 noch Zu-
stände, die ganze Flächenstücke füllen. Solche Bahnen springen chaotisch auf dem
Bildschirm hin und her. Manche Bahnen durchmessen offenbar den ganzen x- und
p-Bereich. Letzteres gilt nicht für kleine K -Werte. Für K < Kc = 0:971635::: gibt
es eindimensionale Bahnen, die das gesamte Bild horizontal durchlaufen (sogenann-
te KAM-Trajektorien). Man kann zeigen, daß chaotische Bahnen die eindimensio-
nalen nicht überspringen können, sie sind also auf ein p-Intervall zwischen zwei
KAM-Trajektorien beschränkt. Bei Kc verschwindet die letzte KAM-Trajektorie,
p
und zwar diejenige mit der irrationalsten“ Windungszahl, dem inversen goldenen
Schnitt w = 2=(1 + 5) = 0:618: : .
”
Wir sind aber nicht allein an den Eigenschaften der Standard-Abbildung interes-
3.2 Frenkel-Kontorova-Modell 109
siert, sondern suchen denjenigen Zustand, der die tiefste Energie zu einem gegebe-
nen -Wert hat. Wir können das Minimum im Prinzip finden, indem wir h(x0 ; p0 )
für verschiedene (x0 ; p0 )-Werte berechnen. In der Praxis gibt es aber bessere Me-
thoden, die wir hier nicht vorstellen (siehe z. B. Griffiths). Abbildung 3.13 zeigt
0.029
0.028
Energie
0.027
0.026
0.025
0.024 3.13 Energie für = 0:4 ei-
nes kräftefreien Zustandes mit
Startwert x0 = 0:0838 als
0.2 0.25 0.3 0.35 0.4
p0 Funktion von p0 .
h(x0 ; p0) in einem Schnitt durch die x0 -p0 -Ebene für festes x0 = 0:0838 und
= 2=5. Die zugehörigen Windungszahlen w sind in Abbildung 3.14 zu se-
hen. Für p0 ' 0:35 nimmt h im betrachteten Intervall ein Minimum an. Wenn
wir das globale Minimum der Energie finden wollen, müssen wir die Funktion
h(x0 ; p0) in der gesamten x0 -p0 -Ebene absuchen. Am Minimum scheint w in den
Wert w = = 0:4 eingerastet“ zu sein. Wenn man für alle -Werte das genaue
”
0.5
0.475
0.45
Windungszahl
0.425
0.4
0.375
0.35
0.325
0.2 0.25 0.3 0.35 0.4
3.14 Mittlerer Nachbarabstand
w für die kräftefreien Zustände
p0 aus Abbildung 3.13 .
es gibt auch zu allen irrationalen Windungszahlen einen -Wert und einen zugehöri-
gen Grundzustand. Dieses Verhalten kann mathematisch bewiesen werden.
Die Funktion w( ), die sich aller Vorstellungskraft widersetzt, entsteht aus dem
Wettbewerb zweier Längen. Die zu den rationalen w-Werten gehörenden kommen-
surablen Grundzustände entsprechen einzelnen Punkten in der x-p-Ebene, während
man zeigen kann, daß die inkommensurablen Grundzustände keinen flächenfüllen-
den chaotischen Trajektorien sondern nur Linien entsprechen. Inkommensurable
Zustände können übrigens ohne Energieänderung über das Cosinus-Potential ge-
zogen werden.
Übung
Zeichnen Sie für verschiedene K -Werte von Gleichung (3.18) Trajektorien in der
x-p-Ebene. Für K = 0 sollten Sie die Bahnen mit der Hand zeichnen können. Beob-
achten Sie, wie die geschlossenen Bahnen, die sogenannten KAM-Trajektorien, mit
wachsendem Wert von K in Inseln oder chaotische Bahnen übergehen, und berech-
nen Sie die Windungszahlen der übriggebliebenen KAM-Trajektorien. Versuchen
Sie, kurz vor Kc die letzte geschlossene Bahn zu finden.
Literatur
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
H. G. Schuster, Deterministic Chaos, Physik Verlag, 1984.
R.B. Griffiths, Frenkel-Kontorova models of commensurate-incommensurate phase
transitions, Fundamental Problems in Statistical Mechanics VII, p. 69-110, H. van
Beijeren, Editor, Elsevier Science Publisher, 1990.
J.M. Greene, A method for determining a stochastic transition, J. Math. Phys. 20,
1183 (1979).
Flußpegel, alles dies kann durch eine gebrochene Dimension D beschrieben wer-
den. Neben dem geometrischen Spiel werden wir in den folgenden Abschnitten noch
Aggregate und Perkolationscluster als weitere Beispiele für diese merkwürdigen
selbstähnlichen Gebilde kennenlernen.
Hier wollen wir uns zunächst mit der Definition der fraktalen Dimension beschäf-
tigen. Danach stellen wir zwei Programme vor, die auf verschiedene Arten das
Sierpinski-Gerüst konstruieren, das oft als Standard-Beispiel für Fraktale beschrie-
ben wird.
Physik
Die räumliche Dimension D eines Objektes kann man durch die Beziehung zwi-
schen der Anzahl seiner Elemente, die seine Masse M ausmachen, und seiner Aus-
dehnung L angeben:
M LD :/ (3.23)
Wenn man also die Massen zweier gleichartiger homogener Würfel mit den Kan-
tenlängen L und 2L vergleicht, erhält man
M2 = 2L
D
M1 L = 2D (3.24)
D = Llim log M :
!1 log L
(3.25)
Es gibt auch einen anderen Weg, um die Dimension D zu bestimmen. Dazu über-
decken wir das Objekt vollständig mit kleinen Würfeln der Kantenlänge ". Es sei
/
N (") die kleinste Anzahl solcher Würfel. Dann gilt N (") " D bzw.
D = "lim log N (") :
!0 log "
(3.26)
3
Für einen Würfel benötigen wir (L=") überdeckende Kästchen, während die An-
2 1
zahl für ein Quadrat (L=") und für eine Linie (L=") beträgt.
Wenn wir also z. B. die Länge einer Grenze auf einer Landkarte bestimmen wol-
len, so können wir einen kleinen Maßstab mit der Länge " nehmen und die Zahl
112 3 Iterationen
N (") der Schritte bestimmen, die wir zum Abschreiten der Grenzlinie benötigen.
Dann sollte eigentlich
L = " N (") (3.27)
ein Maß für die Länge sein, denn wir erwarten als Grenze ein eindimensionales Ob-
jekt mit D = 1 . Auf diese Weise haben die Spanier die Länge ihrer Grenze zu
Portugal mit 987 km angegeben, während die Portugiesen aber dieselbe Grenze mit
1214 km bestimmt haben. Ein kleinerer Maßstab " benötigt offenbar mehr über-
deckende Schritte als L=", also kann nicht D = 1 gelten. Deshalb wird Gleichung
(3.27) eine Länge L ergeben, die von " abhängt. Eine genauere Analyse der Daten
zeigt folgendes: Eine Grenzlinie ist ein Fraktal mit 1 < D < 2, daher gibt Glei-
chung (3.27) L / "1 D , also eine scheinbar divergierende Länge für " 0. Die !
Grenze hat gar keine wohldefinierte Länge! Dies kann natürlich nur für Maßstäbe
" gelten, die größer als die kleinste (z. B. die Meßlatte der Vermessungsingenieure)
und kleiner als die größte Länge (z. B. die Ausdehnung von Portugal) sind.
Ein anderes einfaches Beispiel, bei dem die fraktale Dimension D nicht mit der
Einbettungsdimension d, also der Dimension des Raumes übereinstimmt, in dem
sich das Objekt befindet, ist eine Zufallsbewegung im d-dimensionalen Raum. Die-
ser Zufallsweg wird auch als einfaches Modell für ein Polymermolekül diskutiert,
das aus vielen Monomeren besteht. Dabei nehmen wir an, daß der Abstand benach-
barter Monomere konstant ist, die Winkel zwischen je drei aufeinanderfolgenden
aber unabhängig und zufällig verteilt sind. Die Verbindungsvektoren i benachbar- r
ter Monomere sind dann Zufallsvektoren mit leicht zu berechnenden Eigenschaften.
h i
Im Mittel ::: verschiedener Molekülkonfigurationen gilt:
hrii = 0; hri rj i hri i hrj i
= 6
= 0 fur i = j und 2 = a2 ; hri i
wobei a der Abstand benachbarter Monomere sein soll. Für den Vektor zwischen R
Anfang und Ende des Moleküls, das aus N + 1 Monomeren bestehen möge, gilt:
X
N
R= ri ;
i=1
X
und damit
N
hRi = hri i = 0 ;
i=1
N X
X N X N X
hR 2i = hri rj i = hri 2i + hri rj i = Na2 :
i=1 j =1 i=1 i6=j
Da die Masse M proportional zur Zahl N der Monomere und die lineare Ausdeh-
q
nung L proportional zu hR i
2 wächst, gilt also
M / L2
3.3 Fraktales Gitter 113
Wähle drei Punkte p1; p2 und p3 und einen Startpunkt q0 beliebig in der Ebene.
Ausgehend vom Punkt qn, konstruiere den nächsten Punkt qn+1 auf folgende
p
Weise: Wähle zufällig (z. B. mit einem Würfel) einen der drei Punkte i . Dann
q p
berechne die Mitte der Verbindungslinie zwischen n und i , also
Die Startwerte sind in der Typendeklaration direkt mit angegeben. In jedem Iterati-
onsschritt wird nun einer der drei Punkte p[i] durch das Ziehen einer Zufallszahl
2f g
i 0; 1; 2 ausgewählt,
pw = p[(3*rand())/RAND_MAX]
Dann wird an dieser Stelle ein Bildpunkt gezeichnet, z. B. auf dem PC mit
Diese Funktion wird mit dem Befehl Map auf die ganze Liste von Dreiecken wie-
derholt angewendet. Der Befehl Polygon produziert schließlich Dreiecke als Gra-
phikobjekte, die mit Show gezeichnet werden:
plot1:= Block[ {listzw,plotlist},
listzw=Map[verv,list];
list=Flatten[listzw,1];
plotlist=Map[Polygon,list];
Show[Graphics[plotlist],
AspectRatio –> Automatic]
]
3.16 Durch wiederholtes Herausschneiden von Dreiecken wird ein Fraktal mit der Dimensi-
'
on D 1:58 erzeugt.
Abbildung 3.16 zeigt das Ergebnis. Wir erhalten offenbar die gleiche Struktur wie
im vorherigen Würfelspiel. Jetzt können wir aber leicht einsehen, daß das selbstähn-
liche Gerüst im Limes unendlich vieler Iterationen ein Fraktal ist. Wenn wir eine
116 3 Iterationen
Kante der Länge L eines Dreiecks halbieren, so reduziert sich offenbar seine Masse
M um den Faktor 3. Nach t Schritten gilt
Mt = 3 t M ; Lt = 2 t L :
Daraus folgt
D = tlim ln Mt = lim ( t) ln 3 + ln M = ln 3 :
!1 ln Lt t!1 ( t) ln 2 + ln L ln 2
Das Sierpinski-Gerüst hat daher die gebrochene Dimension D = 1:58::: ; es füllt
zwar keine Fläche, ist aber mehr als eine Linie. Seine Dichte = M=L2 ist null,
und jedes noch so kleine Dreieck sieht genauso aus wie ein großes.
Es ist bemerkenswert, daß sich die Natur der Fraktale bedient, um z. B. jede Stel-
le eines Körpers effektiv mit Blut zu versorgen oder um platzsparende direkte Ver-
bindungen von 1011 kommunizierenden Nervenzellen in unserem Gehirn zu erzeu-
gen. Die Technik konnte die Fraktale bisher nur wenig nutzen. Das Buch von M.
Schröder allerdings beschreibt den Einsatz fraktaler Reflektoren in der Akustik.
Übung
Eine Koch-Kurve ist durch folgende Iteration definiert: Aus einer Strecke wird das
mittlere Drittel herausgetrennt und dafür eine Ausbuchtung mit gleicher Kantenlän-
ge wie im folgenden Bild hinzugefügt. Starten Sie mit einem gleichseitigen Dreieck
und iterieren Sie die obige Konstruktion für jede Kante möglichst oft. Sie erhalten
dann die Kochsche Schneeflocke.
Literatur
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
H. O. Peitgen, D. Saupe, The Science of Fractal Images, Springer Verlag, 1988.
M. Schröder, Fraktale, Chaos und Selbstähnlichkeit, Spektrum Akademischer Ver-
lag, 1994.
H. G. Schuster, Deterministic Chaos, Physik Verlag, 1984.
Stan Wagon, Mathematica in Aktion, Spektrum Akademischer Verlag, 1993.
3.4 Neuronales Netzwerk 117
Physik
Das Perzeptron besteht aus einer Eingabeschicht von Neuronen“ Si , einer weiteren
Schicht von N synaptischen“ Gewichten wi (i = 1; :::; N ) und aus einem Aus-
”
”
118 3 Iterationen
gabeneuron S0 , das mit allen Eingabeneuronen direkt über Synapsen verkoppelt ist.
Wie bei realen Nervenzellen reagiert das Element S0 auf die Summe der Aktivitäten
derjenigen Neuronen, die über die synaptischen Verbindungen direkt auf S0 einwir-
ken können. Schon 1943 wurde dieser recht komplexe zeitabhängige Vorgang durch
eine einfache mathematische Gleichung beschrieben:
X
N !
S0 = sign Sj wj : (3.28)
j =1
Dabei kann jedes Neuron nur zwei Zustände annehmen: Es ruht (Si = 1) oder
2
es sendet Impulse (Si = 1). Die Koeffizienten wi R modellieren die Stärke, mit
der das ankommende Signal des Neurons Si durch die Synapse in ein elektrisches
Potential im Kern von S0 umgewandelt wird. Die reelle Zahl wi beschreibt komple-
xe biochemische Prozesse; eine Synapse kann beispielsweise hemmend (wi < 0)
oder erregend (wi > 0) sein. Wenn die Summe der Potentiale den Schwellenwert 0
überschreitet, dann feuert das Neuron (S0 = +1), sonst ruht es (S0 = 1).
Dies ist die biologische Motivation für die Gleichung (3.28). Mathematisch de-
f
finiert sie eine Boolesche Funktion +1; 1 N g !f g
+1; 1 , die jede der mögli-
S
chen Eingaben = (S1 ; S2 ; : : : ; SN ) nach +1 oder 1 klassifiziert. Es existieren
S
2N verschiedene Eingaben .N Im allgemeinen kann man jede davon mit +1 oder
1 markieren, also gibt es 2(2 ) Boolesche Funktionen; für N = 10 erhält man die
unvorstellbar große Zahl 10308 .
Das durch Gleichung (3.28) charakterisierte Perzeptron definiert aber nur speziel-
S w
le Boolesche Funktionen. Geometrisch gesehen sind und = (w1 ; w2 ; : : : ; wN )
Vektoren im N -dimensionalen Raum. Gleichung (3.28) trennt die Ausgaben S0 = 1
und S0 = 1 durch die (N 1)-dimensionale Hyperebene wS = 0. Daher nennt
man das Perzeptron auch eine linear separable Boolesche Funktion. Man kann zei-
gen, daß deren Anzahl kleiner als 2(N ) ist, für N = 10 aber immerhin noch 1030 .
2
Was bedeutet nun Lernen und Verallgemeinern für das durch Gleichung (3.28)
beschriebene Perzeptron? Ein Neuronales Netzwerk erhält weder Regeln noch Pro-
gramme, sondern Beispiele. In unserem Fall bestehen die Beispiele aus einer Men-
x x
ge von Eingabe/Ausgabe-Paaren, ( ; y ) mit = (x 1 ; x 2 ; : : : ; x N ), y 2
f g
+1; 1 und = 1; :::; M , die von einer unbekannten Abbildung geliefert wer-
den. Wie bei realen Nervenzellen lernt unser Netzwerk durch synaptische Plasti-
zität“ , d. h. es paßt die Stärke seiner Gewichte wi an die Beispiele an. Im günstig-
”
sten Fall kann das Perzeptron nach der Lernphase alle Eingaben richtig klassifizie-
ren:
wx
y = sign ( ) : (3.29)
Schon seit den sechziger Jahren sind effektive Lernregeln für das Perzeptron be-
kannt. Bereits 1949 hat D. Hebb postuliert, daß Synapsen sich an die Aktivität ihrer
3.4 Neuronales Netzwerk 119
Bei der Präsentation des -ten Beispiels ändert sich jede Synapsenstärke wi ein we-
nig, und zwar proportional zum Produkt aus Eingabe- und Ausgabeaktivität. Wenn
x
nur ein Beispiel ( ; y ) gelernt werden soll, sieht man leicht, daß Synapsen aus Glei-
chung (3.30) die zu lernende Bedingung (3.29) perfekt erfüllen (xj 2f g
+1; 1 ) :
N
wx=
X y x x = y X
N
xj xj = y :
j =1 N j j N j =1
(3.31)
O
Allerdings geht das nicht mehr, wenn N Neuronen M = (N ) Beispiele lernen
sollen; in diesem Fall muß man Gleichung (3.30) ein wenig abändern. Jedes Beispiel
soll nur dann mit Gleichung (3.30) gelernt werden, wenn es noch nicht richtig durch
w
das momentane abgebildet wird:
Dies ist die bekannte Perzeptron-Lernregel, für die Rosenblatt 1960 einen mathema-
x
tischen Konvergenzbeweis gefunden hat: Wenn die M Beispiele ( ; y ) überhaupt
durch ein Perzeptron richtig abgebildet werden können, dann stoppt der Algorith-
mus (3.32). In diesem Fall findet die Lernregel (3.32) also immer einen Gewichts-
w
vektor , einen von vielen, der für alle Beispiele die Gleichung (3.29) erfüllt.
Da dieses Lehrbuch Algorithmen betont, wollen wir den Beweis hier vorstellen.
z x
Mit der Definition = y suchen wir also ein w
mit wz > 0 für =
w w z
1; :::; M . Nach Voraussetzung soll es ein solches mit c > 0 für alle
geben. Die Konstante c > 0 entspricht dem kleinsten Abstand der Punkte zu z
w
der durch definierten Hyperebene.
w 0
Wir starten nun den Algorithmus mit (t = 0) = . t soll diejenigen Lernschrit-
te zählen, bei denen die Gewichte geändert werden, bei denen also (t) w z 0
gilt. Bei jedem solchen Schritt t liefert die Lernregel
z 2 = Pj z2 = N ist.
Beachten Sie, daß ( ) j
Iteriert man Gleichung (3.34) von 0 bis t, so erhält man mit w(0) = 0:
(w(t))2 Nt : (3.35)
oder
t N (wc2) = t :
2
(3.40)
Damit ist die Zahl t der durchgeführten Lernschritte beschränkt, der Algorithmus
stoppt nach höchstens t Schritten. Er endet aber nur, wenn alle Beispiele richtig
abgebildet werden. Die Perzeptron-Regel kann also alle lernbaren Probleme auch
wirklich perfekt lernen.
Wenn sehr viele Beispiele gelernt werden sollen, wird der Abstand c zur Hyper-
ebene klein und damit die Zahl t der Lernschritte sehr groß. Das bedeutet, daß man
eventuell jedes Beispiel sehr oft lernen muß, bis schließlich alle richtig klassifiziert
werden.
Wieviele Beispiele kann ein Perzeptron überhaupt lernen? Das hängt offenbar
von der unbekannten Abbildung ab, die die Beispiele erzeugt. Wenn diese von einem
anderen Perzeptron stammen, dann kann nach dem obigen Konvergenz-Theorem
jede Anzahl M gelernt werden. Wenn dagegen die Klassifikationsbits y zufällig
gewählt sind, dann gibt es wieder exakte Aussagen: Für M < N können alle Bei-
spiele perfekt gelernt werden, im Limes N !1 sogar (mit Wahrscheinlichkeit 1)
für M < 2N .
3.4 Neuronales Netzwerk 121
Nach der Lernphase kann das Perzeptron verallgemeinern. Das bedeutet, daß es
S
eine Eingabe , die es vorher nicht gelernt hat, genauso klassifiziert wie die unbe-
kannte Abbildung, von der es gelernt hat. Wenn die Lehrer“-Funktion für eine Ein-
S
gabe das Resultat S0 liefert, dann ist ein Maß g für die Verallgemeinerungsfähig-
”
keit folgendermaßen definiert
wobei über viele Eingaben S gemittelt wird. g = 1=2 ist das Ergebnis von zufälli-
gem Raten, das Perzeptron kann in diesem Fall nicht verallgemeinern. Bei g > 1=2
dagegen hat das Perzeptron in den gelernten Beispielen eine gewisse Regelmäßig-
keit erkannt und stimmt mit der Wahrscheinlichkeit g mit dem Lehrer“ überein.
”
Wir wollen nun das Perzeptron benutzen, um Zeitreihen zu analysieren und Vor-
hersagen für den nächsten Zeitschritt zu machen. Es sei eine Folge von Bits gegeben,
z. B.
Dann lernt das Perzeptron das Beispiel (x ; F +N ) mit der Rosenblatt-Regel (3.32)
bzw. (3.33), schiebt das Fenster um ein Bit nach rechts und macht eine neue Vor-
x
hersage für die Eingabe +1 . Dies wird iteriert und eine Trefferrate g bestimmt.
F
Wenn die Folge eine Periode M hat, dann gibt es offenbar M Beispiele und für
M < N kann das Perzeptron diesen ”Rhythmus“ perfekt lernen. Eine Zufallsfolge
dagegen wird immer eine Trefferrate von g = 50% liefern. Wir wollen selbst eine
Bitfolge eingeben und testen, ob und wie gut ein einfaches Perzeptron deutliche
bzw. unbewußte Regelmäßigkeiten daran erkennen kann.
Algorithmus
Dazu programmieren wir das Perzeptron in der Sprache C. Die Neuronenaktivität
wird im Feld neuron[N] und die synaptischen Gewichte in weight[N] gespei-
chert. Die Variable input erhält das nächste Bit. Es wird immer nur das letzte
Beispiel gelernt. Der Lern- und Vorhersage-Algorithmus (3.32) und (3.44) lautet
dann einfach:
122 3 Iterationen
while (1) f
1. Einlesen:
if (getch() == ’1’) input=1; else input = –1; runs++;
2. Potential berechnen:
for (h=0., i=0; i<N; i++) h += weight[i] * neuron[i];
3. Treffer der Vorhersage zählen:
if(h*input >0) correct++;
4. Lernen:
if(h*input < 0)
for (i=0; i<N; i++)
weight[i] += input*neuron[i]/(float)N;
5. Fenster verschieben:
for (i=N–1; i>0; i––) neuron[i] = neuron[i–1];
neuron [0]= input;
g /* end of while */
Der wesentliche Teil des Programmes nn.c besteht also wirklich nur aus fünf Zei-
len. Alles übrige ist Initialisierung und Bildschirmgraphik. Die Trefferrate in der
Form correct/ runs*100.0 wird jedes Mal ausgedruckt, ebenfalls die Stärke
der Gewichte und das Ergebnis der Vorhersage. Nach der Taste n wird neu gezählt,
und mit e verläßt man das Programm.
Die Version nnf name übernimmt die Eingaben 1 und 0 aus der Datei name.
Wir wollen hier kurz zeigen, wie man Argumente aus der Kommandozeile überneh-
men und eine Datei lesen kann. Die Funktion main enthält nun Argumente
main(int argc, char *argv[])
argc enthält die Anzahl der Eingabeworte, hier argc=2. Die beiden Feldkom-
ponenten argv[0] und argv[1] enthalten die Adressen des Programmnamens
(nnf) und des Arguments (name). Wird kein Name eingegeben, so soll er abge-
fragt und eingelesen werden. Mit diesem Namen wird dann die entsprechende Datei
zum Lesen geöffnet.
FILE *fp;
char str[100];
if(argc==1) { printf("Welche Eingabedatei?");
scanf("%s", str);
}
else strcpy(str, argv[1]);
if((fp=fopen(str,"r"))==NULL)
{ printf("Datei nicht vorhanden");
exit(1); }
3.4 Neuronales Netzwerk 123
Ergebnis
Der Aufruf nn stellt das Perzeptron auf dem Bildschirm graphisch dar (Bild 3.17).
Die Bitfolge aus der Tastatureingabe 1 oder 0, dargestell als roter bzw. grüner Punkt,
ist zwar 20 Schritte weit zu sehen, das Perzeptron greift aber nur die letzten 10 Bits
ab und macht eine Vorhersage für die folgende Eingabe. Diese wird natürlich nicht
angezeigt, sondern das Ergebnis der Übereinstimmung wird erst nach der Eingabe
ausgedruckt. Den Lernvorgang sieht man an der Änderung der synaptischen Ge-
wichte, die als violette Balken gezeichnet werden. Die Trefferrate g ist das wesent-
liche Ergebnis; g > 50% bedeutet, daß das Perzeptron eine Struktur in der Bitfolge
erkannt hat.
124 3 Iterationen
1010101010:::
Nach wenigen Schritten hat das Netzwerk diese zwei Muster gelernt und liefert nur
noch richtige Vorhersagen. Wechselt man dann die Folge zu einer anderen Periode,
z. B.
111001110011100::: ;
so hat das Perzeptron ebenfalls nach wenigen Schritten diese Folge perfekt gelernt.
Eine Rückkehr zum vorherigen Rhythmus gelingt natürlich wieder perfekt. Da die
w
Stärke der Synapsen aber durch den gesamten Lernvorgang beeinflußt wird, hat
w andere Koeffizienten als vorher.
Nun versuchen wir, 1 und 0 zufällig einzutippen. Wir haben dies mit Studen-
ten unserer Vorlesung getestet, die jeweils etwa 1000 mal die beiden Zeichen in
möglichst zufälliger Folge in eine Datei geschrieben haben. Die Auswertung mit
nnf ergab eine mittlere Trefferrate von g = 60%, mit Werten von 50% g
80%. Offenbar ist es recht schwierig, Zufallsfolgen per Hand zu erzeugen. Oft gibt
schon die Vorhersage 1 ! !
0 bzw. 0 1 eine Trefferrate g > 50%. Das Perzeptron
erkennt recht schnell solche Rhythmen.
Fünf Zeilen eines Computerprogrammes sind also in der Lage, unsere Reaktio-
nen mit einer gewissen Wahrscheinlichkeit g vorherzusagen. Umgekehrt sollten wir
allerdings auch in der Lage sein, das Netzwerk zu überlisten, denn das Perzeptron
ist ein einfaches deterministisches System, das wir genau berechnen können. Wir
können daher im Prinzip ausrechnen, welche Vorhersage das Netzwerk machen wird
und dann genau das Gegenteil eintippen. So sollte es uns gelingen, die Trefferrate g
weit unter 50% zu drücken.
In der Tat lieferte ein Student eine Bitfolge ab, die g = 0 ergab. Später räumte
er allerdings ein, das Programm bereits zu kennen, so daß er sich das Gegenbit vom
Netzwerk selbst erzeugen lassen konnte. Eigene Versuche, auf die Vorhersagen des
Modells entsprechend zu reagieren, konnten g auf etwa 40% drücken. Wir laden
unsere Leser herzlich ein, beides auszuprobieren: die Erzeugung von Zufallsbits
und die Überlistung des Perzeptrons.
Übung
Schreiben Sie per Hand in eine Datei name.dat eine Folge von etwa 2000 Zei-
chen, und zwar 1 oder 0, die möglichst zufällig eingetippt werden sollen. Fremdzei-
chen werden vom Programm ignoriert. Lassen Sie diese Daten mit nnf name.dat
auswerten. Sind Sie ein guter Zufallszahlengenerator? Überprüfen Sie, ob Zufalls-
3.4 Neuronales Netzwerk 125
bits, die vom Computer erzeugt werden, eine Trefferrate von etwa 50% liefern. Wie
groß darf die Abweichung von 50% sein?
Literatur
J. Hertz, A. Krogh, R. G. Palmer, Introduction to the Theory of Neural Computation,
Addison-Wesley, 1991.
B. Müller, J. Reinhardt, M. T. Strickland, Neural Networks: An Introduction, Sprin-
ger Verlag, 1995.
Kapitel 4
Differentialgleichungen
Seit mehr als 300 Jahren beschreiben Physiker die Bewegung von Massen durch Ge-
setzmäßigkeiten im unendlich Kleinen: Massenelemente bewegen sich durch Kräfte
in einem winzigen Zeitschritt eine winzige Strecke vorwärts. Eine solche Beschrei-
bung führt auf Differentialgleichungen, die auch heute noch das wichtigste Werk-
zeug in der Physik sind. Wenn doppelt so starke Ursachen eine doppelt so große
Wirkung haben, kann man die Gleichungen meist lösen. Bei nichtlinearen Differen-
tialgleichungen dagegen ist man oft auf einige wenige lösbare Spezialfälle oder auf
numerische Lösungen angewiesen. In diesem Kapitel wollen wir eine Einführung in
einige der numerischen Methoden geben und dazu einfache physikalische Beispiele
lösen.
Es gibt viele fertige Programmpakete zur numerischen Lösung von Differential-
gleichungen. So kann man beispielsweise in Mathematica mit NDSolve gewöhn-
liche Differentialgleichungen lösen, ohne die Einzelheiten des Programms zu ken-
nen. Trotzdem wollen wir hier nicht ganz auf die Beschreibung der Algorithmen
verzichten, denn erstens muß man bei großen und schwierigen Problemen immer
selbst einen Kompromiß zwischen Rechenzeit und Rechengenauigkeit suchen, und
zweitens gibt es für viele Spezialfälle besondere Methoden, die auch heute noch
erforscht werden.
4.1 Runge-Kutta-Methode
Grundlagen
Zunächst wollen wir die Lösung einer gewöhnlichen Differentialgleichung disku-
tieren. Dazu betrachten wir eine Funktion y (x), deren n-te Ableitung y (n) (x) sich
als Funktion von x und allen vorherigen Ableitungen schreiben läßt,
also eine explizite Differentialgleichung n-ter Ordnung. Diese Gleichung ist äquiva-
lent zu n Gleichungen erster Ordnung, denn mit y1 = y; y2 = y 0 ; : : : ; yn = y (n 1)
128 4 Differentialgleichungen
y10 = y2
y20 = y3
..
. (4.2)
y0
n 1 = yn
yn0 = f (x; y1 ; :::; yn ) ;
oder in Vektorform mit y = (y1 ; y2 ; :::; yn ) ;
y
Kennt man den Vektor am Ort x, so kann man seinen Wert nach einem winzigen
Schritt x +x mit Gleichung (4.3) berechnen. Dies ist auch die numerische Metho-
de: Die Ortskoordinate x wird diskretisiert und mit Gleichung (4.3) versucht man,
y am Nachbarort x + x möglichst genau zu berechnen.
Zur Beschreibung der numerischen Methode beschränken wir uns auf die Dimen-
y f
sion n = 1, d. h. und haben nur je eine Komponente y und f . Der vorzustellende
Algorithmus läßt sich später leicht auf beliebige Dimensionen erweitern. Sei also
y0 = f (x; y) (4.4)
gegeben. Für den Start der Rechnung benötigen wir offenbar einen Anfangswert
y(x0) = y0. Zunächst diskretisieren wir die x-Achse:
xn = x0 + n h ; (4.5)
wobei n eine ganze Zahl und h die Schrittweite ist. Seien yn = y(xn ) und yn0 =
y0(xn). Dann gibt die Taylor-Entwicklung
yn1 = y(xn h) = yn h yn0 + h2 yn00 h6 yn000 + O(h4 ) :
2 3
(4.6)
yn0 erhält man aus Gleichung (4.4). In der einfachsten Näherung, dem sogenannten
Euler-Verfahren, erhält man damit:
Der Fehler ist von der Größenordnung h2 . Diese Methode wird nicht für den prak-
tischen Einsatz empfohlen. Mit nur geringem Aufwand kann sie wesentlich verbes-
sert werden.
Gleichung (4.7) berücksichtigt nur die Steigung f am Punkt (xn ; yn ), obwohl
sie sich auf dem Weg zum nächsten Punkt (xn+1 ; yn+1 ) schon wieder geändert hat.
4.1 Runge-Kutta-Methode 129
Die Taylorreihe (4.6) zeigt, daß es günstiger ist, die Steigung auf dem halben Weg
zu diesem Punkt zu benutzen, denn dann gewinnt man eine Größenordnung in der
Schrittweite h. Doch dazu muß man zunächst eine geeignete Schätzung für yn+ 21 =
y xn + h2 finden. Dies ist die Idee des Runge-Kutta-Verfahrens, das schon im Jahr
1895 entwickelt wurde. Nimmt man die Entwicklung (4.6) an der Stelle xn + h2 mit
der Schrittweite h2 , so gilt:
h y0
h 2 1
00
yn = yn+ 2 yn+ + O(h ) ;
+ 2 3
1
2 n+ 21 1
h 2 1
2 2
Daraus folgt:
yn+1 = yn + h yn0 + + O(h3 ) : (4.9)
approximieren wir durch f x ; y + h f (x ; y ) +
1
2
k1 = h f (xn ; yn) ;
h
k2 = h f xn + 2 ; yn + 2 ;k 1
yn+1 = yn + k2 : (4.10)
Dieses Runge-Kutta-Verfahren zweiter Ordnung macht also einen Fehler der Grö-
ßenordnung h3 bei nur zwei Berechnungen der Funktion f . Wenn man diesen Re-
chenschritt mehrmals iteriert, kann man noch höhere Ordnungen von h auslöschen.
Das in der Praxis bewährte Verfahren benötigt vier Rechnungen bei einem Fehler
von der Ordnung h5 . Wir geben nur das Ergebnis an:
k1 = h f
(xn ; yn ) ;
h k 1
k2 = h f xn + 2 ; yn + 2 ;
h k
2
k = h f x + ;y +
3 n 2 2 ;n
k4 = h f (xn + h; yn + k3 ) ;
yn+1 = yn + k61 + k32 + k33 + k64 : (4.11)
Es bleibt das Problem, die Größe der Schrittweite h zu wählen. Eine Möglichkeit,
einen geeigneten Wert für h zu finden, besteht darin, das Ergebnis für verschiedene
130 4 Differentialgleichungen
h-Werte zu prüfen. Bei schwacher Änderung von y kann man sich große Schrittwei-
ten leisten, während man im umgekehrten Fall viele kleine Rechenschritte braucht.
Wenn also die Steigung von y stark variiert, sollte das Programm selbsttätig die
Schrittweite h reduzieren.
Um den Fehler abzuschätzen, berechnet man parallel zu je zwei Runge-Kutta-
Schritten (4.11) mit der Schrittweite h (Ergebnis y21 ) einmal einen Runge-Kutta-
Schritt mit der Schrittweite 2h (Ergebnis y12 ). Dies kostet weniger als 50 % Mehr-
aufwand, da die Ableitung am Startpunkt ohnehin schon berechnet ist. Bezeichnen
wir die exakte Lösung für einen Schritt von x nach x +2h mit y (x +2h), so beträgt
die Abweichung der Näherungswerte y21 , bzw. y12 von y (x +2h) , da wir ja eine
Methode vierter Ordnung verwenden:
Die Konstante ist durch die fünfte Ableitung der Funktion y (x) bestimmt. Für den
Unterschied = y12 y21 folgt hieraus:
/ h5 : (4.13)
dx = v(t) ;
dt
dv = f (x(t); t) :
dt (4.15)
v(t) ist die Geschwindigkeit eines Teilchens mit der Bahn x(t). In diesem Fall gibt
es einen Trick, um die Steigung zwischen zwei Punkten abzuschätzen: Man berech-
net x zu den Zeiten tn = t0 + n h mit n = 1; 2; 3::: und v zu den Zwischenzeiten
4.1 Runge-Kutta-Methode 131
tn+ 1
2
durch
vn+ = vn + h f (xn ; tn ) ;
1
2
1
2
xn+1 = xn + h vn+ : 1
2
(4.16)
Der Algorithmus springt also immer hin und her zwischen der Berechnung des Ortes
x und der Geschwindigkeit v an den Zwischenplätzen. Deshalb hat er den Namen
leapfrog (Bocksprung). Da die Ableitungen immer in der Mitte zwischen jeweils
zwei aufeinanderfolgenden Werten berechnet werden, ist der Fehler von der Ord-
nung h3 . Obwohl die Leapfrog-Methode denselben Rechenaufwand wie der Euler-
Schritt erfordert, ist sie genauer und in der Praxis viel robuster. Sie wird daher gern
bei der Molekulardynamik verwendet, also bei der Lösung der Bewegungsgleichun-
gen von vielen miteinander wechselwirkenden Teilchen.
Abschließend soll noch darauf hingewiesen werden, daß das Runge-Kutta-Ver-
fahren zwar einfach und robust ist, daß es aber je nach Problemstellung noch bes-
sere Methoden mit geringerer Rechenzeit geben kann. Beispielsweise kann man
das Ergebnis von mehreren einfachen Schritten für verschiedene h-Werte berech-
nen und für h !0 geeignet extrapolieren; dies ist die Idee der Richardson Extrapo-
lation und der Bulirsch-Stoer-Methode. Eine andere Möglichkeit ist, verschiedene
yi-Werte mit einem Polynom zu extrapolieren und damit eine Vorhersage für einen
yn-Wert zu erhalten, mit dem die Steigung yn0 berechnet wird. Durch Integration der
yi0 -Werte korrigiert man dann den Wert yn. Auch für solche sogenannten Predictor-
Corrector-Methoden gibt es in den Lehrbüchern geeignete Algorithmen.
Algorithmus
Gleichung (4.11) kann man einfach programmieren, selbst wenn y und f wieder
y f
durch Vektoren und ersetzt werden. In Mathematica sind dann und Listeny f
f y
von Zahlen bzw. Funktionen. Falls nur von und nicht von x abhängt, kann
Gleichung (4.11) geschrieben werden als
RKStep[f_, y_, yp_, h_]:=
Module[{k1, k2, k3, k4},
k1 = h N[f/.Thread[y –> yp]];
k2 = h N[f/.Thread[y –> yp+k1/2]];
k3 = h N[f/.Thread[y –> yp+k2/2]];
k4 = h N[f/.Thread[y –> yp+k3]];
yp + (k1 + 2*k2 + 2*k3 + k4)/6 ]
Die Funktion Thread weist jedem Element der Liste y den entsprechenden Wert
der Liste yp zu. Man beachte, daß k1, k2, k3 und k4 wieder Listen sind. Die
y y
i -Werte im Intervall [0; x] erhält man dann aus dem Anfangswert 0 durch
132 4 Differentialgleichungen
RungeKutta[f_List,y_List,y0_List,{x_, dx_}]:=
NestList[RKStep[f,y,#,N[dx]]&,N[y0],Round[N[x/dx]]]
Ergebnisse
Wir wollen die Differentialgleichung für ein Problem lösen, das wir schon im Ab-
schnitt 1.2 ausführlich untersucht haben: das mathematische Pendel. Die Hamilton-
funktion dazu lautet
Dabei ist p die Winkelgeschwindigkeit '_ und q der Ausschlagswinkel ' des Pen-
p
dels. Energie und Zeit werden wie vorher in Einheiten von mgl und l=g gemes-
sen. Die Bewegungsgleichungen erhält man aus den partiellen Ableitungen der Ha-
miltonfunktion. In Mathematica lautet damit deren Lösung
RungeKutta[{D[hamilton,p], –D[hamilton,q]},
{q,p}, {phi0,p0}, {tmax,dt}]
1.5 1.5
1 1
0.5 0.5
p 0 p 0
-0.5 -0.5
-1 -1
-1.5 -1.5
-2 -1 0 1 2 -2 -1 0 1 2
q q
4.1 Schwingung des Pendels im Phasenraum q = '; p = '_ . Die Kurve links zeigt das
Ergebnis des Runge-Kutta-Verfahrens, während die Kurve der rechten Graphik mit der Euler-
Methode berechnet wurde und offenbar ein falsches Resultat liefert.
4.1 Runge-Kutta-Methode 133
Abbildung 4.1 zeigt das Ergebnis. Die Kurve der linken Graphik ist das richtige
Ergebnis für den Anfangswinkel '0 = 2 . Ohne Reibung ist die Energie erhalten und
die Kurve muß sich wieder schließen (siehe auch Abbildung 1.4). Zum Vergleich
enthält die Abbildung rechts auch das Ergebnis des Euler-Verfahrens mit derselben
Schrittweite h = 0:1 . Man sieht, daß diese Methode ein völlig falsches Ergebnis
liefert, da die Energie wächst und sich die Kurve nicht schließt.
Natürlich können wir auch sehr einfach eine Reibungskraft hinzufügen. Wir ad-
dieren zur Gravitationskraft einen Term der Form r p und erhalten die Lösung der
Bewegungsgleichung mit
RungeKutta[{p,–Sin[q]–r p},{q,p},{phi0,p0},{tmax,dt}]
In Abbildung 4.2 sieht man, daß das Pendel seine Energie verliert und in die Ruhe-
lage q = p = 0 relaxiert.
0.5
p 0
-0.5
-1
Übung
Ein Teilchen der Masse m soll sich in einem eindimensionalen Doppelmuldenpo-
tential bewegen und außerdem eine Reibungskraft spüren, die proportional zur Ge-
schwindigkeit ist. Die Bewegungsgleichung für den Ort x(t) als Funktion der Zeit
t lautet also
m x = r x_ + a x b x3
mit positiven Konstanten r; a und b. Je nach Startzustand endet das Teilchen entwe-
der in der linken (x < 0) oder in der rechten Potentialmulde.
134 4 Differentialgleichungen
Für die Konstanten r=m = 0:1, a=m = b=m = 1 ( in geeigneten Einheiten) sol-
len Sie in der Ebene der Startzustände (x(0); x_ (0)) diejenigen Gebiete berechnen
1
und zeichnen, deren Punkte in der linken Mulde, also bei x( ) = 1 landen.
Literatur
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
E. W. Schmid, G. Spitz, W. Lösch, Theoretische Physik mit dem Personal Computer,
Springer Verlag, 1987.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
J. Stoer, R. Bulirsch, Numerische Mathematik 2, Springer Verlag, 1990.
Paul L. DeVries, Computerphysik: Grundlagen, Methoden, Übungen, Spektrum
Akademischer Verlag, 1995.
In diesem Abschnitt wollen wir ein einfaches Beispiel numerisch berechnen: das
nichtlineare Pendel mit Reibung, das von einer äußeren periodischen Kraft angetrie-
ben wird.
Physik
Wir betrachten zunächst das Pendel aus Abschitt 1.2 mit einer zusätzlichen Rei-
bungskraft. Die Bewegungsgleichung für den Winkel '(t) der Auslenkung lautet in
dimensionsloser Form:
'_ = ! ;
!_ = r ! sin ' + a cos ;
_ = ! : D (4.20)
Die Bewegung des Pendels wird nun im dreidimensionalen Raum ('; !; ) be-
schrieben. Es gibt drei Parameter (r; a; !D ). Ohne Antrieb, ohne Reibung (a =
136 4 Differentialgleichungen
r = 0) und für kleine Winkel ' 1 erhalten wir eine harmonische Schwingung
mit der Frequenz ! = 1. Es gibt deshalb im allgemeinen Fall drei Zeitskalen,
0
und die Relaxationszeit 1=r . Wie schon beim Hofstadter-Schmetterling und beim
Frenkel-Kontorova-Modell führt der Wettbewerb zwischen verschiedenen Längen
oder Zeiten auch hier zu interessanten physikalischen Phänomenen.
Die dreidimensionale Bewegung ('(t); ! (t); (t)) ist nur schwer zu analysieren,
auch wenn wie in unserem Fall nur linear mit der Zeit t wächst. Um die Vielfalt der
möglichen Bewegungsformen auf die wesentlichen Strukturen zu reduzieren, beob-
achtet man wie bei einer stroboskopischen Beleuchtung die Bewegung nur nach
jeweils festen Zeitintervallen. Das Ergebnis wird als Poincaré-Schnitt bezeichnet.
Als Zeitintervall benutzen wir die Antriebsperiode und betrachten
Damit erhalten wir eine Folge von Punkten in der Ebene, wobei jeder Punkt durch
seine Vorgänger eindeutig bestimmt wird. Wie bei der Kette auf dem Wellblech
(Abschnitt 3.2) reduzieren wir das Problem auf eine zweidimensionale diskrete Ab-
bildung, allerdings mit dem Unterschied, daß für r > 0 die Abbildung nicht flä-
chenerhaltend ist. Analog zur eindimensionalen logistischen Abbildung (Abschnitt
3.1) wird ein Flächenstück bei der Iteration kleiner und es entstehen Attraktoren.
Wie sehen nun Trajektorien ('(tj ); ! (tj )) im Poincaré-Schnitt aus? Bei einer
periodischen Bewegung mit der Periodenlänge 2=!0 sieht man in der strobosko-
pischen Aufnahme entweder einzelne Punkte oder eine geschlossene Kurve. Für
!0 = !D gibt es nur einen einzigen Punkt in der ('; !)-Ebene. Für !0 = (p=q) !D
mit teilerfremden ganzen Zahlen p und q erhält man q verschiedene Punkte, und p
bestimmt die Reihenfolge, in der die q Punkte durchlaufen werden. Ist dagegen !0
ein irrationales Vielfaches von !D , so füllen unendlich viele Punkte ('(tj ); ! (tj ))
eine geschlossene Kurve. Aus periodischen Bewegungen resultieren im Poincaré-
Schnitt also entweder einzelne Punkte oder geschlossene Kurven. Solche Bahnen
können Attraktoren sein, d. h., startet man mit Punkten ('(0); ! (0)) in einem ge-
wissen Einzugsgebiet, so laufen alle diese Werte zu einem solchen periodischen
Attraktor. Es sind auch mehrere Attraktoren mit dazugehörigen Einzugsgebieten
möglich.
Es gibt aber noch andere Arten von Attraktoren, sogenannte seltsame Attraktoren.
Sie kann man sich als eine Art Blätterteig vorstellen, den man durch fortwährendes
Strecken und Falten erhält. Solche Attraktoren entsprechen chaotischen Bahnen, die
scheinbar unberechenbar durch den Phasenraum laufen. Die seltsamen Attraktoren
sind Fraktale (siehe Abschnitt 3.3), sie sind mehr als eine Linie aber weniger als ein
Flächenstück.
Die fraktale Dimension D kann man wie im Abschnitt 3.3 durch Überdeckung
4.2 Chaotisches Pendel 137
Numerisch effektiver aber ist eine Methode, die von Grassberger und Procaccia
x
vorgeschlagen wurde. Dazu erzeugen wir uns N Punkte i auf dem Attraktor, die
x
möglichst unkorreliert sein sollen. Dann zählen wir die Anzahl der Punkte j , die
x x
einen Abstand zu i haben, der kleiner ist als R. Diese Zahl mitteln wir über i .
Formal können wir diese Korrelation mit der Stufenfunktion (x) ausdrücken:
1 X
N
C (R) = Nlim
!1 N (N 1) i6=j
(R jxi xj j) : (4.23)
C (R) kann als die mittlere Masse eines Ausschnittes des Attraktors aufgefaßt wer-
den, und die Masse-Länge-Beziehung aus Abschnitt 3.3 definiert eine fraktale Di-
mension DC durch:
/
C (R) RDC : (4.24)
Der log-log-Plot dieser Gleichung sollte also eine Gerade mit der Steigung DC
geben. Das gilt aber nur für R-Werte, die größer als der mittlere Abstand der Da-
tenpunkte und kleiner als die Ausdehnung des Attraktors sind.
Eine andere Methode zur Definition der fraktalen Dimension nutzt den Begriff
der Informationsentropie. Dazu überdeckt man den Attraktor wieder mit Quadraten
der Kantenlänge ". Dann zählt man, wieviele Punkte der erzeugten Trajektorie in
jedem Kästchen liegen. Sei also pi die Wahrscheinlichkeit, daß ein Punkt ('; ! )
des Attraktors im Quadrat mit der Nummer i liegt. Die Entropie ist dann definiert
als X
I (") = pi ln pi ; (4.25)
i
und die Informationsdimension DI erhält man als
DI = "lim I (") :
!0 ln "
(4.26)
Man kann nun zeigen, daß folgende Beziehung zwischen den drei Dimensionen
besteht:
DU DI DC : (4.27)
In der Praxis stimmen die drei Dimensionen oft innerhalb des Beobachtungsfehlers
überein.
138 4 Differentialgleichungen
Algorithmus
Zur numerischen Lösung der Differentialgleichung (4.20) wählen wir das Runge-
Kutta-Verfahren vierter Ordnung aus dem vorherigen Abschnitt. Um die Bewegung
schon während der numerischen Rechnung auf dem Bildschirm sichtbar zu ma-
chen, verwenden wir die Sprache C mit der entsprechenden Graphikumgebung. In
unserem Programm kann während des Laufes durch Tastendruck die Stärke a des
Antriebes geändert und zwischen der kontinuierlichen Bewegung und dem Poin-
caré-Schnitt hin- und hergeschaltet werden.
Es ist nicht schwer, den Runge-Kutta-Schritt Gleichung (4.11) selbst zu program-
mieren, aber wir wollen hier demonstrieren, wie die Routine odeint aus den Nu-
merical Recipes in das eigene Programm eingebunden wird.
odeint integriert das Gleichungssystem (4.20) mit adaptiver Schrittweitenkon-
trolle. Die rechnerische Erzeugung der Trajektorie gibt deshalb nicht deren tatsächli-
chen zeitlichen Verlauf wieder. Wer diesen Zusammenhang erhalten möchte, sollte
direkt die Routine rk4 aus den Numerical Recipes benutzen.
Zunächst müssen alle Variablen der verwendeten Routinen deklariert und die
Routinen zum eigenen Programm hinzugefügt werden. Dabei muß beachtet wer-
den, daß odeint die Programme rk4 und rkqc benutzt und daß alle Routinen
gewisse Fehlerroutinen aufrufen, die in nrutil enthalten sind. Man kann alle
benötigten Programme direkt in den eigenen Programmtext hineinkopieren oder mit
#include hinzufügen, z. B. durch
Der Pfadname hängt natürlich davon ab, wo der Benutzer die Programme gespei-
chert hat. Den ersten Befehl fügen wir hinzu, damit alle reellen Variablen im Pro-
gramm und in den Recipes vom selben Typ double sind. odeint wird in folgen-
der Form aufgerufen:
odeint(y,n,t1,t2,eps,dt,0.,&nok,&nbad,derivs,rkqc)
Dabei ist y ein Vektor mit den Variablen ('(t1 ); ! (t1 )). Es wird über das Intervall
[t1 ; t2 ] integriert und danach wird y durch die Endwerte ('(t2 ); !(t2 )) ersetzt. n
ist die Anzahl der Variablen. Da wir in Gleichung (4.20) wieder durch !D t erset-
zen, gibt es nur n = 2 Variablen. Mit eps geben wir die gewünschte Genauigkeit
und mit dt eine Abschätzung der benötigten Schrittweite an. Die Variablen nok
4.2 Chaotisches Pendel 139
und nbad enthalten bei der Ausgabe Informationen über die Anzahl der benötigten
Schritte. derivs ist der Name einer Funktion, mit der die rechte Seite von Glei-
chung (4.20) ausgewertet wird. Mit derivs(t,y,f) werden aus t und y die
Komponenten von f berechnet. Für unser Beispiel ist
y[1] = ',
y[2] = !,
und dementsprechend
f[1] = y[2],
f[2] =
–r y[2]–sin(y[1])+a cos(!D t).
Schließlich übergibt man der Routine odeint noch die Funktion rkqc, die wie-
derum den Runge-Kutta-Schritt rk4 aufruft. Man kann aber auch andere, eventuell
eigene Integrationsprozeduren übergeben.
Zusammenfassend besteht also der wesentliche Teil des Programmes pendel.c
aus den Befehlen:
main()
{
y[1]=pi/2.;
y[2]=0.;
while(done==0)
{
odeint(y,2,t,t+3.*pi,eps,dt,0.,&nok,&nbad,derivs,rkqc);
xalt=fmod(y[1]/2./pi +100.5,1.)*xbild;
yalt=y[2]/ysc*ybild/2+ybild/2;
rectangle(xalt,yalt,xalt+1,yalt+1);
t=t+3.*pi;
}
}
Auch hier sollte ein guter Programmierer alle Konstanten vorher berechnen lassen.
Die Vektoren y und f wurden einen Platz größer als erforderlich deklariert, da die
Recipes die Indizes mit 1 anstatt mit 0 (wie in C) beginnen lassen.
Das obige Programm benutzt !D = 2=3 und zeichnet die Punkte ('(ti ); ! (ti ))
(als kleine Rechtecke) jeweils nach einer Antriebsperiode [t; t + 3 ]. Will man die
140 4 Differentialgleichungen
Ergebnisse
Als Beispiel betrachten wir auf dem Bildschirm das getriebene Pendel mit dem Rei-
bungskoeffizienten r = 0:25 und der Antriebsfrequenz !D = 2=3. Als Startwerte
wählen wir die 90-Auslenkung, '(0) = =2, und die Anfangswinkelgeschwindig-
keit ! (0) = 0. Mit der Taste h bzw. t können wir die Antriebskraft a um jeweils
0.01 verstärken bzw. verringern.
Ohne Antrieb (a = 0) führt das Pendel eine gedämpfte Schwingung aus und hält
schließlich in der Ruhelage ('; ! ) = (0; 0) an. Für kleine a-Werte erhalten wir
nach einer Einschwingphase eine periodische Bewegung mit der Periode 2=!D ,
also einen Punkt im Poincaré-Schnitt. Bei a = 0:68 ist der Antrieb so stark, daß sich
das Pendel überschlagen kann. Die Bahn verläßt den Bildschirm und tritt wegen der
Periodizität des Winkels ' (= horizontale Achse) auf der gegenüberliegenden Seite
wieder ein.
Für a = 0:7 beobachten wir einen chaotischen Attraktor (Abbildung 4.3). Im Poin-
caré-Schnitt deutet sich ein fraktaler Blätterteig“ an (Abbildung 4.4). Auch für
”
4.2 Chaotisches Pendel 141
4.4 Wie Abbildung 4.3, aber als Poincaré-Schnitt jeweils zu den Zeiten 2 j=!D .
4.5 Phasenraum-Plot für a = 0:85. Die Bewegung ist ein Zyklus der Periode 7 !2 . Der
D
zugehörige Poincaré-Schnitt zeigt genau 7 Punkte.
a = 0:85 sieht die Bahn immer noch regellos aus (Abbildung 4.5), aber der Poin-
caré-Schnitt zeigt deutlich einen Zyklus der Länge 7 2=! . Auch Periodenver-
D
doppelung kann man beobachten. Der einfache Zyklus mit Überschlag bei a = 0:97
142 4 Differentialgleichungen
4.6 Poincaré-Schnitt für a = 1:3. Die Bewegung wechselt zwischen drei chaotischen
Bändern.
hat sich für a = 0:98 und a = 0:99 verdoppelt und bei a = 1:0 vervierfacht. Bei
a = 1:01 sieht die Bahn schon wieder chaotisch aus. Bei a = 1:2 sieht man drei
Punkte und bei a = 1:3 eine chaotische Bahn mit drei Bändern, die in Abbildung
4.6 als Poincaré-Schnitt zu sehen ist.
Mit wachsender Antriebsstärke a beobachten wir also einen fortwährenden Wech-
sel von periodischer und chaotischer Bewegung.
Übung
Zwischen zwei Platten ist eine Flüssigkeit mit gegebener Viskosität , Wärmeleit-
fähigkeit und Dichte eingesperrt. Die untere Platte hat eine Temperatur T +T ,
die obere T . Ist der Temperaturunterschied klein, so findet ausschließlich Wärme-
leitung statt, die konvektive Bewegung wird durch die viskose Reibung gebremst.
Bei Anwachsen der Temperatur beginnt die heiße Flüssigkeit in einigen Bereichen
aufzusteigen und in anderen wieder abzusinken. Es entstehen sogenannte Konvek-
tionsrollen. Bei weiterer Temperaturerhöhung brechen diese statischen Rollen auf
und es entsteht eine chaotische Bewegung.
Unter der Annahme, daß die Konvektionsrollen in y -Richtung unendlich aus-
gedehnt sind, hat der Meteorologe Lorenz durch Fourierentwicklung in x- und z -
Richtung und Vernachlässigung höherer Glieder der Fourierreihe ein Modell ent-
4.2 Chaotisches Pendel 143
Literatur
G. L. Baker, J. P. Gallup, Chaotic Dynamics: An Introduction, Cambridge University
Press, 1991.
H. J. Korsch, H.-J. Jodl, Chaos: A Program Collection for the PC, Springer Verlag,
1994.
E. Ott, Chaos in Dynamical Systems, Cambridge University Press, 1993.
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
144 4 Differentialgleichungen
Physik
Ein Quantenteilchen wird durch eine im allgemeinen komplexwertige Wellenfunk-
r
tion ( ; t) beschrieben, die einer partiellen Differentialgleichung zweiter Ordnung
j r j
genügt. ( ; t) 2 ist die Wahrscheinlichkeitsdichte, zur Zeit t das Teilchen am Ort
r zu messen.
Wenn die Mittelwerte aller Meßgrößen in diesem Zustand zeitunabhängig sind,
so gehorcht die Wellenfunktion der stationären Schrödinger-Gleichung, die in
einer Raumdimension folgendermaßen lautet:
~2 00
2m (x) + V (x) (x) = E (x) : (4.28)
Da das Potential V (x) reell ist, kann auch als reellwertige Funktion gewählt
werden. Gleichung (4.28) beschreibt den stationären Zustand eines Teilchens in ei-
ner Dimension mit der Masse m im Potential V (x), sie ist linear und enthält eine
zweite Ableitung. Aber es gibt eine Besonderheit gegenüber der Newtonschen Be-
wegungsgleichung: Die Energie E des Teilchens kann nicht alle Werte annehmen,
R j
sondern die Gleichung (4.28) bestimmt die möglichen Werte erst dadurch, daß die
j
Wellenfunktion normierbar sein muß, daß also dx (x) 2 einen endlichen Wert
annimmt. Es stellt sich heraus, daß schon bei einer winzigen Abweichung des Wer-
tes E von einem erlaubten Energiewert die Wellenfunktion für große x-Werte expo-
nentiell anwächst. Diese Tatsache muß bei der numerischen Lösungssuche berück-
4.3 Stationäre Zustände 145
sichtigt werden. Wie wir sehen werden, kann man sich andererseits gerade dieses
Verhalten zunutze machen, um die gesuchten Energie-Eigenwerte mit großer Ge-
nauigkeit numerisch zu bestimmen.
Bei symmetrischen Potentialen V (x) = V ( x) hat auch der stationäre Zustand
die Symmetrie (x) =
( x), wobei sich die Vorzeichen mit wachsenden Ener-
giewerten abwechseln. Der Grundzustand ist symmetrisch, 0 (x) = 0 ( x), und
j j
hat keine Nullstelle, 0 (x) > 0. Bei jedem höheren Energie-Eigenwert kommt
eine Nullstelle (= Knoten) der Wellenfunktion hinzu. Die Anzahl der Knoten von
(x) gibt daher die Nummer des Energieniveaus an.
In unserem Beispiel betrachten wir den anharmonischen Oszillator aus Abschnitt
2.1, dessen Schrödinger-Gleichung die folgende dimensionslose Form hat:
00 (x) + ( x2 x4 + 2E ) (x) = 0 : (4.29)
p
Die Energie E und der Ort x werden dabei in Einheiten von ~! bzw. ~=(m! )
gemessen. Im harmonischen Fall ( = 0) kennen wir die Eigenwerte und die Eigen-
zustände aus analytischen Rechnungen. E 0 kann relativ zur Ruheenergie E00 = 1=2
nur ganzzahlige nicht-negative Werte annehmen,
Algorithmus
Mehrere Probleme müssen gelöst werden: Wie findet man die Eigenwerte E ? Wel-
chen Algorithmus benutzt man für die Integration der Schrödinger-Gleichung? Mit
welchen Anfangswerten (x0 ) und (x1 ) startet man die numerische Integration?
Das erste Problem lösen wir mit dem sogenannten Schießverfahren: Wir wählen
einen Energiewert E , von dem wir sicher wissen, daß er unterhalb der Grundzu-
standsenergie E0 liegt, z. B. E = 0:5, und integrieren die Schrödinger-Gleichung
j j
vom Startwert x0 bis zu einem x-Wert, bei dem (x) unrealistisch groß geworden
ist. Dann erhöhen wir die Energie schrittweise, bis (x) das Vorzeichen wechselt.
Jetzt haben wir aufgrund des Knotensatzes ein Energieintervall gefunden, in dem
E0 liegen muß. Nun integrieren wir mit einem E -Wert in der Mitte des Intervalls;
146 4 Differentialgleichungen
wenn (x) das Vorzeichen wechselt, liegt E0 in der unteren, sonst in der oberen
Hälfte des Intervalls. Auf diese Weise können wir E0 sehr schnell einschachteln.
Wir schießen“ sozusagen die Wellenfunktion (x) für verschiedene E -Werte
solange zu großen x-Werten hin, bis die Randbedingung (x)
”
j
0 für große j!
x-Werte einigermaßen erfüllt ist. Allerdings bleibt (x) nur in einem gewissen In-
tervall dicht beim Wert Null, dann explodiert es wieder ins Unendliche.
Obwohl das zweite Problem, die Integration der Schrödinger-Gleichung, im Prin-
zip mit dem Runge-Kutta-Verfahren aus Abschnitt 4.1 gelöst werden kann, ist es bei
dieser Art von Gleichung möglich, eine größere Genauigkeit mit einer einfacheren
Methode, dem Numerov-Verfahren, zu erzielen. Gleichung (4.29) hat die Form:
00 (x) + k(x) (x) = 0 (4.31)
mit k (x) = 2 (E V (x)). Wir diskretisieren mit der Schrittweite h die x-Achse in
der Form xn = (n 12 ) h für gerade, bzw. xn = n h für ungerade Wellenfunktionen
und kennzeichnen die Wellenfunktion und auch deren Ableitungen an den Stellen
xn mit einem unteren Index n, also n = (xn ) ; n0 = 0 (xn ) und analog für die
höheren Ableitungen. Aus der Taylor-Entwicklung
0 h 00 h h4
2 3
nh n+ 2
(3) + (4) : : :
n1 = n 6 n 24 n (4.32)
folgt:
2 00 + h
4
h (4) + O (h6 ) :
n+1 + n 1 = 2 n + n 12 n (4.33)
00
n können wir mit Gleichung (4.31) ersetzen,
00 = kn n:
n (4.34)
Nun kommt der entscheidende Trick, bei dem die vierte Ableitung durch die diskre-
tisierte zweite ersetzt wird:
d2 00 d2
n = dx2 (x) = dx2 (k (x) (x))
(4)
xn xn
= kn+1 n+1 2 kn
h2
n + kn 1 n 1 + O(h2 ) : (4.35)
Die in dieser Schleife immer wiederkehrenden Rechnungen kann man dadurch be-
schleunigen, daß man Konstanten wie 5./12.*dx*dx vorher in eine Variable
schreibt. Die Iterationsschleife for (: : :) läuft soweit, daß gerade ein Pixel auf der
x-Achse des Bildschirms überbrückt wird. (xb, yb) sind die Koordinaten auf dem
Bildschirm. xb wird mit einer for-Schleife jeweils um den Wert 1 erhöht, während
ybneu aus yp1 berechnet wird. Als Startwert für 1 wählen wir 1:0. Die Haupt-
schleife für die geraden Wellenfunktionen lautet damit:
Dabei wird als Explosionskriterium für n benutzt, daß die y -Koordinate den Wert
10000 überschreitet. Auf dem PC wird eine Linie von (xb–1,ybalt) nach (xb,
ybneu) gezeichnet. Nach dieser Schleife wird auf eine Tastatureingabe mit ch=
getch() gewartet, und je nach Eingabe werden der Wert von e (= E ), die Ener-
gieschrittweite de oder die Schrittweite der Integration dx (= h) geändert.
Ergebnis
Das Programm schroedinger berechnet und zeichnet die Wellenfunktion (x)
für die Stärke = 0:1 des anharmonischen Potentials. Bild 4.7 zeigt das Ergeb-
nis für E = 6:22030088. Wegen der Symmetrie (x) = ( x) (nur der Bereich
x 0 ist gezeichnet) hat die Wellenfunktion vier Nullstellen, wir suchen also das
vierte Energieniveau E4 über dem Grundzustand. Für = 0 gilt E40 = 4:5. Der
anharmonische Term mit = 0:1 verschiebt daher dieses Niveau erheblich nach
oben. Die Wellenfunktion (x) aus Bild 4.7 liegt schon sehr dicht an dem gebunde-
nen Zustand 4 (x). Das sieht man daran, daß sich (x) sehr lange an die x-Achse
1
anschmiegt, bevor es exponentiell stark nach + schießt. Erhöht man E um den
Wert 0:00000005, so divergiert das entsprechende (x) nach 1
. Die Energie E4
liegt also im Intervall
[ 6:22030088; 6:22030093 ]:
4.3 Stationäre Zustände 149
4.7 Wellenfunktion 4 (x) mit vier Knoten für den fünften Energie-Eigenwert.
Im Abschnitt 2.1 haben wir die Energieniveaus mit einer anderen Methode berech-
net. Die unendliche Matrix des Hamiltonoperators wurde dort durch eine N N -
Untermatrix genähert und diagonalisiert. Für N = 50 fanden wir den Wert
E4 = 6:220300900006516 ;
der mit dem obigen Resultat übereinstimmt. Der Vorteil der direkten Integration
liegt darin, daß wir eine obere und untere Schranke erhalten. Deren Genauigkeit
können wir prüfen, indem wir die Schrittweite dx der Integration halbieren.
Übung
Im Abschnitt 2.1 sollten die vier niedrigsten Energieniveaus des Doppelmulden-
potentials mit der Matrix-Methode berechnet werden. Hier soll dasselbe Problem
durch Integration der Schrödinger-Gleichung gelöst werden. Das Potential V sei
also in dimensionsloser Form
Literatur
S. Brandt, H. D. Dahmen, Quantum Mechanics on the Personal Computer, Springer
Verlag, 1992.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
E. W. Schmid, G. Spitz, W. Lösch, Theoretische Physik mit dem Personal Computer,
Springer Verlag, 1987.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
J. Stoer, R. Bulirsch, Numerische Mathematik 2, Springer Verlag, 1990.
4.4 Solitonen
Bisher haben wir nur Differentialgleichungen von Funktionen betrachtet, die von ei-
ner Variablen (Zeit oder Ort) abhängen. Jetzt wollen wir eine Welle betrachten, die
sich mit der Zeit fortbewegt und eventuell ihre Form ändert. Die zeitliche Änderung
ist dabei mit der räumlichen gekoppelt, man erhält eine partielle Differentialglei-
chung.
Wir wollen uns in diesem Abschnitt mit der Korteweg-de-Vries-Gleichung (KdV-
Gleichung) beschäftigen und ausnahmsweise eine analytisch bekannte Lösung die-
ser Gleichung auch auf numerischem Wege gewinnen. Die KdV-Gleichung ist ei-
ne nichtlineare Differentialgleichung mit speziellen Lösungen, den sogenannten
Solitonen, die einige überraschende Eigenschaften zeigen. So können z. B. zwei
Solitonen aufeinander zulaufen, sich gegenseitig durchdringen und danach ohne
Formänderung mit der ursprünglichen Geschwindigkeit wieder getrennt weiterlau-
fen.
Physik
In der Theorie von Wasserwellen in seichten Kanälen wird die Auslenkung u(x; t)
über dem mittleren Wasserspiegel zur Zeit t am Ort x durch eine nichtlineare par-
tielle Differentialgleichung beschrieben. In dimensionsloser und geeignet skalierter
Form lautet die KdV-Gleichung
@u = 6 u @u @ 3 u :
@t @x @x3 (4.37)
Im Term u @u@x ergibt eine doppelte Auslenkung einen vierfachen Beitrag, die Glei-
chung ist also nichtlinear.
4.4 Solitonen 151
Unter den vielen Lösungen der KdV-Gleichung gibt es eine ganz charakteristi-
sche, nämlich
u(x; t) = 2 sech2 (x 4t) (4.38)
mit sech x = 1= cosh x. Diese Funktion u(x; t) beschreibt ein Wellental, das sich
mit der Geschwindigkeit v = 4 nach rechts bewegt und dabei seine Form nicht
ändert. Eine solche Lösung wird als Soliton bezeichnet.
Man kennt aber auch komplexere Lösungen. Die mathematische Theorie dazu ist
nicht einfach, so daß wir hier nur das Ergebnis angeben. Aus dem Anfangszustand
-2
u(x,0.3)
-4
4.8 Zwei Solitonen entfernen
-6 sich voneinander. Die nume-
rische Lösung (durchgezogen)
-8 stimmt gut mit der exakten (ge-
-10 -5 0 5 10 punktet) überein (t = 0:3,
x dx = 0:18, dt = 0:002).
Bild 4.8 zeigt, daß diese Lösung zwei Solitonen enthält. Eine Welle mit großer Am-
plitude hat eine breitere Welle mit kleiner Amplitude überholt. Zur Zeit t = 0 über-
lagern sich beide zu dem Wellenpaket (4.39), während nach dem Überholvorgang
beide Solitonen wieder die gleiche Form wie vorher haben.
Es soll noch ein interessanter Zusammenhang mit der Quantenmechanik erwähnt
werden: Die Schrödinger-Gleichung mit dem Potential V (x)= N (N + 1) sech2 (x)
hat N gebundene Zustände, aus denen man mit den Methoden der inversen Streu-
theorie die Lösung der KdV-Gleichung konstruieren kann. Da dies nicht einfach zu
erklären ist, verweisen wir auf die Literatur zu Solitonen.
152 4 Differentialgleichungen
Mit diesen Ersetzungen lösen wir Gleichung (4.37) nach ujn+1 auf und erhalten:
ujn+1 = ujn + dt 6ujn un dx un ujn+3 3ujn+2 + 3ujn+1 ujn :
j +1 j
(dx)3 (4.44)
f g
Diese Gleichung ist leicht zu programmieren. In Mathematica stellen wir ujn max
j =0
als Liste mit max +1 Elementen dar. Zur Initialisierung verwenden wir Gleichung
(4.39) mit N = 2,
ustart:=Table[–6 Sech[(j–max/2)dx]ˆ2//N,{j,0,max}]
und nehmen periodische Randbedingungen an. Wir verschaffen uns mit uplus[k]
=RotateLeft[u,k] für k = 1; 2 und 3 die verschobenen Listen ujn+k und f g
f g !f
können dann den Integrationsschritt ujn ujn+1 folgendermaßen formulieren:
g
step[u_]:=(Do[uplus[k]=RotateLeft[u,k],{k,3}];
u+dt(6 u(uplus[1]–u)/dx –
(uplus[3]–3 uplus[2]+3 uplus[1]–u)/dxˆ3))
Mit plot2[i_:3] zeichnen wir für dx = 0:05 und dt = 0:02 das Ergebnis nach
i Integrationsschritten.
plot2[i_:3]:= (dx=0.05; dt=0.02; upast=ustart; zeit=0;
Do[upres=step[upast];
upast=upres;Print["Zeit ",zeit=zeit+dt],{i}] ;
xulist = Table[{(j–max/2)dx,upres[[j]]},{j,0,max}];
ListPlot[xulist, PlotJoined–>True, PlotRange–>All])
4.4 Solitonen 153
Abbildung 4.9 zeigt das Resultat. Schon nach drei Zeitschritten treten in u(x; t)
numerisch bedingte Oszillationen auf, die nach zwei weiteren Schritten explodie-
”
ren“ ; dies ist natürlich unphysikalisch und auf den schlechten Algorithmus zurück-
zuführen.
0
u(x,0.06)
-5
Was läuft falsch? Wir haben mehrere Fehler gemacht, die wir durch folgende Mo-
difikationen vermeiden können:
1. Durch besseres Diskretisieren der Ableitungen kann man den Fehler der Appro-
@ und @ n reduzieren,
ximation von @t @xn
2. Mittelwertbildung stabilisiert den Algorithmus,
Dann gilt:
u00 = u1 dx u0 dx 00
2 u0 + ;
u00 = u1 2 dxu 1 (dx6 ) u0000 + :
2
(4.45)
Man sieht, daß man im zweiten Fall u00 so berechnen kann, daß dx 00
2 u0 gerade kom-
pensiert wird. Dadurch wird der Fehler um eine Größenordnung reduziert. Auch
154 4 Differentialgleichungen
bei höheren Ableitungen kann man so durch geeignete Wahl der Koeffizienten den
Fehler reduzieren. Man erhält
u000 = u1 2dx
u0 + u 1 + O(dx2) ;
2
u0000 = u2 2u1 2+dx2u3 1 u 2 + O(dx2 ) : (4.46)
Bei dem in (4.44) verwandten Algorithmus wurde also hinsichtlich der Güte der
Approximation bei sämtlichen Ableitungen eine Größenordnung in dx und dt ver-
schenkt.
Punkt 2 und 3 wollen wir an einer einfachen linearen Differentialgleichung er-
läutern, und zwar wählen wir
@u = v @u
@t @x
mit einer konstanten Geschwindigkeit v . Wir diskretisieren diese Gleichung in der
Form
ujn+1 ujn = v ujn+1 ujn 1 ;
dt 2 dx (4.47)
@ schon die verbesserte Version (4.45) eingesetzt haben. Aufgelöst
wobei wir für @x
u
nach den Komponenten (u1n+1 ; u2n+1 ; : : :) , die wir zu n+1 zusammenfassen, läßt
sich (4.47) als Matrixgleichung
un+1 = M un
T T
(4.48)
mit der tridiagonalen Matrix M formulieren. Die Lösung von (4.48) ist offensicht-
u u
lich Tn = Mn T0 , an der wir erkennen, daß für die Stabilität des Algorithmus der
Betrag der Eigenwerte von M entscheidend ist. Die Eigenmoden wvon Matrizen
dieses Typs sind immer von der Form w = exp(i k j dx) mit einem Wellenvektor
j
k, dessen mögliche Werte mit den Randbedingungen zusammenhängen. Wählen wir
w w
eine Eigenmode = 0 als Anfangsauslenkung und bezeichnen den zugehörigen
Eigenwert mit a, so ergibt die n-fache Anwendung der Matrix M :
wnj = an ei k j dx (4.49)
Setzen wir dies in (4.47) ein, so erhalten wir eine Bestimmungsgleichung für die
Amplitude a:
an+1 an = v an eikdx e ikdx :
dt 2dx (4.50)
a ist also komplex, und der Betrag ist außer für k = 0 immer größer als eins.
Das heißt, daß jede Anfangsauslenkung, die nicht gerade konstant ist, mit der Zeit
exponentiell anwächst. Der Algorithmus ist unbrauchbar!
Eine scheinbar unwesentliche Änderung kann das Verfahren aber stabilisieren:
Wir ersetzen in Gleichung (4.47) ujn durch den Mittelwert:
a = cos(kdx) i vdt
dx sin(kdx) : (4.54)
Die Lösung s 2
a= i vdt
dx sin kdx 1
vdt
dx sin kdx (4.58)
jj
zeigt, daß a den Wert 1 hat, wenn die Courant-Bedingung (4.55) gilt. Auch hier
muß man dt relativ zu dx klein genug wählen.
Gleichung (4.56) enthält nun drei Zeitschritte, nämlich n + 1; n und n 1. Um
die Zukunft zu berechnen, müssen wir Gegenwart und Vergangenheit kennen. Im
ersten Schritt kennen wir nur die Gegenwart, die Zukunft muß also in einem Schritt,
156 4 Differentialgleichungen
z. B. mit Gleichung (4.53) berechnet werden. Alle weiteren Schritte können dann
mit Gleichung (4.56) durchgeführt werden.
Diese Erkenntnisse wollen wir nun für die numerische Lösung der KdV-Glei-
chung nutzen. Wir setzen:
j j
@u
@t ! un+12dtun 1 ;
@u ! un 2dxun ;
j +1 j 1
@x
u
! 13 ujn+1 + ujn + ujn 1 ;
@3u 1 uj+2 2uj+1 + 2uj 1 uj 2 :
! 2(dx
@x3 )3 n n n n
0
-2
-4
u -6
-8
-10
4 0.2
2
0.1
0
x 0
-2 t
-0.1
-4
-0.2
4.10 Zwei Solitonen wie in Bild 4.8, aber als 3D-Plot für verschiedene Zeiten. Ein großes,
schnelles Soliton überholt ein kleines breites.
10
x 0
im dazugehörigen Contour-Plot (Bild 4.11) deutlich. Für negative Zeiten nähert sich
das schnelle Soliton mit großer Amplitude dem langsamen. Bei t = 0 überlagern
sich beide zu einem einzigen Wellental, und nach dem Überholvorgang haben beide
wieder die ursprüngliche Gestalt. Beim Überholen erfährt das kleine Soliton ei-
ne Verzögerung, während das große beschleunigt wird. Dies ist besonders gut im
Contour-Plot Bild 4.11 zu erkennen.
158 4 Differentialgleichungen
-1
u(x,0.3)
-2
Übung
Die Stabilität des in step2[u_,w_] programmierten Algorithmus wird entschei-
dend durch die diskretisierte dritte Ableitung begrenzt.
@u = @ 3u :
@t @x3 (4.59)
Untersuchen Sie diesen Algorithmus auf seine Stabilität, indem Sie in (4.60) den
Ansatz (4.49) verwenden. Zeigen Sie, daß analog zu (4.57) hieraus die Amplitu-
4.5 Zeitabhängige Schrödinger-Gleichung 159
dengleichung
dt 1 (dx)3 : (4.61)
b) Benutzen Sie den Algorithmus step2[u,w] zur Integration und die Anfangs-
bedingung u(x; 0) = 6 sech2 x. Variieren Sie dx zwischen 0:1 und 0:2 und
bestimmen Sie zu gegebenem dx die Stabilitätsgrenze hinsichtlich dt, d. h. be-
stimmen Sie ungefähr das maximale dt in Abhängigkeit von dx. Bestätigen Sie
in einem log-log-Plot die Gleichung (4.61).
Literatur
G. Baumann, Mathematica in der Theoretischen Physik, Springer Verlag, 1993.
R. E. Crandall, Mathematica for the Sciences, Addison Wesley, 1991.
Physik
Es sei (x; t) die komplexwertige Wellenfunktion eines Teilchens mit der Masse m,
das sich in einer Dimension in einem Potential V~ (x) bewegt. (x; t) 2 dx ist dann
j j
die Wahrscheinlichkeit, das Teilchen zur Zeit t im Intervall [x; x + dx] anzutreffen.
Die zeitliche Änderung von (x; t) wird durch die Schrödinger-Gleichung in der
Ortsdardarstellung beschrieben:
Um diese Gleichung in eine dimensionslose Form zu bringen, skalieren wir die Zeit
mit t0 und den Ort mit x0 :
~ t0 = 2mx20 : (4.64)
Wenn wir nun V~ (x) t0 =~ = V (x=x0 ) setzen und Ort und Zeit in Einheiten von x0
und t0 messen, so erhalten wir die dimensionslose Gleichung
@
@2
i @t = H = @x2 + V (x) : (4.65)
H ist der skalierte Hamiltonoperator des Teilchens. Zur numerischen Lösung dieser
Gleichung gibt es zwei Wege: Erstens können wir die Eigenzustände und Eigenwer-
te der stationären Gleichung H = E berechnen, (x; 0) nach diesen Zuständen
entwickeln und dann für (x; t) eine Reihendarstellung angeben. Zweitens können
wir die zeitabhängige Gleichung wie im vorigen Abschnitt direkt integrieren. Der
zweite Weg ist auch für Probleme anwendbar, bei denen die erste Methode versagt,
so daß wir im Algorithmus-Teil diesen Weg beschreiben wollen. Wenn andererseits
4.5 Zeitabhängige Schrödinger-Gleichung 161
die Eigenzustände bekannt sind, so kann man mit dem analytischen Ansatz zumin-
dest einige Eigenschaften der Wellenfunktion (x; t) direkt herleiten.
Wir wollen ein Teilchen im unendlich hohen Kasten betrachten. Weil im folgen-
den Symmetrieüberlegungen eine beträchtliche Rolle spielen, legen wir das Koor-
dinatensystem so, daß sich diese Symmetrie einfach ausdrücken läßt. Das Potential
V (x) habe also die Form
0 1 x 12 ;
V (x) = 1
für
sonst :
2 (4.66)
Dabei wird die Länge x in Einheiten der Breite a des Kastens und die Energie
in Einheiten von ~2 =2ma2 gemessen. Die Energien En der stationären Zustände
n (x) sind aus der Quantenmechanik-Vorlesung bekannt:
En = (n2 2 mit n = 1; 2; 3; : : : ;
p
n (x) = p2 cos(nx) für n ungerade ; 1
2 x 12 : (4.67)
2 sin(nx) für n gerade
Diese Zustände sind stehende Wellen, deren Betrag sich zeitlich nicht ändert. Der
hi
mittlere Ort des Teilchens in diesen Zuständen x = 0 ändert sich ebenfalls nicht
mit der Zeit.
Wir wollen nun ein Wellenpaket (x; t) betrachten, das im Kasten hin- und
herläuft. (x; 0) kann nach den Eigenzuständen entwickelt werden, so daß wir für
(x; t) erhalten:
X
1
i 2 (2m 1)2 t
(x; t) = c^2m 1 e cos((2m 1)x) +
m=1
X
1
i 2 (2m)2 t
c^2m e sin(2mx) (4.68)
m=1
= g (x; t) + u (x; t) (4.69)
f g
mit Entwicklungskoeffizienten c^n . Wegen der Symmetrie der Basisfunktionen
(4.67) liefert diese Entwicklung zugleich die Zerlegung von (x; t) in den gera-
den ( g ) und ungeraden ( u ) Anteil.
Der allgemeine Zustand ist also eine unendliche Überlagerung aus stehenden
Wellen, bei jeder Welle aber entwickelt sich der Phasenfaktor mit einer anderen
Geschwindigkeit. Auf diese Weise werden komplexe Interferenzmuster erzeugt, die
sich zeitlich sehr schnell ändern können (siehe Ergebnisse). Allerdings gibt es im
Kasten eine Besonderheit, die mit der Struktur der Energien En zusammenhängt.
Jede Frequenz !n = n2 2 ist ein ganzzahliges Vielfaches der Grundfrequenz
162 4 Differentialgleichungen
!1 = 2 . Daraus folgt, daß (x; t) periodisch in der Zeit t ist mit der Periodendauer
T = 2=!1 = 2= . Nach der Zeit t = T verschwinden die wilden Interferenz-
muster und das Wellenpaket (x; t) kehrt vollständig in seinen Ausgangszustand
(x; 0) zurück.
Wir werden im Ergebnisteil sehen, daß auch schon vorher zu bestimmten Zei-
ten einfache Muster auftauchen. So entsteht z. B. nach der Zeit t = T=2 die an der
Mitte des Kastens gespiegelte Anfangsverteilung, die gerade in die entgegengesetzte
Richtung läuft. Dies wollen wir kurz analytisch zeigen. Zur Zeit t = T=2 = 1= er-
geben alle Phasenfaktoren in g (x; t) den Faktor 1, denn exp( i (2m 1)2 ) =
1, während die e-Faktoren in u (x; t) für t = 1= alle den Wert 1 haben. Also
erhalten wir
Nach der Zeit T=2 entsteht also die Aufenthaltswahrscheinlichkeit (x; 0) 2 zur j j
Anfangszeit, nur an der Mittelachse des Kastens, x = 0, gespiegelt. Daß die Welle
zu diesem Zeitpunkt in die entgegengesetzte Richtung läuft, erkennt man am besten
an der Stromdichte
j (x; t) = i (x; t) @@x (x; t) (x; t) @
@x (x; t) : (4.71)
Setzen wir hier das Ergebnis von Gleichung (4.70) ein, so ergibt sich unmittelbar
j (x; T2 ) = j ( x; 0) : (4.72)
Wir haben gezeigt, daß sich zu den Zeiten T=2 und T aus den komplexen Interfe-
renzmustern die ursprüngliche Form zurückbildet. Der Ergebnisteil zeigt aber, daß
sich auch schon früher einfache Wellen bilden. So entstehen z. B. bei T=4 zwei
Wellenpakete, die gegeneinander laufen und später miteinander interferieren. Dies
ist eine Folge der von uns gewählten Anfangsbedingung
" 2 #
(x; 0) = eikx exp 1 x + 14 :
22 (4.73)
ist eine Gaußfunktion der Breite , die bei x = 1=4 konzentriert ist, mul-
tipliziert mit exp(ikx). Dieser Faktor bewirkt, daß das Teilchen am Anfang eine
mittlere Geschwindigkeit
hat. Die Breite muß genügend klein sein, damit die Randbedingung ( 12 ; 0) = 0
noch mit ausreichender Genauigkeit als erfüllt angesehen werden kann. In der nu-
merischen Simulation verwenden wir = 0:05, also ( 12 ; 0) j
exp( 12:5) j .
j
4 10 6 im Vergleich zu ( 1=4; 0) = 1 . j
Wir setzen t = T=4 = 1=(2 ) in Gleichung (4.68) ein – die Phasenfaktoren
ergeben jetzt exp( i 2 (2m 1)2 =(2 )) = i bzw. exp( i 2 (2m)2 =(2 )) = 1
– und erhalten
(x; T4 ) = i g (x; 0) + u (x; 0) : (4.75)
Das Betragsquadrat der Wellenfunktion für t = T=4 ist demnach
Der letzte Summand dieser Gleichung, der sich als 2 Im( g (x; 0) u (x; 0)) schrei-
ben läßt, ist verschwindend klein. Eine einfache Rechnung unter Benutzung von
(4.73) ergibt:
1
1
2 Im ( g (x; 0) (x; 0)) = 2 exp + 2x2 cos kx sin kx ;
u 22 8
(4.77)
einen Term also, der für = 0:05 von der Größenordnung exp( 25) ist. Der Rest
läßt sich in folgender Weise durch ( x; 0) ausdrücken:
j (x; T4 )j2
= 21 (j (x; 0)j2 + j ( x; 0)j2 ) ; (4.78)
j (x; T4 )
= 12 j (x; 0) 1 j(
2 x; 0) (4.79)
Auch zu noch kürzeren Zeiten entstehen Wellen mit einer einfachen Struktur.
Setzen wir t = T p=q mit ganzen teilerfremden Zahlen p und q , dann kann die Pha-
se exp( 2i n2 p=q ) höchstens q verschiedene Werte annehmen. (x; t) ist daher
nach (4.68) eine Überlagerung von q Wellen, wobei jede Welle eine unendliche Teil-
summe aus (x; 0) ist. Nimmt man an, daß jede Teilwelle eine glatte Funktion ist,
so ist deren Überlagerung ebenfalls glatt, und (x; t) zeigt zu diesen Zeiten eine
einfache Struktur. Genau dies werden wir bei der numerischen Integration beobach-
ten.
Damit schließen wir die analytischen Betrachtungen ab und wenden uns der Be-
schreibung der numerischen Lösung der zeitabhängigen Schrödinger-Gleichung zu.
Algorithmus
Zunächst wird (x; t) diskretisiert:
j
n = (j dx; n dt) : (4.80)
j und n sind ganze Zahlen, dx und dt sind die Schrittweiten in Ort und Zeit. Wie
vorher schreiben wir die zweite Ableitung mit einem Fehler der Größenordnung
O (dx2 ) als
@2 !1 j +1 2 j + j 1 :
@x 2 (dx)2 n n n (4.81)
Nun könnten wir die zeitliche Ableitung geeignet diskretisieren, analog zu den So-
Gesamtwahrscheinlichkeit
Rj
litonen aus dem vorigen Abschnitt. Allerdings erhält dieser Algorithmus nicht die
j
(x; t) 2 dx = 1, die sich zeitlich nicht ändern darf.
Es ist in der Tat möglich, eine diskrete Näherung der partiellen Differentialglei-
chung zu finden, bei der die Gesamtwahrscheinlichkeit erhalten bleibt. Dazu muß
der diskretisierte Zeitentwicklungsoperator unitär gewählt werden.
Die Lösung der Schrödinger-Gleichung (4.65) kann man auch in der Form
1
j
n+1 = 1 + 2i H dt 1 2i H dt j
n: (4.85)
Pj j
Nun bleibt die Gesamtwahrscheinlichkeit j nj 2 als Funktion der Zeit n kon-
stant. Der inverse Operator kann auch auf die linke Seite der Gleichung gebracht
werden, i
1 + i H dt
2
j
n+1 = 1 2 H dt j
n: (4.86)
In dieser Form wird die Differenzengleichung implizit; das heißt, die Wellenfunkti-
on im folgenden Zeitschritt ist durch ein Gleichungssystem bestimmt, das man erst
lösen muß. Der entsprechende Algorithmus kostet zwar mehr Rechenzeit, führt aber
fast immer zu einem stabilen numerischen Verfahren. Setzen wir nun die spezielle
Form des Hamiltonoperators ein, so erhalten wir
Damit erhält man aus Gleichung (4.86)
2 (dx)2 (dx)2 V j
j +1 j j 1
n+1 + i dt 2 n+1 + n+1 =
2 (dx)2
j +1 i j
+ (dx) V + 2
2 j j 1 j:
n + dt n n = n (4.88)
Die zweite Zeile, in der nur Größen des Zeitschritts n vorkommen, haben wir mit
j abgekürzt. Diese Gleichung hat die Form
n
T n+1 = n; (4.89)
wobei die Matrix T Tridiagonalgestalt hat. Wir müssen also zu jedem Zeitschritt ein
lineares Gleichungssystem lösen. Bei Tridiagonalmatrizen gibt es dafür ein speziel-
les Verfahren. Wir machen den Ansatz
j +1 j j j
n+1 = a n+1 + bn : (4.90)
Setzen wir dies in Gleichung (4.88) ein, so finden wir
1 :
j = 2 + (dx)2 V j i 2(dx)
2
a j j 1 j j
n+1 dt n+1 + bn n (4.91)
Der Vergleich mit (4.90) ergibt Gleichungen für aj 1 und bjn 1 , die wir nach aj und
bjn auflösen können. Das Ergebnis ist
aj = 2 + (dx)2 V j i 2(dx dt
)2 1 ;
a 1
j
j
b = j j
+ b =a :
1 j 1
n n n (4.92)
166 4 Differentialgleichungen
aj ist also, wie vom Ansatz (4.90) gefordert, von n unabhängig, während bjn aus der
Wellenfunktion nj berechnet wird. Zur Lösung dieser Gleichungen benötigen wir
den Anfangszustand 0j und Randbedingungen. Da wir das Teilchen in einen Kasten
mit unendlich hohen Wänden sperren wollen, muß am Rand verschwinden,
0 =0 J = 0;
n und n (4.93)
wobei wir jetzt, da es sich einfacher programmieren läßt, den Rand durch x = 0 und
x = 1 definiert haben. Die Anzahl J der Stützpunkte ist damit durch J = 1+1=dx
festgelegt. Gleichung (4.88) lautet bei j = 1:
2 (dx)2
n+1 + i dt (dx)2 V 1 2 n+1 = n :
2 1 1 (4.94)
dx)2 ; b1 = 1 :
a1 = 2 + (dx)2 V 1 i 2 (dt n n (4.95)
Mit diesen Startwerten und Gleichung (4.92) können alle aj und nach jedem Zeit-
schritt alle bjn berechnet werden. Die Wellenfunktion berechnet man dann durch
Rückwärts-Iteration aus Gleichung (4.90):
j = j +1
bjn =aj :
n+1 n+1 (4.96)
3. Berechne für alle Orte j die Variable bjn mit dem Startwert aus (4.95) und der
Rekursion (4.92).
4. Berechne aus Gleichung (4.96) die Werte der Wellenfunktion nj +1 mit dem
Startwert nJ+1 = 0 für den nächsten Zeitschritt n + 1. Damit erhält man auch
j aus Gleichung (4.88).
n+1
5. Iteriere die Schritte 3 und 4 für n = 0; 1; 2; :::
4.5 Zeitabhängige Schrödinger-Gleichung 167
Als Anfangszustand wählen wir, wie schon erwähnt, ein Gaußsches Wellenpaket,
das sich mit dem mittleren Impuls k bewegt:
(x x )2
0
(x; 0) = ei k x exp 2 2 : (4.97)
Multiplikation und Division müssen damit selbst geschrieben werden. Die für kom-
plexe Zahlen a = Re a + i Im a und b = Re b + i Im b bekannten Formeln der
Multiplikation und Division
a b = Re a Re b Im a Im b + i (Im a Re b + Re a Im b) ; (4.98)
a = Re a Re b + Im a Im b + i (Im a Re b Re a Im b)
b (Re b)2 + (Im b)2 (4.99)
finden sich zum Beispiel in der als Funktion calculate_b geschriebenen Iterati-
on der Gleichung (4.92) wieder:
void calculate_b(complex *b, complex *omega, complex *a)
{
int j ; double a2;
b[1].real=omega[1].real;
b[1].imag=omega[1].imag;
for (j=2;j<J;j++)
{a2=a[j–1].real*a[j–1].real+a[j–1].imag*a[j–1].imag;
b[j].real=omega[j].real+
(b[j–1].real*a[j–1].real+b[j–1].imag*a[j–1].imag)/a2;
b[j].imag=omega[j].imag+
(b[j–1].imag*a[j–1].real–b[j–1].real*a[j–1].imag)/a2;
}
}
Alle anderen Schritte des obigen Algorithmus lassen sich ebenso einfach program-
mieren. Wir verweisen auf den Quellcode auf der beiliegenden Diskette.
168 4 Differentialgleichungen
Zur numerischen Integration der Schrödinger-Gleichung haben wir für den Ka-
sten das Intervall [0; 1] gewählt, unter anderem auch, weil sich damit die x-Koordi-
nate leichter in positive Bildkoordinaten umrechnen läßt. Die der Gleichung (4.68)
entsprechende Eigenfunktionsentwicklung lautet dann:
X
1
in2 2 t
(x; t) = cn e sin(nx) ; (4.100)
n=1
Z1
cn = 2 sin(nx) (x; 0) dx : (4.101)
0
Der Startzustand in unserer Simulation ist das gaußförmige Wellenpaket (4.97) mit
der Breite = 0:05 und dem mittleren Impuls k = 40, das bei x0 = 0:25 zentriert
ist. Wie wir schon gesehen haben, muß die Welle nach der Zeit T = 2= 0:6366 '
in ihren Anfangszustand zurückkehren. Dies gibt uns einen Test für die Genauigkeit,
mit der wir die Schrödinger-Gleichung integriert haben.
T ist natürlich auch die größte Zeitskala, die für dieses Problem relevant ist.
Zusätzlich aber gibt es drei weitere charakteristische Zeiten, die hier eine Rolle
spielen. Da ist zum einen die Zeit t1 , die das Teilchen benötigt, um aufgrund seines
mittleren Impulses den Kasten einmal zu durchlaufen. Mit k = 40 erhalten wir aus
Gleichung (4.74) t1 = 1=80 = 0:0125 . Darüber hinaus müssen wir den typisch
quantenmechanischen Effekt des Zerfließens eines Wellenpaketes berücksichtigen.
Eine freie gaußförmige Anfangsverteilung mit der Breite hat zur Zeit t die Breite
p
1 + t2 ~2 =(4 m2 4). Wenn wir fragen, wann diese Breite mit der Kastenbreite
übereinstimmt, so erhalten wir daraus die Zeit t2 = 1=20 = 0:05 .
Die vierte Zeitskala schließlich, die uns auch einen Anhaltspunkt für die Wahl der
Schrittweiten dx und dt gibt, ist durch die größte relevante Phasengeschwindigkeit
festgelegt, zu deren Bestimmung wir die Gleichungen (4.100) und (4.101) heranzie-
hen. Drücken wir den Sinus in diesen Gleichungen durch die Exponentialfunktion
aus, so sind die Summanden in (4.100) von der Form
cn e i n (n t x) ; (4.102)
vnph = n (4.103)
Auf dem dem Bildschirm können wir nur solche Amplituden sichtbar machen,
die mindestens 1=1000 der maximalen Amplitude betragen. Dies führt uns zur
Abschätzung
1 2 (n k)2 ln(1000) ) nmax ' 35 ; vmax
ph ' 100 : (4.105)
2
Wenn auf den kürzesten Sinusbogen noch etwa 20 bis 30 Teilpunkte entfallen sollen,
so ergibt diese Überlegung
dx . 10 3 und dt . 10 5 ; (4.106)
Für den Betrag der Differenz dieser beiden Ausdrücke liefert die Taylor-Entwick-
lung von d'
1 `(dt n2 2 )3 :
' 12 (4.108)
Fordern wir < 1=2 für ` = T=dt und n = nmax , so folgt hieraus dt 2 10 6 . .
Es stellt sich heraus, daß unser Algorithmus in der Tat mit dx = 10 3 und dt = 5
10 6 passable Ergebnisse produziert, die allerdings mit wachsender Integrationszeit
auch Abweichungen von der exakten Zeitentwicklung aufweisen.
Ergebnisse
Am Anfang merkt die Welle noch nichts vom Kasten. Sie bewegt sich nach rechts
und zerfließt dabei. Sobald aber ein Teil der Welle von der Wand reflektiert wird,
interferiert er mit dem noch einlaufendem Teil zu einem Wellenmuster (Bild 4.13,
links). Auf der rechten Seite dieser Abbildung sieht man, daß sich schon nach kurzer
Zeit (t = T=40) ein unregelmäßiges Interferenzmuster über den ganzen Kasten
ausgebildet hat. Dieses Muster ist typisch für fast alle Zeiten.
170 4 Differentialgleichungen
j j
4.13 Links: Wellenpaket (x; t) 2 kurz nach dem ersten Aufprall auf die Wand (t =
j j
T=100). Rechts: Typisches Interferenzmuster, (x; t) 2 für t = T=40 .
4.14 j (x; t)j2 zu den Zeiten t = T=12 (links) und t = T=4 (rechts).
Die Einzelbilder zu verschiedenen Zeiten werden im Titelbild dieses Lehrbuches als
Gebirge über der Ort-Zeit-Ebene dargestellt. Die Ortskoordinate wurde horizontal
von rechts nach links und die Zeit von hinten nach vorn aufgetragen. Ganz hinten
sieht man, wie der Startzustand nach links läuft, dabei zunächst zerfließt und dann
4.5 Zeitabhängige Schrödinger-Gleichung 171
4.15 Wellenpaket j (x; t)j2 zu den Zeiten t = T=3 (links) und t = T=2 (rechts).
an der Wand reflektiert wird. Ganz vorn ist die Aufenthaltswahrscheinlichkeit kurz
vor der Zeit T=6 zu sehen; eine glatte Welle mit drei Bergen. Dazwischen entsteht
eine faszinierende Hügellandschaft von unerwarteter Vielfalt und Regelmäßigkeit.
Insbesondere die vielen Täler, die sich sternförmig ausbreiten, sind uns bei der Be-
obachtung der Welle direkt auf dem Bildschirm nicht aufgefallen. Wir haben bis
jetzt diese Täler noch nicht analytisch berechnen können.
j j
Bild 4.16 schließlich zeigt sowohl die Anfangsverteilung (x; 0) 2 (punktiert)
als auch das numerisch integrierte Wellenpaket nach der vollen Periode T . Wollten
wir die offensichtliche Diskrepanz zwischen numerischer Lösung und exakter Zeit-
entwicklung beseitigen, so müßten wir die Diskretisierung der Ortskoordinate noch
weiter verfeinern. Bei unseren Überlegungen zur Periodendauer sind wir bisher
nämlich von den Energiewerten En = n2 2 des exakten Hamiltonoperators H
ausgegangen, wohingegen für die numerische Integration die Matrixversion von H ,
Gleichung (4.87) mit V j = 0, relevant ist. Die Eigenwerte End dieses Operators
und die zugehörigen Eigenvektoren jn , die natürlich die Randbedingungen (4.93)
172 4 Differentialgleichungen
erfüllen müssen, sind aber auch bekannt:
n ist hier der Index der Eigenmode und nicht die Nummer des Zeitschrittes. Der
obigen Gleichung und der Entwicklung von End für dx 1,
1 n4 4 (dx)2 ;
End ' n22 12 (4.110)
entnehmen wir erstens, daß die Frequenzen nicht mehr exakt ganzzahlige Vielfa-
che einer Grundfrequenz sind, und zweitens, daß sie alle kleiner sind als die vorher
betrachteten En . Hierdurch erklärt sich sowohl die Verbreiterung als auch die zeit-
liche Verzögerung des Wellenpaketes in Bild 4.16. Die Berücksichtigung der mo-
difizierten Energiewerte End (4.109) in Gleichung (4.107) ergibt dx . 10 4 und
.
dt 10 , wenn diese Korrektur nach einer Periode noch nicht sichtbar sein soll.
6
Übung
a) Verwenden Sie die beschriebene Integrationsroutine, um die Mittelwerte x , hi
hi
p und deren Streuungen x, p in Abhängigkeit von der Zeit zu berechnen
und sichtbar zu machen.
b) Der obige Programmcode läßt sich leicht so abwandeln, daß damit der Tunnelef-
fekt demonstriert werden kann. Ändern Sie das Potential innerhalb des Kastens,
indem Sie in die Mitte des Kastens eine gaußförmige Barriere der Form
V0 e (x 12 )2 =(2d2 )
setzen. Versuchen Sie, ein numerisches Kriterium für die Tunnelzeit tT zu fin-
den. Zum Beispiel ist die Wahrscheinlichkeit wn , das Teilchen zur Zeit tn = n dt
P j j
rechts von der Barriere zu finden, durch
J j 2
j =J=2 n
P j j
wn = J j 2
j =1 0
berechenbar. Bestimmen Sie numerisch die Abhängigkeit der Tunnelzeit von V0
und der Barrierenbreite d.
Literatur
S. Brandt, H. D. Dahmen, Quantum Mechanics on the Personal Computer, Springer
Verlag, 1992.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
Kapitel 5
Monte-Carlo-Simulationen
5.1 Zufallszahlen
Ein Computer kann keine Zufallszahlen erzeugen. Er arbeitet nach einem wohlde-
finierten Programm, nach Regeln also, die auf Eingabedaten angewendet werden
und Ausgabedaten erzeugen. Ein Computer funktioniert daher wie eine determini-
stische Abbildung, die dem Zufall keinen Raum läßt. Dennoch gibt es Algorithmen,
die Pseudozufallszahlen“ erzeugen. Bei vielen statistischen Tests führt eine solche
”
Folge von Zahlen zu ähnlichen Ergebnissen wie sie Zufallszahlen erzeugen würden,
die die mathematische Definition von zufällig“ erfüllen. Wir wollen hier solche
”
Algorithmen kurz vorstellen.
rn = f (rn 1 ) ; (5.1)
erzeugt demnach eine Folge r0 ; r1 ; r2 ; ::: , die sich nach höchstens 232 Schritten
wiederholen muß. Ein Computer kann daher nur periodische Sequenzen von Zahlen
erzeugen. Bei maximaler Periodenlänge kommt jede Zahl in einer sehr langen Folge
gleich oft vor, diese Zahlen sind demnach gleichverteilt. Wenn die computererzeug-
te Zahlenreihe viele Tests auf Zufälligkeit besteht, so nennt man sie Zufallszahlen.
Eine in diesem Zusammenhang häufig verwendete Abbildung f (r ) ist die Mo-
dulo-Funktion mit drei Parametern a; c und m:
rn = (a rn 1 + c) mod m : (5.2)
Jeder Generator benötigt einen Startwert r0 , den wir hier auf r0 = 1234 gesetzt
haben. Ein kurzes Mathematica-Programm
r0 = 1234
a = 106
c = 1283
m = 6075
zufall[r_] = Mod[a r+c,m]
uniform = NestList[zufall,r0,m+1]/N[m]
tripel = Table[Take[uniform,{n,n+2}],{n,m}]
unitvectors = Map[(#/Sqrt[#.#])&,tripel]
5.1 Zufallszahlen 175
e
die in Gleichung (5.3) beschriebenen Einheitsvektoren n gewinnen. Der folgende
Befehl macht daraus Graphikobjekte und stellt sie auf dem Bildschirm dar:
Show[Graphics3D[Map[Point,unitvectors]],
ViewPoint –> {2,3,2}]
Der Vektor {2,3,2} weist in die Richtung des Beobachters. Bild 5.1 (links) zeigt
e
das Ergebnis. Wären die Punkte n wirklich zufällig verteilt, so müßte bis auf
5.1 Tripel aus Pseudozufallszahlen. Links: Projektion auf die Kugeloberfläche. Rechts: Die-
selben Punkte im Einheitswürfel bei geeigneter Blickrichtung.
einen Geometriefaktor, der von der Projektion des Würfels auf die Kugel herrührt,
dieser Ausschnitt der Oberfläche gleichmäßig mit Punkten überdeckt sein. Man
sieht aber deutliche Strukturen, die aus der Korrelation zwischen drei aufeinan-
derfolgenden Zahlen rn entstehen. Tatsächlich läßt sich zeigen, daß die Punkte
u n = (rn ; rn+1 ; rn+2 )=m wie die Bausteine eines Kristalls auf einem regelmäßi-
gen Gitter liegen. Ausgehend von einem Gitterpunkt kann man die nächstgelegenen
Punkte aufsuchen und auf diese Weise die primitiven Gittervektoren bestimmen.
Blickt man aus genügend großer Entfernung und geeigneter Richtung auf die Zu-
fallspunkte, so wird diese Gitterstruktur sichtbar. Bild 5.1 (rechts) ist das Resultat
von
Show[Graphics3D[Map[Point, tripel]],
ViewPoint –> {–325., 2000., –525.}]
Es ist klar zu erkennen, daß insgesamt 14 Ebenen ausreichen, um alle Punkte unter-
zubringen. Dieser Wert ist noch als relativ gut anzusehen, denn er ist zu vergleichen
176 5 Monte-Carlo-Simulationen
mit der völlig regelmäßigen kubischen Struktur, die auf m1=3 = 60751=3 ' 18
Ebenen führt. Bei einer Periode von m = 6075 können die Vektoren also nicht
gleichförmiger als auf 18 Ebenen verteilt sein. Eine schlechte Wahl von a und c hat
zur Folge, daß weniger Ebenen ausreichen, um alle Punkte aufzunehmen.
In Abbildung 5.2 sind die Zufallszahlen in derselben Art aufgetragen wie in Bild
5.1 (links), nur wurden sie diesmal mit dem Mathematica-Generator Random[]
erzeugt. Jetzt erkennt man keine Struktur mehr auf der Kugeloberfläche. Das be-
deutet aber nicht, daß es keine anderen Korrelationen zwischen den Zufallszahlen
gibt. Bei geeigneter Auftragung könnten auch höhere Korrelationen oder Abhängig-
keiten zwischen weit voneinander entfernten Zahlen dem Auge sichtbar werden.
Es gibt verschiedene Tricks, um möglichst große Perioden und gute Zufallszahlen
zu erhalten. Man kann mehrere verschiedene Generatoren ineinander verschachteln,
oder man kann andere Abbildungen f benutzen. Ebenso kann man sich Sequenzen
von einzelnen Bits erzeugen, indem man Bits in einem festem Abstand miteinander
logisch verknüpft. Nach dieser Vorschrift wird ein neues Bit erzeugt, und danach
wird das Verknüpfungsfenster um eine Stelle verschoben. Es ist aber bekannt, daß
auch solche Schieberegister-Generatoren Korrelationen in den Bitsequenzen liefern.
Wie kann man überhaupt mit einfachen Abbildungen aus m verschiedenen Zah-
len Perioden erzeugen, die länger sind als m? Um dies zu erreichen, kann man
Gleichung (5.1) z. B. dadurch erweitern, daß rn nicht nur aus einer, sondern aus
zwei oder mehreren schon erzeugten Zahlen rj berechnet wird:
rn = f (rn t ; rn s ) : (5.4)
5.1 Zufallszahlen 177
Dabei sind t und s geeignet gewählte natürliche Zahlen mit t > s. Jetzt wiederholt
f g
sich die Folge erst, wenn alle Zahlen rn t ; rn t+1 :::; rn 1 schon einmal vorge-
kommen sind. Benutzt man ganze Zahlen mit 32 Bits, so kann der Generator daher
maximal 232 t Zahlen erzeugen. Auf diese Weise lassen sich also Zahlenfolgen mit
riesigen Perioden erzeugen. Schon für t = 2 kann ein Programm, das pro Sekunde
eine Million Zufallszahlen erzeugt, 584942 Jahre laufen, bevor sich die Zahlenfolge
wiederholt.
Natürlich muß man in der Iteration (5.4) noch eine Funktion f finden, die auch
wirklich die maximale Periode 232 t erzeugt. Vor etwa 10 Jahren haben Marsaglia
und Zaman eine Klasse von einfachen Funktionen gefunden, die fast die maximale
Periode liefern. Sie nennen diese Funktionen subtract-with-borrow generators:
Dabei ist c ein Bit, das für den folgenden Schritt auf c = 1 oder c = 0 gesetzt wird,
je nachdem, ob rn s rn t negativ oder positiv ist. Mit zahlentheoretischen Argu-
menten geben die Autoren Werte von s; t und m an, bei denen die Periodenlänge
berechnet werden kann. So hat der Generator
die Periodenlänge (m3 m2 )=3 ' 295 . Dieser Generator eignet sich außerdem
hervorragend für die Sprache C. In modernen Rechnern ist die Operation Modulo
232 automatisch bei der Arithmetik von ganzen Zahlen mit 32 Bit Länge eingebaut.
Da C vorzeichenlose Integerzahlen erlaubt (unsigned long int), kann man Gleichung
(5.6) sehr einfach programmieren.
Marsaglia und Zaman kombinieren diesen Generator mit
der die Periode 232 hat. Die Gleichungen (5.6) und (5.7) können leicht in der C-
Sprache formuliert werden.
#define N 1000000
typedef unsigned long int unlong;
unlong x=521288629, y=362436069, z=16163801,
c=1, n=1131199209;
unlong mzran()
{ unlong s;
if(y>x+c) {s=y–(x+c); c=0;}
else {s=y–(x+c)–18; c=1;}
x=y; y=z; z=s; n=69069*n+1013904243;
178 5 Monte-Carlo-Simulationen
return (z+n);
}
main()
{
double r=0.;
long i;
for (i=0;i<N; i++)
r+=mzran()/4294967296.;
printf ("r= %lf \n",r/(double)N);
}
x, y, z und n werden auf Anfangswerte gesetzt, die der Benutzer beliebig ändern
kann. Das Hilfsbit c muß auf c = y > z gesetzt werden, in C also auf 1 (wahr) oder
0 (falsch). Da dieses Programm für einen Rechner geschrieben ist, der die Modulo-
232 -Operation automatisch durchführt, muß bei mod (232 18) der Wert 18 noch
von der Differenz (rn 2 rn 3 c) abgezogen werden. Das geschieht natürlich nur,
wenn diese Differenz negativ ist, denn sonst kommt die Modulo-Operation nicht vor.
Der nächste rn -Wert ist die Summe der beiden Generatoren (5.6) und (5.7).
Weil diese beiden Generatoren teilerfremde Perioden haben, ist die Länge des
zusammengesetzten Generators das Produkt der beiden einzelnen Längen, also etwa
2127 . Dieser Generator kann etwa 1024 Jahre laufen, bevor sich die Zufallszahlen
wiederholen. Da die Zahlenfolge außerdem eine Menge statistischer Tests bestanden
hat, kann man bei vielen Anwendungen davon ausgehen, daß sich diese Zahlen so
verhalten wie echte“ Zufallszahlen.
”
Dennoch müssen wir den Leser warnen: auch die obigen Pseudozufallszahlen
entstehen aus einem deterministischen Algorithmus, der sogar zahlentheoretisch
analysiert werden kann. Man kann also nicht ausschließen, daß Korrelationen bei
statistischen Anwendungen stören. Jedes Problem reagiert anders auf unterschied-
liche Korrelationen. Daher können die Experten auch nach einigen Jahrzehnten Er-
fahrung mit Zufallszahlen nur den Rat geben, verschiedene Generatoren zu benut-
zen und die Ergebnisse zu vergleichen. Wenn möglich, sollte man sich ein ähnliches
Problem suchen, das exakt gelöst werden kann und die numerischen Ergebnisse
mit den exakt berechneten vergleichen. Dann hat man eine gewisse Sicherheit über
die Qualität der Zufallszahlen. Da die zukünftigen Computersimulationen immer
umfangreicher und genauer werden, darf die Qualität der Zufallszahlen nicht ver-
nachlässigt werden.
Die Beispiele in unserem Lehrbuch dienen nur zur Demonstration und nicht zur
genauen quantitativen Analyse. Deshalb werden wir im folgenden nur die in den
Programmiersprachen vorhandenen Generatoren rand() bzw. Random[] benut-
zen.
5.1 Zufallszahlen 179
Übung
a) Programmieren Sie die beiden Zufallszahlengeneratoren
(I ) rn = (rn 2 rn 5 ) mod 10 ;
(II ) rn = (rn 2 rn 5 c) mod 10 ;
wobei c = 1 oder c = 0 gesetzt wird, falls (rn 2 rn 5 ) < 0 bzw. > 0 ist.
Beide Generatoren erzeugen ganze Zahlen 0; 1; : : : ; 9 und wiederholen die Zah-
lenfolge, wenn die letzten fünf Zahlen schon einmal vorgekommen sind. Beide
müssen daher nach maximal 105 Schritten die erzeugte Zahlenfolge wiederho-
len.
Starten Sie mit verschiedenen Sätzen von fünf Anfangsziffern und berechnen Sie
die tatsächliche Periodenlänge der erzeugten Zahlenfolgen.
Tip: Die Periodenlänge der Generatoren läßt sich z. B. dadurch berechnen, daß
man zwei Folgen parallel erzeugt. Bei der zweiten Folge erzeugt man jeweils
zwei Schritte und beobachtet dann, wann die zweite die erste Folge überholt.
b) Erzeugen Sie sich die Summe s von N gleichverteilten Zufallszahlen r aus dem
Einheitsintervall. Der Mittelwert der Summe ist dann m = 0:5N und die mitt-
lere quadratische Abweichung, die Varianz, ist
21 0Z1 123
Z
2 = N hr2 i hri2 = N 64 r2dr @ rdrA 75 = 12
N:
0 0
Wiederholen Sie das Experiment sehr oft und zeichnen Sie die Häufigkeit der
Summen in ein Histogramm. Vergleichen Sie das Ergebnis mit einer Gaußver-
teilung mit Mittelwert m und Varianz 2 ,
(s m)2
P (s) = p 1 exp 2 2 :
2
Überprüfen Sie die Übereinstimmung für N = 10; 100 und 1000.
Literatur
K. Binder, D. W. Heermann, Monte Carlo Simulation in Statistical Physics, Springer
Verlag, 1992.
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods: Appli-
cations to Physical Systems, Parts I and II, Addison Wesley, 1988.
180 5 Monte-Carlo-Simulationen
D. E. Knuth, The Art of Computer Programming, Vols. I, II, and III, Addison Wesley,
1973.
G. Marsaglia, A. Zaman, Some portable very-long period random number genera-
tors, Computer in Physics 8, 117 (1994).
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
Physik
Wir beschreiben im folgenden ein Modell eines Wachstumsprozesses, bei dem die
ungerichtete Diffusion von Teilchen, bevor sie angelagert werden, die entscheiden-
de Rolle spielt. Das Abscheiden von Material aus einer Elektrolytlösung bei sehr
geringer Spannung zwischen den Elektroden kann als Beispiel hierfür dienen. Man
muß nur dafür sorgen, daß die Zufallsbewegung der diffundierenden Ionen wichti-
ger ist als ihre Drift aufgrund des elektrischen Feldes. Die Materialablagerung an
5.2 Fraktale Aggregate 181
der Elektrode führt dann nicht zu einem kompakten Gebilde, sondern es entsteht
ein filigranartig verästelter Cluster, den wir wieder durch eine fraktale Dimension
D beschreiben können. D ist etwa 5=6 mal so groß wie die Raumdimension.
Den Prozeß nennt man Diffusion Limited Aggregation (DLA). Obwohl DLA ein-
fach auf dem Computer simuliert und analysiert werden kann, gibt es unseres Wis-
sens bis heute keine analytische Theorie dazu. Dagegen existiert für das Diffusions-
problem bzw. die Zufallsbewegung eines Teilchens eine gut entwickelte mathema-
tische Theorie. Einige Aussagen und Ergebnisse, auf die wir im Algorithmus-Teil
zurückkommen, wollen wir hier kurz erläutern.
Wir betrachten einen random walk auf einem quadratischen, oder auch allgemei-
ner, auf einem d-dimensionalen kubischen Gitter. Die Gittervektoren bezeichnen
x
wir mit , und die Verbindungsvektoren zu den 2 d nächsten Nachbarn nennen wir
x
i ; i = 1; 2; : : : ; 2 d. Die Bewegung unseres Zufallswanderers ist nun dadurch
x
bestimmt, daß er in jedem Zeitschritt t, wenn er zur Zeit t am Gitterplatz ist,
x x
von den nächsten Nachbarplätzen + i einen zufällig auswählt und dort hin-
springt. Setzen wir jetzt viele Teilchen auf das Gitter, die unabhängig voneinander
x
alle nach demselben Zufallsrezept hüpfen, und bezeichnen mit u( ; t) den Bruchteil
x
derer, die zur Zeit t am Platz sind, so erhalten wir folgende Bilanzgleichung:
X
2d
u(x; t + t) u(x; t) = 21d (u(x + xi ; t) u(x; t)) : (5.8)
i=1
x
Den Term u( ; t) haben wir auf beiden Seiten subtrahiert, damit man leichter sieht,
daß dies gerade die diskrete Version der Diffusionsgleichung ist. Dividieren wir
nämlich (5.8) sowohl durch ein geeignetes kleines Volumen, so daß eine Dichte
entsteht, als auch durch t und lassen alle kleinen Größen, insbesondere alle i
p x
proportional zu t, gegen 0 gehen, so erhalten wir für die Wahrscheinlichkeits-
dichte die Gleichung
@u = r2 u
@t (5.9)
erhält für t t0 :
jx x j2
u(x; t) = (4(t t0)) 0
d
2
exp 4(t t0 ) : (5.10)
Wir sehen hieran, daß die Wahrscheinlichkeit, das hüpfende Teilchen, das zur Zeit
x x
t0 bei 0 war, zu einer späteren Zeit t bei anzutreffen, nur vom Abstand r =
jx x j 0 , nicht aber von der Richtung abhängt. Das ist nicht weiter verwunder-
lich und drückt nur die räumliche Isotropie des Diffusionsprozesses aus, die wir
hineingesteckt haben, indem wir alle Raumrichtungen gleichbehandelt haben. Der
Mittelwert ( hx x i
0 ) ergibt sich zu
2
(hx x i0 ) = 2 d (t t0 )
2 (5.11)
p
und besagt, daß die mittlere Ausdehnung des Zufallsweges wie t t0 anwächst.
Dieses Gesetz ist bis auf den Vorfaktor unabhängig von der Dimension d des Raum-
es, in den die Zufallsbewegung eingebettet ist.
Das Modell von Witten und Sander beschreibt ein diffusionsbestimmtes Wachs-
tum, das nach folgender Vorschrift abläuft. Man beginnt mit einem minimalen Clu-
ster, in der Regel mit einem einzelnen Teilchen im Ursprung des Koordinatensy-
stems. Dann läßt man in großer Entfernung und unter einer zufälligen Richtung ein
weiteres Teilchen starten, das solange frei diffundiert, bis es an den Kern im Ur-
sprung anstößt und dort haften bleibt. Daraufhin startet weit draußen, wiederum un-
ter einer zufällig ausgewürfelten Richtung das nächste Teilchen, und dann immer so
weiter. Im Mittel über viele Realisierungen wird der zentrale Cluster radialsymme-
trisch wachsen. Für eine konkrete Realisierung bezeichnen wir die maximale radiale
Ausdehnung des Clusters mit Rmax (t) und bestimmen seine fraktale Dimension D
durch den Zusammenhang zwischen Rmax (t) und seiner Masse M (t), der Zahl der
bis zum Zeitpunkt t angelagerten Teilchen:
M / Rmax
D : (5.12)
x
Wenn wir dieses Modell durch eine Wahrscheinlichkeitsdichte u( ; t) der diffun-
dierenden Teilchen beschreiben wollen, so müssen wir als Randbedingung berück-
sichtigen, daß die Dichte am gerade entstandenen Cluster verschwindet. Ein weite-
res Teilchen wird mit einer Wahrscheinlichkeit, die proportional zum Teilchenstrom
ist, am Cluster angelagert. Näherungsweise können wir aber auch annehmen, daß
alle Teilchen, die einen gewissen Einfangradius Rc unterschreiten, durch Absorpti-
on weggefangen werden. Nach Witten und Sander ist aber Rc proportional zu Rmax ,
und wir machen für die nachfolgende Dimensionsbetrachtung keinen Fehler, wenn
wir Rc durch Rmax ersetzen. Außerdem können wir davon ausgehen, daß die Zeit,
die den Diffusionsprozeß charakterisiert, z. B. die Zeit, die ein diffundierendes Teil-
chen benötigt, um die Strecke zum Nachbarplatz zurückzulegen, sehr viel kleiner ist
5.2 Fraktale Aggregate 183
als die Zeit, die das Anwachsen des Clusters charakterisiert. Mit anderen Worten,
wir suchen eine radialsymmetrische, zeitunabhängige Lösung der Diffusionsglei-
chung (5.9) mit der Randbedingung u(Rmax ) = 0. Die Gleichung
u = rd1 1 @r @ rd 1 @ u = 0
@r (5.13)
können wir aber leicht integrieren. Wir erhalten für d > 2 die Lösung
R d 2 !
max
u(r) = u0 1 r ; (5.14)
Die Geschwindigkeit v , mit der die Clustergröße zunimmt, ist also proportional zu
Rmax
d 1 D . Stecken wir jetzt noch die plausible Annahme hinein, daß v jedenfalls
nicht mit der Clustergröße anwachsen kann, so darf der Exponent d 1 D nicht
positiv sein, es muß also d 1 D gelten. Andererseits ist der DLA-Cluster in den
d-dimensionalen Raum eingebettet, so daß wir die Relation
d 1Dd (5.16)
erhalten, die durch numerische Simulationen für d = 2; 3; : : : ; 8 bestätigt wurde.
Algorithmus
Wir wollen einen DLA-Cluster auf einem 2-dimensionalen quadratischen Gitter er-
zeugen. Dazu besetzen wir den Platz in der Mitte des Gitters, setzen ein weiteres
Teilchen im Abstand Rs auf das Gitter und lassen es diffundieren, bis es entweder
am besetzten Platz hängenbleibt oder einen Abstand Rk > Rs dazu überschritten
hat. Dies wird iteriert. Der Algorithmus lautet also:
1. Starte mit einem leeren Quadratgitter und besetze den mittleren Gitterplatz mit
einem Teilchen.
2. Die aktuelle Größe des Aggregates sei durch den Radius Rmax gegeben. Setze ein
&
Teilchen auf einen zufällig gewählten Platz, der einen Abstand Rs Rmax vom
Ursprung hat, und lasse es zu einem zufällig gewählten Nachbarplatz hüpfen.
184 5 Monte-Carlo-Simulationen
3. Wenn das Teilchen einen Nachbarplatz des Aggregates erreicht, so wird es hin-
zugefügt und Rmax wird eventuell erhöht. Wenn das Teilchen den Abstand Rk
(Rk > Rs > Rmax) überschreitet, dann wird es vernichtet.
4. Iteriere 2 und 3 und berechne D = ln N= ln Rmax , wobei N die Anzahl der
Aggregatteilchen ist.
Die Skizze 5.3 zeigt noch einmal den kleinsten Kreis mit dem Radius Rmax um
das Aggregat, den Startkreis und den Vernichtungskreis. Allerdings verfälscht die
Einführung eines Vernichtungskreises die Eigenschaften des Aggregates, denn das
diffundierende Teilchen kann auch für R > Rk wieder zum Aggregat zurückkeh-
ren. Unser Algorithmus beschreibt also erst im Limes Rk !1 das eigentliche
Problem. Große Rk -Werte bedeuten aber große Rechenzeiten, und wir erwarten kei-
ne wesentlichen Abweichungen für endliche Rk -Werte. Man kann die Wahrschein-
lichkeit, daß das Teilchen an eine bestimmte Stelle des Startkreises zurückkehrt,
analytisch berechnen und damit das Teilchen in einem Schritt zurücksetzen. Da-
mit vermeidet man den Vernichtungskreis. Bei großen Aggregaten lohnt sich dieser
Aufwand, doch wir wollen hier darauf verzichten.
Vernichte
Starte
Der Algorithmus läßt sich darüber hinaus noch wesentlich beschleunigen, wenn
man um das Teilchen, das sich vom Cluster wegbewegt hat, einen möglichst großen
Kreis konstruiert, der gerade den Rand des Aggregates berührt. Da das diffundieren-
de Teilchen nach Gleichung (5.10) mit gleicher Wahrscheinlichkeit an jedem Punkt
dieses Kreises ankommt, kann man es zufällig auf den Kreis setzen, ohne die zeit-
aufwendige Diffusion zu simulieren. Dies wird solange wiederholt, bis das Teilchen
einen Nachbarplatz des Aggregates erreicht hat oder den Vernichtungskreis über-
schreitet. Der Algorithmus dazu lautet also:
5.2 Fraktale Aggregate 185
1. Starte mit einem leeren Quadratgitter und besetze den mittleren Gitterplatz mit
einem Aggregatteilchen.
2. Die aktuelle Größe des Aggregates ist Rmax . Setze ein Teilchen auf einen zufällig
&
gewählten Platz auf den Kreis mit dem Radius Rs Rmax und lasse es zu einem
zufällig gewählten Nachbarplatz hüpfen.
3. Wenn das Teilchen einen Nachbarplatz des Aggregates erreicht, so wird es hin-
zugefügt und Rmax wird eventuell erhöht. Wenn das Teilchen den Abstand Rd >
&
Rs Rmax überschreitet – seine Entfernung vom Ursprung sei R – , so wird es
auf einen zufällig gewählten Platz auf einem Kreis um das Teilchen mit dem Ra-
dius (R Rs ) gesetzt. Wenn das Teilchen den Abstand Rk > Rd > Rs Rmax &
überschreitet, so wird es vernichtet.
4. Iteriere 2. und 3. und berechne D = ln N= ln Rmax , wobei N die Anzahl der
Aggregatteilchen ist.
Die Skizze 5.4 soll diesen Algorithmus noch einmal verdeutlichen. Zur schnellen
Starte Vernichte
Rd
Rmax
5.4 Wie Bild 5.3, doch außerhalb
des Kreises mit dem Radius Rd legt
das Teilchen mit einem Sprung die
Strecke R Rs zurück.
void besetze()
{
double phi;
phi=(double)rand()/RAND_MAX*2.*pi;
rx=rs*sin(phi);
ry=rs*cos(phi);
}
Das Hüpfen auf einen der vier Nachbarplätze wird mit einer zufällig gewählten Zahl
0; 1; 2 oder 3 gesteuert:
void huepfe()
{
int r;
r=random(4);
switch(r)
{
case 0: rx+=1;break;
case 1: rx+=–1;break;
case 2: ry+=1;break;
case 3: ry+=–1;break;
}
}
Nach jedem Sprung muß geprüft werden, ob das Teilchen vernichtet wird (R >
Rk ), ob es einen Randplatz des Aggregates erreicht hat, ob ein Hüpfsprung (R <
Rd) oder ein Kreissprung (R Rd ) gemacht wird. Diese vier ”wenn“ im Schritt
Nr. 3 des obigen Algorithmus werden durch die Funktion pruefe() abgefragt:
char pruefe()
{
double r,x,y;
x=rx;
y=ry;
r=sqrt(x*x+y*y);
if (r > rkill) return ’v’;
if (r >= rd) return ’k’;
if (xf[rx + 1 + lmax/2][ry + lmax/2] +
xf[rx – 1 + lmax/2][ry + lmax/2] +
xf[rx + lmax/2][ry + 1 + lmax/2] +
xf[rx + lmax/2][ry – 1 + lmax/2] > 0)
return ’a’;
else
5.2 Fraktale Aggregate 187
return ’h’;
}
lmax ist die Größe des Zeichenfensters. Die folgende Funktion fügt das Teilchen
zum Aggregat hinzu:
void aggregate()
{
double x,y;
xf[rx+lmax/2][ry+lmax/2]=1;
x=rx;y=ry;
rmax= max(rmax,sqrt(x*x+y*y));
if(rmax>lmax/2.–5.) {printf("\7");stop=1;}
circle(4*rx+340,4*ry+240,2);
}
und beim Kreissprung wird ein Zufallsvektor mit dem Betrag R Rs zum Ort des
Teilchens addiert,
void kreissprung()
{
double r,x,y,phi;
phi=(double)rand()/RAND_MAX*2.*pi;
x=rx; y=ry; r=sqrt(x*x+y*y);
rx+=(r–rs)*sin(phi);
ry+=(r–rs)*cos(phi);
}
Die Koordinaten rx und ry des Teilchens und das Aggregatfeld xf[rx][ry]
werden vor dem Hauptteil main() global deklariert, so daß alle Funktionen auf sie
zugreifen können. Mit den obigen fünf Funktionen lautet dann der wesentliche Teil
des Hauptprogrammes
while(stop==0)
{
if(kbhit()) stop=1;
switch(pruefe())
{
case ’v’:besetze();huepfe();break;
case ’a’:aggregate();besetze();huepfe();break;
case ’h’:huepfe();break;
case ’k’:kreissprung();break;
}
}
188 5 Monte-Carlo-Simulationen
Ergebnis
In Bild 5.5 ist das Ergebnis der Simulation zu sehen. Auf der Workstation haben sich
innerhalb einer Minute 1540 Teilchen zu einem fraktalen Aggregat angelagert. Mit
der maximalen Ausdehnung von 63 Gitterabständen erhält man die Abschätzung
'
D = ln 1540= ln 63 1:77 für die fraktale Dimension.
Die Simulationen zeigen außerdem, daß durch die Einführung der großen Sprünge
für R > Rd die Rechenzeit sich nicht wesentlich erhöht, wenn man den Radius des
Vernichtungskreises vergrößert.
Übung
Verbesserte Dimensionsanalyse
Bei der Bestimmung der fraktalen Dimension haben wir bisher vernachlässigt, daß
der momentan erzeugte Cluster noch nicht fertig ist. Während sich die Arme“ des
”
Clusters weiter ausbilden, können immer noch weitere Teilchen in seine inneren Be-
reiche gelangen. Durch unser willkürliches Abbrechen beim Erreichen eines gewis-
sen maximalen Radius vernachlässigen wir diese Teilchen. Der tatsächliche Cluster
sollte etwas dichter, die fraktale Dimension etwas höher sein.
Berechnen Sie die Masse des Clusters unter Vernachlässigung aller Teilchen, die
einen Abstand größer als r haben. Tragen Sie in einem log-log-Diagramm die Mas-
se über r auf und versuchen Sie, das Verhalten zu interpretieren.
5.3 Perkolation 189
Literatur
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods:
Applications to Physical Systems, Parts I and II, Addison Wesley, 1988.
E. Sander, L. M. Sander, R. M. Ziff, Fractals and fractal correlations, Computers
in Physics 8, 420 (1994).
5.3 Perkolation
In einem idealen Kristall sind alle Atome regelmäßig auf einem Gitter angeordnet.
Für diesen Fall können wir die Fouriertransformation benutzen, um die periodischen
Strukturen und auch die Kristallanregungen, z. B. die Phononen, zu beschreiben.
Weil aber unsere Natur nur selten aus idealen Kristallen besteht, bemühen sich die
Festkörperphysiker seit Jahrzehnten, auch Materialien mit unregelmäßigen Struktu-
ren zu verstehen.
Es gibt eine einfache Beschreibung eines ungeordneten Materials, das Perko-
lationsmodell. Das englische Wort to percolate bedeutet durchsickern. Das Mo-
dell soll ein poröses Material beschreiben, durch das gewisse Teilchen hindurch-
diffundieren können, falls es durchgehende Wege durch die Poren gibt. Die Geo-
metrie der zufällig entstanden Poren wird durch die Perkolationstheorie beschrie-
ben. Das Modell kann jedem Schüler erklärt werden, es kann auf einem Computer
leicht programmiert werden, und dennoch enthält es interessante Physik, die mit
Phasenübergängen, kritischen Phänomenen, Universalität und selbstähnlichen Frak-
talen zusammenhängt.
In diesem Abschnitt wollen wir das Perkolationsmodell vorstellen und simulie-
ren.
190 5 Monte-Carlo-Simulationen
Physik
Nehmen wir an, wir haben eine Legierung, die aus zwei Atomsorten besteht, die
wir A- und B -Atome nennen wollen. Die Konzentration der A-Atome sei p, und
beide Teilchensorten sollen zufällig verteilt sein und zusammen ein regelmäßiges
Kristallgitter bilden. Wir wollen weiterhin annehmen, daß die A-Atome magnetisch
sind mit einer kurzreichweitigen magnetischen Wechselwirkung, die nur bei unmit-
telbarer Nachbarschaft zweier A-Atome zum Tragen kommt. Wenn es keine Kopp-
lung zu den unmagnetischen B -Atomen gibt, so kann der Kristall nur dann eine
magnetische Ordnung bilden, wenn ein unendlich großes Netz von zusammenhän-
genden A-Atomen existiert. Phasenübergänge gibt es zwar streng genommen nur in
unendlich großen Systemen mit hinreichend großer Vernetzung, in unseren Compu-
tersimulationen werden wir aber auch für endlich große Systeme bei einer kritischen
Konzentration der A-Atome deutliche Anzeichen eines Phasenübergangs erkennen
können. Die Größe der Strukturen von A-Atomen, die alle untereinander verbunden
sind, spielt dabei eine wichtige Rolle. Eine solche Menge von A-Atomen, die durch
ihre Kopplungen zusammenhängen, wird Cluster genannt.
Bei kleinen Konzentrationen p gibt es nur eine Menge kleiner Cluster ohne ma-
gnetische Ordnung. Mit wachsendem p wird die mittlere Größe der zusammenhän-
genden A-Atome ebenfalls wachsen, bis sich ab einem Schwellenwert pc ein Clu-
ster durch den ganzen Kristall ausdehnt. pc nennt man Perkolationsschwelle oder
kritische Konzentration. Für p > pc koexistiert der unendliche mit vielen kleinen
Clustern, erst bei p = 1 sind alle Plätze mit A-Atomen besetzt, und es gibt nur einen
(unendlichen) Cluster.
Für den unendlich großen Kristall gibt es nur einen wohldefinierten Wert für die
Perkolationsschwelle pc . Beispielsweise findet man auf dem quadratischen Gitter
mit vier nächsten Nachbarn den numerischen Wert pc = 0:59275 0:00003, auf
dem Dreiecksgitter mit sechs Nachbarplätzen ist pc = 1=2 exakt bekannt. pc hängt
zwar vom Gittertyp und der Reichweite der Kopplungen ab, nicht aber von der spe-
ziellen Realisierung der Probe, wenn man die Größe des Kristalls gegen Unendlich
gehen läßt. Im endlichen Kristall dagegen gibt es, abhängig von p, natürlich nur eine
gewisse Wahrscheinlichkeit dafür, daß ein Cluster existiert, der zwei gegenüberlie-
gende Seiten verbindet.
Man kann nun viele Fragen zu den Eigenschaften der Cluster stellen und da-
zu mathematische Gesetzmäßigkeiten erarbeiten. Wie groß ist pc für verschiedene
Gitterstrukturen und Clusterdefinitionen? Wie wächst die mittlere Ausdehnung der
endlichen Cluster, wenn man die Konzentration p bis zur Schwelle pc erhöht? Wie
wächst die Dichte des unendlichen Clusters oberhalb pc ? Wie sieht die Verteilung
der Clustergrößen aus? Hat der unendliche Cluster bei pc eine Struktur?
Besonders interessant sind die Gesetzmäßigkeiten in der Nähe der Perkolations-
schwelle pc . Wir definieren z.B. eine mittlere Ausdehung R(s) eines Clusters mit s
5.3 Perkolation 191
Teilchen durch
X
R2(s) = s(s 1 1) (r i r j )2 ; (5.17)
i6=j
wobei i und j die Teilchen des Clusters durchnumerieren und r i die Position des
i-ten Atoms auf dem Gitter ist. Die mittlere Ausdehnung der endlichen Cluster ist
dann definiert durch p
= hR2(s)is<1 (5.18)
h i
dabei bezeichnet ::: s<1 den Mittelwert über alle endlichen Cluster .
divergiert an der Perkolationsschwelle, und dicht bei pc gilt:
jp pcj : (5.19)
In zwei Dimensionen gilt = 5=36 ' 0:14 ; P (p) wächst also bei pc sehr steil an.
Direkt an der Perkolationsschwelle verschwindet zwar die Dichte des unendli-
chen Clusters, P (pc ) pc = 0, trotzdem existiert er, und er hat eine interessante
Struktur: Er ist ein Fraktal. Wenn wir einen quadratischen Ausschnitt des Gitters
mit der Kantenlänge L betrachten, und wenn M (L) die Anzahl der Teilchen des
unendlichen Clusters in diesem Ausschnitt ist, dann gilt bei pc :
hM (L)i / LD ; (5.21)
h i
wobei ::: den Mittelwert über verschiedene Ausschnitte bezeichnet. Die Masse
des Clusters wächst also mit einer Potenz der Länge, und nach Abschnitt 3.3 ist
'
D seine fraktale Dimension. In der Ebene gilt D = 91=48 1:89. Der kritische
Perkolationscluster ist also wesentlich kompakter als das durch Diffusion erzeugte
Aggregat aus dem vorherigen Abschnitt.
Bisher haben wir drei universelle kritische Exponenten ; und D kennenge-
lernt, aber noch viele andere Eigenschaften werden bei pc durch Potenzgesetze
192 5 Monte-Carlo-Simulationen
mit weiteren Exponenten beschrieben. Solche Singularitäten sind aber nicht un-
abhängig voneinander, sondern hängen durch Skalengesetze miteinander zusam-
men. Wir wollen hier nur die Idee skizzieren und für das tiefere Verständnis auf
die Lehrbücher zu den kritischen Phasenübergängen und der Renormierungsgrup-
pentheorie verweisen.
Sei M (p; L) die mittlere Anzahl der Teilchen eines Clusters, der ein Quadrat der
Länge L durchquert. Für jeden Wert von L erhält man die Anzahl M als Funktion
von p ; dies ergibt eine ganze Kurvenschar. Die Skalentheorie besagt nun, daß diese
Kurvenschar in der Nähe des kritischen Punktes nach geeigneter Skalierung durch
eine einzige universelle Funktion f beschrieben wird. Die Skalen für die Größen M
und L können durch Potenzen von entweder p pc oder mit Gleichung (5.19) von
ausgedrückt werden. L wird dabei in Einheiten von und M in Einheiten einer
Potenz von , z. B. x , gemessen. Das bedeutet:
L
M (p; L) x f ; (5.22)
wobei f eine zunächst unbekannte Funktion und x ein kritischer Exponent ist. Setzt
man L = k mit einer Konstanten k , so folgt aus Gleichung (5.21) x = D . L
wird also in Einheiten von und M in Einheiten von D gemessen, daher der Name
Skalentheorie.
Aus L = k folgt auch:
M (p; L) D d f (k) ;
Ld (5.23)
wobei Ld die Anzahl der Gitterpunkte im d-dimensionalen Würfel mit der Kan-
tenlänge L ist. M=Ld ist aber die Wahrscheinlichkeit, daß ein Gitterplatz zum per-
kolierenden Cluster gehört. Für große L-Werte gilt daher:
M (p; L) ' p P (p) (p p ) :
c
Ld (5.24)
= (d D) : (5.26)
Die drei kritischen Exponenten sind damit durch ein Skalengesetz miteinander ver-
koppelt. Tatsächlich genügt die Kenntnis zweier Exponenten, um alle anderen zu
berechnen.
5.3 Perkolation 193
Zunächst sind die kritischen Exponenten nur für das unendlich große Gitter defi-
niert. Mit dem Computer können wir aber nur endliche Gitter mit Teilchen besetzen.
Im endlichen System gibt es jedoch keinen Phasenübergang, keine scharf definierte
Perkolationsschwelle und keine Divergenzen. Wie kann man von den Eigenschaf-
ten eines endlichen Systems auf die kritischen universellen Gesetze des unendlichen
Gitters schließen?
Die Theorie des finite size scaling beantwortet diese Frage. Sie basiert auf den
oben skizzierten Skalengesetzen, die auch etwas über die Abhängigkeit der Singula-
ritäten von der Gittergröße L aussagen. Benutzt man das durch Gleichung (5.19) be-
schriebene Verhalten der Korrelationslänge in der Skalenbeziehung (5.22), so erhält
man mit f (x) = f~(x1= ) :
M (p; L) jp pc j D f~ (p pc)L1= :
(5.27)
Die Konzentration p und die Systemlänge L sind also in der Nähe des kritischen
Punktes p = pc ; L = 1 miteinander verknüpft.
Die fraktale Dimension D erhält man schon aus Gleichung (5.21). Denn für
L sieht das endliche System wie das unendlich große aus. Deshalb folgt aus
Gleichung (5.21) M (pc ; L) LD . Aus dem Anstieg der Zahl M (pc ; L) der Teil-
chen im perkolierenden Cluster mit der Gittergröße L kann man also die fraktale
Dimension D numerisch berechnen. Wie aber bestimmt man pc und den Exponen-
ten ?
Dazu stellen wir ein Skalengesetz analog zu Gleichung (5.27) für die Wahrschein-
lichkeit (p; L) auf, daß es in einer Probe der Größe L einen Cluster gibt, der zwei
gegenüberliegende Seiten verbindet, der also perkoliert. Offenbar gilt
0 p < pc ;
(p; 1) = 1
für
für p > pc : (5.28)
Für endliche L-Werte wird diese Stufenfunktion in der Nähe von pc abgerundet. Da
im unendlichen System für p > pc eine Konstante ist, hat der entsprechende Ska-
lenexponent den Wert Null. Die Skalengleichung für (p; L), analog zu Gleichung
(5.27) für M (p; L), lautet also mit einer unbekannten Funktion g :
Wenn wir nun die Plätze eines Gitters mit der Wahrscheinlichkeit p mit Atomen
besetzen und dann p erhöhen, so wachsen alle Cluster. Bei einem Schwellenwert
pc(L) wird ein perkolierender Cluster auftreten.
Die Wahrscheinlichkeit, daß pc (L) im Intervall [p; p + dp] liegt, ist durch die
Ableitung (d=dp) dp an der Stelle pc (L) gegeben. d=dp zeigt ein Maximum,
das für L ! 1 divergiert und zur Perkolationsschwelle pc des unendlichen Gitters
läuft. Wegen der großen statistischen Fluktuationen läßt sich das Maximum von
194 5 Monte-Carlo-Simulationen
d=dp nur schlecht numerisch bestimmen. Es ist besser, den Mittelwert und die
Fluktuationen von pc (L) zu berechnen. Der Mittelwert der Perkolationsschwelle ist
gegeben durch Z d
hpc(L)i = p dp dp : (5.30)
L 1= : (5.34)
Aus der Standardabweichung von pc (L) läßt sich somit der Parameter direkt ge-
winnen.
Mit Hilfe der Skalengesetze gelingt es uns also, die kritischen Werte des unend-
lichen Gitters aus den Eigenschaften endlicher Systeme zu berechnen. Dieses finite
size scaling ist nicht nur auf das Perkolationsproblem beschränkt, sondern es gilt
auch für andere Arten von Phasenübergängen, z. B. für den magnetischen Übergang
des Ising-Ferromagneten, den wir in Abschnitt 5.5 behandeln werden. Wir haben da-
mit ein wichtiges Werkzeug kennengelernt, um universelle, also modellunabhängige
Größen zu berechnen.
Schließlich sollten wir erwähnen, daß es neben der hier besprochenen site per-
colation auch die sogenannte bond percolation gibt. Dabei werden nicht die Plätze
des Gitters, die sites, sondern die Verbindungslinien benachbarter Plätze, die bonds,
mit der Wahrscheinlichkeit p besetzt. Solche Systeme haben zwar eine andere Per-
kolationsschwelle, jedoch dieselben universellen kritischen Eigenschaften wie das
besprochene Modell.
5.3 Perkolation 195
Algorithmus
Auf einem Gitter läßt sich die Perkolationsstruktur numerisch leicht erzeugen. Wir
wählen ein Quadratgitter mit Gitterplätzen (i; j ); i = 0; : : : ; L 1 und j =
2
0; : : : ; L 1, und benutzen gleichverteilte Zufallszahlen r [0; 1]. Der Algo-
rithmus lautet damit:
1. Durchlaufe alle (i; j ).
2. Ziehe eine Zufallszahl r .
3. Falls r < p, zeichne einen Punkt am Platz (i; j ).
Das C-Programm dazu lautet:
double p = 0.59275;
int i, j, L = 500, pr;
pr = p*RAND_MAX;
for (i = 0; i < L; i++)
for (j = 0; j < L; j++)
if (rand() < pr) putpixel(i,j,WHITE);
Bild 5.6 zeigt das Ergebnis. Man sieht eine scheinbar regellose Struktur. Es ist des-
halb überraschend, daß man daraus durch geeignete Fragen und deren quantitative
Beantwortung so vielfältige mathematische Gesetzmäßigkeiten herausholen kann.
Allerdings ist die Auswertung der Perkolationsstruktur nicht mehr so einfach zu
programmieren wie deren Erzeugung. Die Frage z. B., ob die Struktur in Bild 5.6
perkoliert, ob es also einen Weg über besetzte Nachbarplätze gibt, der zwei ge-
genüberliegende Seiten verbindet, läßt sich nicht leicht beantworten. Auch unser
Auge ist mit dieser Frage überfordert.
Wir brauchen einen Algorithmus, der Cluster von zusammenhängenden Teilchen
identifizieren kann. Eine naive Methode wäre, von jedem besetzten Platz aus wach-
sende Kreise zu ziehen und alle verbundenen Plätze zu markieren. Dies kostet aber
sehr viel Rechenzeit. Ein schneller Algorithmus wurde 1976 von Hoshen und Ko-
pelman entwickelt. Dabei wird das Gitter nur einmal durchlaufen, und es werden
Clusternummern an alle besetzten Plätze vergeben. Jeder Platz, der nicht mit vorher
besuchten verbunden ist, erhält eine neue Nummer. Allerdings werden dabei manch-
mal auch Teile desselben Clusters mit unterschiedlichen Nummern belegt. Durch
einen Buchhaltungstrick können solche Kollisionen am Ende leicht aufgelöst wer-
den. Die Details dieses Algorithmus sind in den Lehrbüchern von Stauffer/Aharony
und Gould/Tobochnik gut beschrieben.
Hier wollen wir einen anderen Weg verfolgen, der von Leath ebenfalls im Jahr
1976 vorgeschlagen wurde. Cluster sollen direkt durch einen Wachstumsprozeß er-
zeugt werden. Dazu besetzen wir zunächst nur das Zentrum eines leeren Gitters
196 5 Monte-Carlo-Simulationen
und definieren alle Nachbarplätze als besetzt oder unbesetzt mit der Wahrschein-
lichkeit p bzw. 1 p. Dieser Prozeß wird iteriert, wobei jeweils alle undefinierten
Randplätze in besetzte oder unbesetzte umgewandelt werden. Wenn es keine unde-
finierten Randplätze des Clusters mehr gibt, dann wurde ein Perkolationscluster er-
zeugt. Viele Wiederholungen geben eine Verteilung von Clustern, die man mit den
Methoden des finite size scaling auswerten kann. Da jedes erzeugte Teilchen das
statistische Gewicht p und jeder Leerplatz das Gewicht (1 p) erhält, und da der
gesamte Cluster mit dem Produkt aller dieser Faktoren gewichtet wird, erzeugt der
Wachstumsprozeß die Cluster mit derselben Wahrscheinlichkeit wie der vorherige
Algorithmus.
Der Wachstumsalgorithmus für einen Cluster lautet damit:
1. Markiere alle Plätze eines Quadratgitters mit der Seitenlänge L als undefiniert
und besetze das Zentrum. Der Cluster besteht am Anfang also nur aus einem
Teilchen.
2. Wähle einen undefinierten Randplatz des Clusters aus.
3. Ziehe eine gleichverteilte Zufallszahl r 2[0; 1] und besetze diesen Platz, falls
r < p. Sonst markiere diesen Platz als unbesetzt.
4. Iteriere 2 und 3, bis es keine undefinierten Randplätze des Clusters mehr gibt.
Damit der Wachstumsprozeß am Rand des Gitters in definierter Weise beendet wird,
markieren wir die Gitterrandplätze mit unbesetzt“ . Zu Punkt 2 werden wir eine
”
Liste erzeugen, aus der wir die Positionen der noch undefinierten Randplätze des
Clusters entnehmen können. Natürlich muß diese Liste während des Wachtumspro-
zesses ständig aktualisiert werden.
Da wir wieder möglichst große Gitter simulieren und auf dem Bildschirm den
wachsenden Cluster direkt beobachten wollen, haben wir den Algorithmus in der
Sprache C geschrieben. Zunächst vereinbaren wir, daß die Markierung der drei ver-
schiedenen Fälle mit den Zahlen 0, 1 und 2 erfolgen soll:
#define UNDEFINIERT 0
#define BESETZT 1
#define UNBESETZT 2
Für das Gitter, das nur diese drei Werte anzunehmen braucht, benutzen wir einen
Datentyp, der wenig Speicherplatz benötigt, nämlich char feld[L][L], und
definieren außerdem mit
struct { int x; int y ;} liste[PD];
eine Liste, die die Positionen (i,j) der undefinierten Clusterrandplätze aufneh-
men soll. Diese Liste, die anfangs nur die vier Nachbarplätze des Zentrums enthält,
5.3 Perkolation 197
wird sukzessive abgearbeitet und erhält dabei neue Einträge. Weil die bearbeite-
ten Plätze nicht mehr benötigt werden, kann diese Liste periodisch beschrieben und
durchlaufen werden. Ihre Länge PD braucht deshalb nicht gleich L2 zu sein, sondern
es reicht aus, wenn wir PD = 4 L wählen. Die Initialisierung sieht folgendermaßen
aus:
for(i=0;i<L;i++)
feld[0][i]=feld[i][0]=feld[i][L–1]=
feld[L–1][i]=UNBESETZT;
for(i=1;i<L–1;i++)
for(j=1;j<L–1;j++)
feld[i][j]=UNDEFINIERT;
feld[L/2][L/2]=BESETZT;
liste[0].x=L/2+1; liste[0].y=L/2;
liste[1].x=L/2 ; liste[1].y=L/2+1;
liste[2].x=L/2–1; liste[2].y=L/2;
liste[3].x=L/2 ; liste[3].y=L/2–1;
count=3;
putpixel(L/2, L/2, WHITE);
Dabei ist count eine reine Zählvariable, deren Wert jeweils um 1 erhöht wird,
wenn ein neuer undefinierter Randplatz des Clusters entsteht. Die Hauptschleife,
Punkt 4, lautet:
while(! done )
{
event();
for(k=0; k<=count; k++)
{
i=liste[k%PD].x; j=liste[k%PD].y;
definiere(i,j);
} /* for */
} /* while */
Das Programm durchläuft und bearbeitet also die Liste der noch undefinierten Rand-
plätze des Clusters. Die Funktion definiere(i,j) prüft zuerst, ob der Platz
(i,j) schon definiert ist. Das ist nötig, weil derselbe Randplatz eventuell mehr-
fach in der Liste auftaucht. Wenn der Platz noch undefiniert ist, wird Schritt 3 durch-
geführt und der Platz (i,j) besetzt, falls die Zufallszahl r kleiner als die Konzen-
tration p ist. Wenn dieser jetzt besetzte Platz noch undefinierte Nachbarn hat, wer-
den deren Positionen in die obige Liste aufgenommen und der Wert der Variablen
count wird entsprechend erhöht.
Das sieht im Programm folgendermaßen aus:
198 5 Monte-Carlo-Simulationen
Ergebnis
Zunächst wenden wir den ersten Algorithmus zur Erzeugung der gesamten Perko-
lationsstruktur an und besetzen ein Quadratgitter mit 500 500 Plätzen mit der
Konzentration p = 0:59275. Die besetzten Plätze (A-Atome) sind schwarz mar-
kiert, das Gitter und die unbesetzten Plätze werden nicht gezeigt. Bild 5.6 zeigt das
Ergebnis. Man sieht nur ein Rauschen, das noch nichts von den mathematischen
Gesetzen ahnen läßt, die man nach quantitativer Auswertung dieses Bildes erhalten
kann. Wir haben die Konzentration p gerade an der Perkolationsschwelle gewählt,
doch ein perkolierender Cluster und kritische Eigenschaften sind nicht zu erken-
nen. Nur ein geeignetes Computerprogramm kann aus dieser Struktur die Cluster
bestimmen und quantitativ auswerten.
Bild 5.7 zeigt einen Cluster, der durch den Wachstumsalgorithmus erzeugt wurde.
Die Konzentration p und die Gittergröße stimmen mit denen von Bild 5.6 überein.
Jetzt sieht man einen perkolierenden Cluster, der Strukturen auf allen Längenskalen
von der Gitterkonstanten bis zur Gesamtgröße des Gitters zeigt. Er ist ein fraktales
selbstähnliches Gebilde. Natürlich erzeugt das Programm nicht nur perkolierende
5.3 Perkolation 199
Cluster, sondern sehr oft stoppt der Wachstumsprozeß, bevor der Cluster den Rand
erreicht hat. Für p < pc tritt dieser Fall sehr häufig auf, während für p > pc fast nur
noch perkolierende Cluster erzeugt werden.
200 5 Monte-Carlo-Simulationen
Übung
Es sei s die Anzahl der Teilchen in einem Perkolationscluster. Die mittlere Clu-
hi
stermasse s der endlichen Cluster divergiert im unendlich großen System an der
Perkolationsschwelle mit dem Potenzgesetz
hsi jp pcj :
Berechnen Sie den Mittelwert hsi für alle numerisch erzeugten Cluster, die nicht den
Rand berühren. Tragen Sie diese Werte als Funktion der Konzentration p auf, und
versuchen Sie, damit die kritische Konzentration pc zu bestimmen. Berechnen Sie
das Maximum dieser Funktion für verschiedene Werte der Gitterlänge L. Versuchen
Sie, mit Hilfe von finite size scaling den kritischen Exponenten zu berechnen. Sie
dürfen dabei den oben angegebenen Wert von benutzen.
Literatur
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods: Appli-
cations to Physical Systems, Part II, Addison Wesley, 1988.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
D. Stauffer, A. Aharony, Perkolationstheorie: Eine Einführung, VCH Verlagsgesell-
schaft, 1995.
5.4 Polymer-Ketten
Polymere spielen eine große Rolle sowohl in der Chemie als auch in der Biologie
und der Medizin. Aber auch die Physik interessiert sich seit langem für allgemei-
ne mathematische Gesetzmäßigkeiten der Eigenschaften von Polymeren. Schon ein
einziges Molekül, das aus einer langen Kette von identischen Einheiten (Monome-
ren) aufgebaut ist, hat interessante Eigenschaften. Um solche Ketten von vielen tau-
send Monomeren mathematisch beschreiben zu können, muß man versuchen, die
wesentlichen Mechanismen und Strukturen möglichst einfach zu modellieren. Ein
bewährtes Modell dazu ist der zufällig erzeugte Weg, der in der Fachliteratur mit
random walk bezeichnet wird. Der Weg besteht aus vielen kleinen Strecken, die in
zufälligen Richtungen aneinandergereiht sind.
Im Abschnitt 3.3 haben wir schon festgestellt, daß ein Zufallsweg als Modell
für ein Polymermolekül angesehen werden kann, bei dem in einem Wärmebad al-
le Konfigurationen gleich wahrscheinlich sind. Die Masse der Kette wächst dabei
mit dem Quadrat ihrer mittleren Ausdehnung. Die mathematische Theorie dazu ist
5.4 Polymer-Ketten 201
sehr gut entwickelt. Allerdings wird bei diesem Modell ein wichtiger Mechanismus
vernachlässigt: Die Kette darf sich nicht selbst durchdringen. Zufallswege mit einer
solchen Einschränkung, die deshalb auch SAW’s (self-avoiding walks) heißen, kann
man nur näherungsweise analytisch berechnen. Sie lassen sich aber relativ leicht auf
einem Computer simulieren.
Physik
Am einfachsten kann ein Zufallsweg auf einem Gitter definiert werden. Da wir uns
nur für die globalen Eigenschaften sehr langer Polymere interessieren, insbesondere
für die fraktale Dimension, können wir annehmen, daß es keine Rolle spielt, ob wir
einen random walk mit kontinuierlichen Schrittweiten und Richtungen oder einen
solchen auf dem Gitter betrachten. Im Abschnitt 3.3 haben wir gezeigt, daß ein
Zufallsweg ohne Einschränkungen ein Knäuel eines Polymermoleküls beschreibt,
dessen Masse wie das Quadrat der mittleren Ausdehnung wächst. Sei nämlich N
die Anzahl der Schritte und RN der Abstand der beiden Enden des Weges, dann gilt
h i
Dabei ist ::: ein Mittelwert über alle Zufallswege und a ist die Länge der Ketten-
ph i
glieder. Definiert man eine mittlere Länge durch L = RN2 , so erhält man
N / LD (5.36)
mit der Dimension D = 2. Dieses Ergebnis gilt nicht nur in der Ebene, sondern in
allen Raumdimensionen.
Nun betrachten wir Zufallswege, die sich nicht selbst schneiden dürfen. Bei rea-
len Polymeren ist es das Eigenvolumen der Ketten, das diese Durchdringung ver-
bietet. Ein solcher self-avoiding walk wird offenbar im Vergleich zum random walk
im Mittel nicht so stark verknäult sein, der mittlere End-zu-End-Abstand L wird
größer werden. Das bedeutet, die Struktur des entsprechenden Polymers ist nicht
mehr so kompakt und die Dimension D sollte kleiner sein. Tatsächlich findet man
beim SAW für große N -Werte wieder ein Gesetz der Form (5.36), nun aber mit ei-
ner fraktalen Dimension D , die von der Raumdimension d abhängt. Schon 1949 hat
Flory mit einer Art Molekularfeldnäherung eine Formel für D angegeben,
D = d +3 2 : (5.37)
demjenigen des random walk überein, dort spielt also das Verbot des Selbstkreuzens
keine Rolle mehr bei den globalen Eigenschaften. In allen höheren Raumdimensio-
nen bleibt der Wert D = 2. Wie bei vielen anderen Phasenübergängen werden ab
einer oberen kritischen Dimension d = 4 die kritischen Exponenten durch die Mo-
lekularfeldtheorie beschrieben.
Tatsächlich gibt es verdünnte Lösungen von Polymeren, bei denen bei hohen
Temperaturen ein SAW-Gesetz wie in den Gleichungen (5.36) und (5.37) beob-
achtet wurde. Bei realen Molekül-Ketten gibt es auch attraktive Wechselwirkun-
gen zwischen entfernten Monomeren eines einzelnen Polymermoleküls, so daß die
Kette bei tiefen Temperaturen zu einem kompakten Knäuel mit D = d kollabie-
ren kann. Noch komplexer wird es natürlich, wenn viele Molekülketten miteinander
wechselwirken. Gerade in den letzten Jahren haben extensive numerische Simulatio-
nen wesentlich zum Verständnis der Polymerdynamik in einer solchen Spaghetti-
”
Suppe“ beitragen können. Hier wollen wir uns dagegen mit der Simulation des re-
lativ einfachen SAW befassen.
Algorithmus
Einen Zufallsweg auf einem Gitter kann man mit dem Computer leicht erzeugen.
Bei jedem Schritt wählt man mit einer Zufallszahl einen der Nachbarplätze aus und
macht dorthin einen weiteren Schritt. Auch beim Zufallsweg, der sich nicht über-
kreuzen darf, scheint der Algorithmus offensichtlich zu sein: Man wählt zufällig
einen der bisher nicht besuchten Nachbarplätze aus und macht einen Schritt dort-
hin. Doch überraschenderweise gibt dieser Algorithmus falsche Resultate: Im Mittel
wird das Polymer kompakter als das korrekte statistische Mittel. Ketten, die sich an
mehreren Stellen berühren, werden öfter erzeugt als gestreckte Ketten mit wenigen
Berührungspunkten.
Der Grund dafür soll hier kurz erläutert werden. Sei Zi die Zahl der noch nicht
besuchten Nachbarplätze am Ende einer Kette. Dann ist 1=Zi die Wahrscheinlich-
keit, daß ein Monomer an einem dieser Plätze hinzugefügt wird. Die gesamte Wahr-
scheinlichkeit W , eine spezielle Kettenkonfiguration mit N Gliedern zu erzeugen,
ist damit
Y
N
1
WN = Z : (5.38)
i=1 i
Man sieht also, daß Ketten mit vielen Berührungspunkten (Zi klein) eine hohe
Wahrscheinlichkeit erhalten. Dies darf nicht sein, denn im korrekten statistischen
Mittel muß jede erlaubte Konfiguration mit derselben Wahrscheinlichkeit auftreten.
Gleichung (5.38) zeigt aber auch sofort, wie man die unerwünschte Bevorzugung
kompakter Ketten korrigieren kann. Man muß jeder Bindung das statistische Ge-
5.4 Polymer-Ketten 203
wicht Zi geben und die Eigenschaften des Polymers damit wichten. Dadurch erhält
jede Kette dasselbe statistische Gewicht
Y
N
WN Zi = 1 ; (5.39)
i=1
und der korrekte Wert des mittleren End-zu-End-Abstandes L ist bei dieser Simula-
P Q
tion also
N
RN;l
2 Zi;l
L = R =
2 h Ni
2 l i =1 ;
P QN Z (5.40)
i;l
l i=1
wobei l die erzeugten Konfigurationen durchnumeriert.
Es gibt aber auch eine effektive Methode, um direkt Polymerkonfigurationen mit
konstanter Wahrscheinlichkeit zu erzeugen. Während der vorherige Algorithmus
Ketten wachsen läßt, arbeitet diese Methode, die mit Reptation bezeichnet wird,
mit konstanter Kettenlänge N . Dabei schlängelt“ sich das Polymer über das Gitter
”
und ändert auf diese Weise ständig seine Form und Richtung.
Bevor wir diesen Reptationsalgorithmus und seine Eigenschaften beschreiben,
müssen wir kurz erläutern, was man unter einer Konfiguration des Polymers versteht
und wann zwei solche Konfigurationen auf dem ebenen Quadratgitter als verschie-
den gelten. Es ist beispielsweise sinnvoll, alle diejenigen Konfigurationen als gleich
anzusehen, die durch die möglichen Translationen einer gegebenen Form der Poly-
merkette entstehen. Zum Vergleich eventuell verschiedener Konfigurationen können
wir diese dann so verschieben, daß alle an demselben festen Gitterpunkt beginnen.
Dabei ist implizit schon die Festlegung getroffen worden, daß die Kette einen An-
fang hat und wir also von der ersten Monomereneinheit, der zweiten, der dritten
usw. reden können.
Eine weitere elementare Symmetrie des Quadratgitters sollten wir noch zur Ver-
einfachung nutzen, nämlich die 90 -Drehungen. Die Richtung des ersten Monomers
könnte nach Norden, nach Westen, nach Süden oder nach Osten zeigen.
Wenn wir von der Richtung des ersten Kettengliedes absehen, so ist zur ein-
deutigen Charakterisierung einer Konfiguration nur erforderlich zu wissen, ob nach
dem ersten Schritt der nächste nach links, geradeaus oder nach rechts erfolgt, und
dementsprechend für die folgenden Schritte. Wir können also eine Konfiguration ei-
nes Polymers, das aus N Gliedern besteht, durch eine Folge von N 1 Richtungs-
angaben beschreiben, wobei deren mögliche Werte links, geradeaus und rechts
sind. Wichtig in diesem Zusammenhang ist, daß diese Folge in einer bestimmten
Richtung durchlaufen wird. Wie oben schon gesagt, benötigt die Polymerkette ei-
ne Orientierung. Dazu markieren wir die Enden der Kette mit Kopf bzw. Schwanz
204 5 Monte-Carlo-Simulationen
und verabreden z. B., daß die Orientierung vom Schwanzende zum Kopfende hin
erfolgen soll.
Aber nicht jede Folge von N 1 Richtungsangaben stellt einen SAW dar, sondern
es sind nur diejenigen Folgen erlaubt, die keine Selbstüberschneidungen aufweisen,
eine Nebenbedingung, die sich nicht lokal formulieren läßt. Das ist auch der Grund
dafür, daß es zur Statistik der SAWs bisher nur so wenige analytische Resultate gibt
und man auf Computersimulationen angewiesen ist.
Der Algorithmus für die Reptation einer Polymerkette mit N Gliedern lautet fol-
gendermaßen:
1. Starte mit einer Konfiguration auf dem Gitter, wobei die Enden der Kette mit
Kopf bzw. Schwanz markiert sind.
3. Falls dieser Platz unbesetzt ist, füge dort ein neues Kopfmonomer hinzu. Falls
dieser Platz besetzt ist, restauriere die alte Konfiguration, vertausche die Markie-
rungen Kopf und Schwanz und berücksichtige die ansonsten unveränderte Konfi-
guration als neue Konfiguration bei der Mittelwertbildung.
4. Iteriere 2 und 3.
Man kann zeigen, daß diese Methode alle Konfigurationen, die überhaupt aus der
Startkonfiguration entstehen können, mit der gleichen Wahrscheinlichkeit erzeugt.
Dazu numerieren wir die verschiedenen erreichbaren Zustände mit l = 1; 2; 3; : : : ;
N durch und bezeichnen mit pl (t) die Besetzungswahrscheinlichkeiten, die sich
nach entsprechend langer Zeit einstellen. Wenn wir zudem noch die Übergangs-
wahrscheinlichkeiten W (l !
k) kennen, mit der pro Zeitschritt Konfiguration l in
Konfiguration k transformiert wird, so können wir für die Zeitentwicklung der pl (t)
folgende Mastergleichung aufschreiben:
X
N
p_l = (W (k ! l) pk W (l ! k) pl ) : (5.41)
k=1
P
Wegen k W (l ! k) = 1 läßt sich die Summation im zweiten Term ausführen.
Weil wir an der stationären Verteilung interessiert sind, d. h. p_l = 0, suchen wir also
die Lösung des Gleichungssystems
X
N
W (k ! l) pk = pl : (5.42)
k=1
5.4 Polymer-Ketten 205
gilt. Man spricht dann von detailliertem Gleichgewicht (detailed balance), und aus
Gleichung (5.41) ersieht man sofort, daß dann pk = wk eine Lösung der stationären
Mastergleichung ist.
Detailed balance gilt aber für unseren Fall nicht, wie man sich an folgendem
Beispiel klarmacht: Die völlig gestreckte Konfiguration hat mit Wahrscheinlichkeit
1=3 nach dem nächsten Zeitschritt am Kopfende einen Rechtsknick, während die
Wahrscheinlichkeit, daß dieser neue Zustand wieder in den gestreckten übergeht,
null ist.
Statt des detaillierten Gleichgewichts gilt aber für den Reptationsalgorithmus die
folgende Beziehung:
! !
W (k l) = W (linv kinv ) ; (5.44)
wobei wir mit linv den Zustand bezeichnen, den man aus l durch Vertauschung
von Kopf und Schwanz erhält. Für l = kinv ist die Gleichung (5.44) trivialerweise
erfüllt. Das betrifft alle die Fälle, in denen der Algorithmus eine Kopf-Schwanz-
Vertauschung verlangt. Für die anderen Übergänge gilt folgendes: Wenn es möglich
ist, am Schwanzende ein Monomer zu entfernen und dafür am Kopfende eines hin-
zuzufügen, so ist auch der umgekehrte Prozeß möglich, nämlich dieses neue Kopf-
monomer zu entfernen und es ans Schwanzende zurückzulegen. Daraus schließen
wir, daß beide Seiten von Gleichung (5.44) entweder gleich null sind oder ungleich
null sind. Wenn sie aber ungleich null sind, so sind sie beide gleich 1=3, denn
das Hinzufügen eines neuen Kopfmonomers einer bestimmten Richtung geschieht,
wenn es überhaupt möglich ist, immer mit der Wahrscheinlichkeit 1=3 . Verwenden
wir (5.44) in Gleichung (5.42), so erhalten wir ähnlich wie oben, daß pl = const. =
P
N !
1= eine Lösung ist, denn natürlich ist auch k W (linv kinv ) = 1 . D. h., die
erreichbaren Konfigurationen werden mit gleicher Wahrscheinlichkeit erzeugt.
Allerdings gibt es ganze Klassen von Konfigurationen, die mit dem Reptations-
algorithmus nicht erreichbar sind, wenn man als Startzustand den völlig gestreckten
oder einen äquivalenten benutzt. Das Bild 5.8 zeigt Beispiele aus zwei verschiede-
nen solcher Klassen. Wir können aber davon ausgehen, daß die Anzahl dieser Konfi-
gurationen klein ist im Vergleich zu den Zuständen in der Hauptklasse. Andererseits
hängt es natürlich von der Fragestellung ab, ob die anderen Konfigurationen relevant
sind oder nicht. Wenn wir mit dem Reptationsalgorithmus den mittleren End-zu-
End-Abstand berechnen, so werden wir einen geringfügig zu großen Wert erwarten,
weil wir die stärker eingerollten Zustände der anderen Klassen nicht berücksichtigt
haben.
206 5 Monte-Carlo-Simulationen
5.8 Polymerkonfigurationen, die nicht von der gestreckten Startkonfiguration aus erreichbar
sind. Der offene Kreis bezeichnet den Kopf.
Wir wollen uns das schlängelnde Polymer auf dem Computerbildschirm erzeu-
gen. Dazu programmieren wir den Reptationsalgorithmus auf dem Quadratgitter in
der Sprache C. Zunächst deklarieren wir den Variablentyp vector, der Strukturen
mit den Ortskoordinaten (x; y ) definiert.
typedef struct f
float x,y; vector; g
vector richtung[3], polymer[NMAX];
polymer[NMAX] ist ein Feld von Vektoren, das alle Ortskoordinaten des Poly-
mers enthält; polymer[5].y gibt z. B. die y -Koordinate des 5-ten Monomers an.
Am Anfang wird als Konfiguration für das Polymer die gestreckte Kette festgelegt
und mit der Funktion kreis gezeichnet.
for(i=0;i<N;i++)
{
polymer[i].x=i–N/2;
polymer[i].y=0;
kreis(polymer[i]);
}
while(!done)
{
event();
w=wahl();
if(kreuzung(w))
{ kopf=schwanz; incr=–incr;
schwanz=(kopf+incr+N)%N;
}
else akzeptiere(w);
}
Anstatt das Polymer auf seinem Speicherplatz zu verschieben, verwenden wir Indi-
zes für den Kopf und den Schwanz. Die Variable incr = 1 gibt die Richtung
des Polymers im Feld polymer[N] an. Um negative Indizes zu vermeiden, wird
bei der Modulo-Operation % noch die Zahl N addiert.
Die Funktion event() fragt wie in jedem unserer C-Programme Tasten- bzw.
Maus-Aktionen des Beobachters ab und gibt eventuell done=1 zurück, wodurch
die while-Schleife beendet wird.
Die Funktion wahl() gibt einen (x; y )-Vektor zurück, der vom Kopf auf einen
der drei Nachbarplätze zeigt. Zunächst werden die drei möglichen Richtungen er-
r
zeugt, indem die Differenz ( (Kopf) r (Hals)) gebildet wird (richtung[0])
und dann die beiden Vektoren senkrecht dazu berechnet werden. Wenn z. B. der
Vektor richtung[0]= (0; 1) ist, so enthalten die Variablen richtung[1]
und richtung[2] die Vektoren (1; 0) bzw. ( 1; 0). Mit einer gleichverteilten
Zufallszahl aus dem Intervall [0; 3) wird dann durch Umwandlung in eine ganze
Zahl r eine der drei Richtungen zufällig ausgewählt und zurückgegeben.
vector wahl()
{
int km,r;
km=(kopf–incr+N)%N;
richtung[0].x=polymer[kopf].x–polymer[km].x;
richtung[0].y=polymer[kopf].y–polymer[km].y;
richtung[1].x=richtung[0].y;
richtung[1].y=richtung[0].x;
richtung[2].x=–richtung[1].x;
richtung[2].y=–richtung[1].y;
r=random(3);
return richtung[r];
}
Die Funktion kreuzung(w) gibt den Wert 1 bzw. 0 zurück, falls der gewähl-
te Nachbarplatz auf den alten Kettengliedern liegt bzw. nicht liegt. Dies läßt sich
208 5 Monte-Carlo-Simulationen
int kreuzung(vector w)
{
int i;
for(i=0;i<N;i++)
if(w.x+polymer[kopf].x==polymer[i].x &&
w.y+polymer[kopf].y==polymer[i].y &&
i != schwanz) return 1;
return 0;
}
Ohne Kreuzung wird der gewählte Platz als neuer Kopf akzeptiert und die Indizes
werden um den Wert incr verschoben. Auf dem Bildschirm wird der Kreis am Ort
des Schwanzes mit Hintergrundfarbe übermalt und der neue Kopf wird als Kreis hin-
zugezeichnet. So entsteht eine Schlangenbewegung auf dem Gitter. All dies macht
folgende Funktion:
Ergebnisse
Der Aufruf unseres C-Programms erzeugt das Polymer auf dem Bildschirm (Bild
p
5.9). Gleichzeitig wird der mittlere End-zu-End-Abstand ausgedruckt, und zwar re-
lativ zum Ergebnis L = N des random walk ohne Einschränkungen. Man er-
kennt, daß das Polymer im Mittel gestreckter ist als der random walk und daß diese
relative mittlere Länge mit N anwächst, in Übereinstimmung mit der kleineren frak-
talen Dimension D = 4=3. Tatsächlich ergibt schon der Fit aus den beiden Werten
für N = 50 und N = 100 recht genau, daß das Verhältnis der Längen, wie es die
Theorie vorhersagt, proportional zu N 0:25 anwächst.
Übung
Programmieren Sie den anfangs erwähnten Algorithmus, indem Sie, wie in den
Gleichungen (5.39), (5.40) angegeben, die Anzahl Zi der bei jedem Schritt verfüg-
baren freien Plätze in korrekter Weise berücksichtigen. Vergleichen Sie diese Im-
plementierung mit dem Reptationsalgorithmus in bezug auf die Rechengeschwin-
digkeit und den Wert für den mittleren End-zu-End-Abstand.
Literatur
K. Binder, D. W. Heermann, Monte Carlo Simulation in Statistical Physics, Springer
Verlag, 1992.
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods:
Applications to Physical Systems, Parts I and II, Addison Wesley, 1988.
210 5 Monte-Carlo-Simulationen
5.5 Ising-Ferromagnet
Wenn sehr viele Teilchen zusammenwirken, können qualitativ neue Eigenschaften
entstehen. Zum Beispiel werden Gase bei tiefen Temperaturen oder hohem Druck
plötzlich flüssig, Flüssigkeiten werden zum Festkörper, magnetische Atome ordnen
sich zu einem magnetischen Material und Metalle verlieren plötzlich ihren elektri-
schen Widerstand. Es gibt sehr viele solcher Systeme, die im Wärmegleichgewicht
bei einer wohldefinierten Temperatur ihre makroskopischen Eigenschaften ändern.
In der mathematischen Modellierung treten diese Phasenübergänge nur im unend-
lich großen System auf.
Kann man mit dem Computer ein Wärmegleichgewicht simulieren und ein Sy-
stem langsam abkühlen? Kann die Simulation endlich großer Systeme Phasenum-
wandlungen beschreiben? Mit solchen Fragen wollen wir uns in diesem Abschnitt
befassen, exemplarisch wieder an einem einfachen Modell, dem Ising-Ferromagne-
ten auf dem Quadratgitter. Dieses Modell hat am Phasenübergang universelle kriti-
sche Eigenschaften, die auch bei vielen anderen Modellen und bei realen Materiali-
en gemessen werden. Wir lassen die mikroskopischen Magnete auf dem Bildschirm
flackern und heizen dabei mit einem Tastendruck den Magneten auf oder kühlen ihn
ab.
Physik
Schon seit Anfang dieses Jahrhunderts ist bekannt, wie man das Wärmegleichge-
wicht von wechselwirkenden Teilchen mathematisch beschreiben kann. In der kano-
nischen Formulierung führt die statistische Mechanik die thermischen Eigenschaf-
ten auf die Berechnung einer Zustandssumme Z zurück,
X H (S )=kB T :
Z= e (5.45)
S
Z ist die Summe über alle möglichen Vielteilchenzustände S , und jeder Zustand
wird entsprechend seiner Energie H (S ) gewichtet. T ist die Temperatur und kB die
Boltzmann-Konstante.
Wir wollen das Ising-Modell beschreiben, ein einfaches Modell für ein magne-
tisches System. Dazu betrachten wir ein Quadratgitter, auf dessen Gitterplätzen
Spins sitzen, die nur zwei Einstellmöglichkeiten haben. Außerdem gibt es zwi-
schen benachbarten Spins eine Wechselwirkung. Mathematisch läßt sich das fol-
gendermaßen formulieren: An jedem Gitterplatz i = 1; :::; N gibt es eine Variable
2f g
Si +1; 1 , so daß ein Vielteilchenzustand durch S = (S1; S2 ; :::; SN ) ge-
kennzeichnet ist. In die Berechnung der Gesamtenergie H (S ) geht eine Summation
5.5 Ising-Ferromagnet 211
sowohl über alle Nachbarpaare (i; j )nn als auch über alle Plätze i ein:
X X
H= J Si Sj h Si : (5.46)
(i;j )nn i
Dies bedeutet, parallele Nachbar-Spins haben die Paar-Wechselwirkungs-Energie
J < 0, während der Term proportional zu h ein äußeres Magnetfeld beschreibt,
in dem jeder zum Feld parallele Spin die Energie h < 0 hat.
Das Problem ist damit wohldefiniert: Wir brauchen nur“ die Summe (5.45) aus-
”
zurechnen. Wir wollen dies mit einem Computer versuchen. Nehmen wir an, wir
hätten 100 Stunden Rechenzeit auf einer Maschine zur Verfügung, die für einen
Rechenschritt etwa 10 6 s benötigt. Insgesamt können wir also 3:6 1011 Rechen-
schritte nutzen, wobei wir von einer schnellen Maschine ausgegangen sind, wenn
man beachtet, daß ein Rechenschritt, also z. B. die Auswertung der exp-Funktion,
viele Zeittakte benötigt.
Wieviele Rechnungen brauchen wir bei N Spins für die Auswertung der Glei-
chung (5.45) ? Da jeder Spin Si zwei Einstellmöglichkeiten hat, gibt es insgesamt
2N verschiedene Spinkonfigurationen. Bei jedem dieser Zustände muß die Energie
H aus Gleichung (5.46) berechnet werden. Dies kostet 2N Rechenschritte. Daraus
folgt
2N 2N = 3:6 1011 (5.47)
mit der Lösung N ' 32. Das Ergebnis ist entmutigend. Selbst mit heutigen Super-
computern können wir nur einen winzigen Magneten der Größe 3 3 3 berechnen,
dabei wollen wir ein reales Material mit 107 107 107 Spins beschreiben!
Mit Transfermatrix-Methoden gelingt es, die Zustandssumme Z für Stäbe der
1
Größe 4 4 exakt zu berechnen. Allerdings ist dies immer noch sehr wenig,
wenn wir Phasenübergänge beobachten wollen.
Man könnte nun auf die Idee kommen, nur einige wenige zufällig erzeugte Zu-
stände S = (S1 ; S2 ; S3 ; : : : ; SN ) in der Zustandssumme Gleichung (5.45) zu be-
rücksichtigen. Das funktioniert aber nicht. Denn zufällig erzeugte Zustände ha-
ben nach dem zentralen Grenzwertsatz für große N -Werte die Energie H
p ' 0+
O ( N ). Die physikalisch wichtigen Zustände haben aber eine Energie der Größen-
O
ordnung (N ), sie werden also bei der obigen Methode überhaupt nicht erzeugt.
Schon zu den Zeiten der ersten Computer haben sich Physiker überlegt, wie man
die physikalisch relevanten Zustände erzeugen kann. Dazu startet man mit einer
Konfiguration S (t = 0) und erzeugt daraus eine Folge S (1); S (2); :::; S (t), die
in das thermische Gleichgewicht relaxiert. Dazu wird eine Übergangswahrschein-
lichkeit W (S ! S 0) definiert, die – man vergleiche mit dem vorigen Abschnitt –
folgendem detaillierten Gleichgewicht genügt
P (S ) = Z1 e H (S )=k T B
(5.49)
Bevor wir zur Programmierung des durch Gleichung (5.48) beschriebenen sto-
chastischen Prozesses kommen, wollen wir kurz die Eigenschaften des Ising-Fer-
romagneten und deren Abhängigkeit von der Systemgröße N diskutieren. Das un-
endlich große System (N !1 ) hat ohne äußeres Magnetfeld (h = 0) einen
Phasenübergang in zwei und mehr Raumdimensionen. Unterhalb einer kritischen
Temperatur Tc ordnen sich im thermischen Mittel die Spins parallel zueinander und
bilden eine makroskopische Magnetisierung M ,
X
M (T ) = N1 hSii : (5.53)
i
M kann positiv oder negativ sein; das System wählt durch zufällige Fluktuationen
beim Abkühlen eine Richtung aus. Da für h = 0 die Energie symmetrisch in M
ist, H (S ) = H ( S ), nennt man diesen Vorgang spontane Symmetriebrechung.
Ein äußeres Magnetfeld h 6= 0 hebt diese Symmetrie auf und zerstört dadurch den
Phasenübergang.
Der Phasenübergang ist kritisch, d. h. die Magnetisierung M (T ) geht mit wach-
sender Temperatur stetig gegen den Wert M (T ) = 0 für T Tc . Wie bei der
Perkolation aus Abschnitt 5.3 gibt es eine divergierende Korrelationslänge (T ),
die durch den Zerfall der Spinkorrelationen für große Abstände r definiert ist:
hSi Sj i exp( r=) mit r = jri rj j : (5.54)
In der Nähe des Phasenübergangs T ' Tc ; h ' 0, gibt es wieder Skalengesetze und
Potenzsingularitäten mit universellen kritischen Exponenten. Bei Tc gelten folgende
Beziehungen für die Magnetisierung M , die Korrelationslänge , die magnetische
Suszeptibilität und die spezifische Wärme C :
M (T ) (Tc T ) (T % Tc )
(T ) jTc T j
(T ) jTc T j
C (T ) jTc T j : (5.55)
Die Begründung für diese universellen Eigenschaften gibt die mathematisch an-
spruchsvolle Theorie der Renormierungsgruppe aus den siebziger Jahren (Nobel-
preis für K. G. Wilson im Jahre 1982). Das zweidimensionale Modell (für h = 0)
wurde 1944 von Onsager gelöst. Die universellen Größen sind daher für d = 2
exakt bekannt, und zwar gibt die Onsager-Lösung
Tc = kJ p2 ' 2:269::: kJ ;
B ln 2 + 1 B
1 7
= 8 ; = 1; = 4 ; = 0 : (5.56)
214 5 Monte-Carlo-Simulationen
(T; L) = jT Tc j f jT TcjL1= :
(5.57)
Aus der Divergenz der Suszeptibilität als Funktion der Systemgröße erhält man also
den Wert = . Entsprechend findet man aus der Divergenz der spezifischen Wärme
C (Tc; L) den Exponenten = . Aus diesen beiden Werten kann man mit Hilfe der
Skalengesetze alle anderen Exponenten berechnen. Es gilt (d = Raumdimension 2; 3
oder 4)
= d +2 = ; = d +2 = ; = dd + =
= : (5.59)
Algorithmus
Der stochastische Prozeß benötigt eine Übergangswahrscheinlichkeit W (S S 0 ),
!
die dem detaillierten Gleichgewicht (5.48) genügt. Wir wollen hier eine einfache
Methode verwenden, und zwar den Metropolis-Algorithmus. W soll nur Übergänge
erlauben, bei denen höchstens ein Spin geändert wird. Sei also
die Fluktuation der Energie und der Magnetisierung aus, um mit einer Simulation
Eigenschaften eines ganzen Temperaturintervalls zu erhalten. Man kann auch Si-
mulationen bei konstanter Energie (mikrokanonisch) durchführen, oder mit einem
Trick hohe Energiebarrieren überwinden. Der Metropolis-Algorithmus dagegen ist
einfach und universell, ein Grund, weshalb wir ihn hier programmieren wollen.
Wir sind daran interessiert, die Systemgröße N , die Relaxationszeit t0 und die
Meßzeit t1 so groß wie nur möglich zu machen. Wir brauchen also eine schnel-
le Computersprache. In der aktuellen Forschung und für die Computersimulation
großer Systeme wird meistens die Sprache FORTRAN benutzt, da die FORTRAN-
Compiler der Superrechner den höchsten Optimierungsgrad haben. Aber auch C-
Programme laufen auf Höchstleistungsrechnern effektiv. Wir wollen im folgenden
die Monte-Carlo-Simulation des Ising-Ferromagneten in C programmieren.
Die Spins Si werden auf einem quadratischen Feld s[x][y], x = 1; : : : ; L,
y = 1; : : : ; L, gespeichert und mit den Werten Si = 1 initialisiert. Man könnte
jeden beliebigen Startzustand nehmen, da das System immer ins thermische Gleich-
gewicht relaxiert. Bei tiefen Temperaturen können andere Startzustände aber lange
Relaxationszeiten haben. Die Diffusion von Domänenwänden – im Ergebnisteil ist
ein Bild davon zu sehen – macht dies deutlich.
Randeffekte können einen starken Einfluß auf die Eigenschaften des Magne-
ten haben, insbesondere bei kleinen Systemen. Daher verwenden wir hier periodi-
sche Randbedingungen, d. h. jeder Randspin wechselwirkt mit dem Spin auf der
gegenüberliegenden Seite. Damit hat das System keinen Rand, sondern es ist to-
pologisch zu einem Torus (Autoreifen) aufgewickelt. Um in der innersten Schlei-
fe möglichst viel Rechenzeit einzusparen, verzichten wir darauf, mit if-Abfragen
oder Modulo-Rechnungen die Randindizes festzustellen. Statt dessen kopieren wir
die Werte der Randspins nach jedem Durchlauf in die vier Zusatzfelder s[0][i],
s[L+1][i], s[i][0] und s[i][L+1] mit i = 1; : : : ; L.
Der Algorithmus vergleicht Zufallszahlen mit exp( 2Si hi =kB T ), dem Boltz-
mann-Gewicht bei der Temperatur T . Mit einem kleinen Trick können wir die
ständige Berechnung der e-Funktion vermeiden. Wir führen ihn für h = 0 vor, er
6
funktioniert aber auch für h = 0. Auf dem Quadratgitter kann nämlich die Summe
P
Si j2N (i) Sj über die Nachbarn von Si nur die Werte 4; 2; 0; 2 und 4 anneh-
men. Bei den negativen Werten wird Si immer gedreht. Deshalb gibt es nur zwei
verschiedene Boltzmann-Gewichte exp( 4=T ) und exp( 8=T ), wobei die Tem-
peratur T in Einheiten der Wechselwirkungsenergie J=kB gemessen wird. Beide
Zahlen werden vor den Monte-Carlo-Schritten mit folgender Funktion berechnet:
void setT(double t)
{
temp=t;
bf[0]= 0.5*RAND_MAX;
5.5 Ising-Ferromagnet 217
bf[1]= exp(–4./temp)*RAND_MAX;
bf[2]= exp(–8./temp)*RAND_MAX;
}
Die Variable temp und das Feld bf[...] müssen natürlich vor dem Hauptprogramm
main() deklariert sein, sonst kennt die Funktion setT() diese Größen nicht.
Falls das innere Feld den Wert Null hat, verwenden wir die Übergangswahrschein-
lichkeit W (S ! S 0) = W (S 0 S ) = 1=2 (anstatt 1). Dies vermeidet Oszillatio-
!
nen, die bei der sequentiellen Wahl der besuchten Plätze auftreten können.
Mit den so definierten Boltzmann-Gewichten bf[...] lautet die innerste Schleife
for(x=1;x<L+1;x++) for(y=1;y<L+1;y++)
{
e=s[x][y]*(s[x–1][y]+s[x+1][y]+s[x][y–1]+s[x][y+1]);
if( e<0 || rand()<bf[e/2] )
{
s[x][y]=–s[x][y];
v=2*(x*80+2*(y–1)+2);
ch=(s[x][y]+1)*15;
poke(VSEG,v,0xf00|ch);
}
}
for(x=1;x<L+1;x++)
{
s[0][x] = s[L][x];
s[L+1][x] = s[1][x];
s[x][0] = s[x][L];
s[x][L+1] = s[x][1];
}
In der letzten for-Schleife werden die zusätzlichen Hilfsfelder mit den aktuel-
len Randspins besetzt, um die periodischen Randbedingungen zu erfüllen. Mit dem
poke-Befehl sprechen wir auf dem PC den Bildspeicher im Textmodus direkt an.
Dies ist sehr schnell, während ein Graphik- oder ein putch()-Befehl das Pro-
gramm etwa um einen Faktor 2 langsamer macht. Allerdings funktioniert dieser
Befehl nicht auf allen Maschinen.
Die Monte-Carlo-Simulation läßt sich mit wenig Aufwand programmieren. Mit
kleinen Programmen und schnellen Computern erhält man leicht Resultate. Aber es
ist nicht einfach, die Daten auszuwerten. Immerhin möchte man aus stark fluktu-
ierenden Ergebnissen für relativ kleine Systeme und – verglichen mit dem Experi-
ment – relativ kurzen Rechenzeiten allgemeine Gesetze für die Eigenschaften des
218 5 Monte-Carlo-Simulationen
b
unendlichen Gitters im thermischen Gleichgewicht (= unendliche Relaxationszei-
ten) ableiten. Auch mit der oben erläuterten Theorie des finite size scaling, die ja nur
asymptotisch für N !1 gilt, bleibt dies eine schwierige und mühsame Aufgabe.
Hinzu kommt, daß versteckte Korrelationen in scheinbar guten Zufallszahlengene-
ratoren schon oft zu einem systematischen Fehler geführt haben.
Ergebnisse
Das PC-Programm ISING simuliert einen 20 20-Ising-Ferromagneten auf dem
Quadratgitter und zeigt die Stellung der Spins auf dem Bildschirm an. Mit einem
Tastendruck läßt sich während des Laufes das System aufheizen bzw. abkühlen. Die
Anfangstemperatur T = 2:269J=kB ist nach Onsager die kritische Temperatur Tc
des unendlichen Magneten. Zusätzlich zur Temperatur T und zur Zahl der Monte-
Carlo-Schritte pro Spin (MCS) wird die Zeit ausgedruckt, die der Rechner für einen
Monte-Carlo-Schritt benötigt, auf unserem PC etwa 4 10 5 s. Also selbst auf ei-
nem PC ist ein Schritt so schnell, daß die Spins im simulierten Wärmebad flackern.
Bild 5.10 zeigt ein System der Größe 100 100, dessen Verhalten mit dem ent-
sprechenden Programm auf der Workstation simuliert wurde. Bei Tc sieht das Bild
selbstähnlich aus, d. h. es treten Cluster von parallelen Spins auf allen Größenord-
nungen auf. Die Korrelationslänge ist am kritischen Punkt so groß wie die Gitter-
h i
ausdehnung L, und die Korrelationen Si Sj zerfallen für a
r= i j Ljr r j
wie eine Potenz von r (a = Gitterkonstante). Bei T = 0:8 Tc ist das System magne-
P 6
tisiert, ( Si )=N = 0. Durch spontane Fluktuationen hat sich der Magnet eine der
beiden möglichen Richtungen gewählt und die Spins Si sind bis auf wenige Aus-
nahmen parallel dazu ausgerichtet. Wir beobachten also eine von null verschiedene
5.5 Ising-Ferromagnet 219
P
spontane Magnetisierung, und selbst wenn wir Si über ein Zeitintervall t1 mitteln
hP i
würden, würde ( Si )=N t0 ;t1 nicht verschwinden. Widerspricht dies der exakten
Aussage, daß ein endliches System keinen Phasenübergang haben kann (M (T ) = 0
für T > 0)?
Hierzu müssen wir uns die Zeitskala klarmachen, in der das System die Magne-
Bei T = 1:5 Tc scheinen die Spins fast zufällig ausgewürfelt zu sein, die Korre-
lationslänge hat fast den Wert a angenommen. Mit einem Tastendruck kann man
nun den Magneten sprungartig auf eine Temperatur deutlich unterhalb Tc abkühlen.
Nach einigen Versuchen sollte es gelingen, Bereiche mit positiver und negativer
Magnetisierung gleichzeitig zu erzeugen (Bild 5.11). Dann entstehen diffundieren-
de Domänenwände, die sich so lange gegenseitig vernichten oder zusammenziehen,
bis das thermische Gleichgewicht mit nur einer einzigen Domäne übrig bleibt. Die
Magnetisierung zeigt als Funktion der Zeit am kritischen Punkt starke Fluktuationen
(Programm ising g). Nach der statistischen Mechanik bestimmen diese Schwan-
kungen von M gerade die magnetische Suszeptibilität , die bei Tc nach Gleichung
220 5 Monte-Carlo-Simulationen
(5.58) mit L divergiert. Das gleiche gilt für die Fluktuationen der Energie, die die
spezifische Wärme C bestimmen.
Für T > Tc und für lange Zeiten t zerfallen die zeitlichen Korrelationen (ebenso
wie die räumlichen) exponentiell schnell
hSi(t0 ) Si (t0 + t)i e t= : (5.64)
Die Relaxationszeit (T ) divergiert bei Tc wie
jT Tc j z= ; (5.65)
wobei z ein neuer universeller kritischer Exponent ist, dessen Wert auch beim zwei-
'
dimensionalen Modell nur numerisch bekannt ist (z 2:1). Die Fluktuationen der
Magnetisierung werden bei Tc also nicht nur größer, sondern auch langsamer. Des-
halb nennt man diesen Effekt critical slowing down.
Übung
Es soll der Phasenübergang eines Gittergases mit der Monte-Carlo-Methode simu-
liert werden. Dazu betrachten wir ein Modell, bei dem auf einem N N -Gitter die
Teilchen nur auf den Gitterpunkten sitzen können. Dies wird durch die Variable ni
beschrieben, die die Werte ni = 1(0) annimmt, falls der Gitterplatz i besetzt (un-
besetzt) ist. Die Anzahl der Teilchen wird durch ein chemisches Potential kontrol-
liert. Die Dynamik besteht darin, daß Teilchen verschwinden und wieder auftauchen
können. Jeder Platz i wird mit der Wahrscheinlichkeit proportional zu z ni besetzt,
wobei z die Fugazität genannt wird. Benachbarte Teilchen sollen sich so stark ab-
stoßen, daß keine Nachbarplätze besetzt werden können. Das Modell enthält sonst
keine Wechselwirkungen und deshalb auch keine Temperatur, der einzige Kontroll-
parameter ist die Fugazität z , die die Teilchendichte des Gitters einstellt.
Wenn das Gitter maximal bedeckt ist, befinden sich N 2 =2 Teilchen auf einem
der beiden Untergitter, wie beim Schachbrett entweder auf den weißen oder auf
den schwarzen Plätzen. Aber auch bei unvollständiger Bedeckung bevorzugen die
Teilchen eines der beiden Untergitter; im thermischen Mittel ist die Differenz der
Anzahl der Teilchen zwischen den weißen und schwarzen Plätzen ungleich Null.
Diese Differenz ist der Ordungsparameter des Systems, er entspricht der Magne-
tisierung des Ising-Modells. Erst wenn die Bedeckung einen gewissen Wert unter-
schreitet, werden im thermischen Mittel beide Untergitter gleich stark belegt, und
der Ordnungsparameter hat den Wert Null. Wie beim Ising-Modell gibt es diesen
Phasenübergang streng genommen nur im unendlich großen System; in der Simu-
lation muß man finite size scaling anwenden, um die Eigenschaften des Übergangs
zu berechnen.
Programmieren Sie folgenden Monte-Carlo-Schritt für das Gittergas:
5.6 Kürzeste Rundreise 221
2. Ist der Gitterplatz leer, besetze ihn, wenn dies erlaubt ist, d. h., wenn alle nächsten
Nachbarplätze leer sind, ansonsten akzeptiere die alte Konfiguration.
2
3. Ist der Gitterplatz besetzt, ziehe eine Zufallszahl r [0; 1] und vergleiche sie
mit z 1 . Ist sie kleiner, entferne das Teilchen. Ist sie größer, akzeptiere die alte
Konfiguration.
Berechnen Sie den Mittelwert des Ordnungsparameters und dessen Varianz, die Sus-
zeptibilität, als Funktion der Fugazität z . Bestimmen Sie deren kritischen Wert zc
und die zugehörige Bedeckung c des Gitters.
Hinweis: In der Literatur findet man zc = 3:7959 und c = 0:36776.
Literatur
K. Binder, D. W. Heermann, Monte Carlo Simulation in Statistical Physics, Springer
Verlag, 1992.
H. Gould, J. Tobochnik, An Introduction to Computer Simulation Methods:
Applications to Physical Systems, Parts I and II, Addison Wesley, 1988.
J. Honerkamp, Stochastische Dynamische Systeme: Konzepte, numerische Metho-
den, Datenanalysen, VCH Verlagsgesellschaft, 1990.
S. E. Koonin, D. C. Meredith, Physik auf dem Computer, Band 1+2, R. Oldenbourg
Verlag, 1990.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
vorherigen Abschnitt können wir im Prinzip die kürzeste und in der Praxis eine sehr
kurze Rundreise finden.
Physik
Verteile N Punkte – jeder Punkt entspricht einer Stadt – auf ein Quadrat mit der
Seitenlänge L und markiere einen Rundweg, der jeden Punkt genau einmal berührt.
Wieviele Rundwege gibt es? Eine bestimmte Route ist durch die Reihenfolge der
Punkte festgelegt, und offensichtlich gibt es N ! verschiedene Anordnungen, näm-
lich gerade alle Permutationen der N Punkte. Da jeweils N Startpunkte und zwei
Richtungen dieselbe Weglänge geben, müssen (N 1)!=2 verschiedene Wege be-
trachtet werden. Für N = 100 erhält man etwa 10155 Wege, also viel mehr, als man
jemals auf einem Computer wird durchprobieren können.
N ! wächst schneller als eN und sehr viel schneller als jede Potenz von N . Man
kann sich zwar leicht eine regelmäßige Anordnung der Städte überlegen, bei der die
kürzeste Reise angegeben werden kann, aber für den ungünstigsten Fall sind sich
die Mathematiker fast sicher, daß es keinen Algorithmus gibt, der den kürzesten
Rundweg in einer Anzahl von Schritten berechnet, die wie ein Polynom von N
wächst. N ! wächst wie N 2 (N=e)N . Mit den Methoden der Informatik kann man
1
jedoch das exakte Abzählen der Wege auf etwa N 2 2N Rechenschritte reduzieren,
für N = 100 also auf etwa 1034 Rechnungen. Das ist aber immer noch zuviel selbst
für einen heutigen Superrechner.
Obwohl die numerische Lösung des Problems fast aussichtslos scheint, hat die In-
formatik aber Methoden entwickelt, mit denen in einem konkreten Fall die kürzeste
Rundreise eines Handlungsreisenden, der etwa N = 2500 Städte besuchen soll,
exakt berechnet wurde. Mathematisch läßt sich das TSP so formulieren: cij sei der
Abstand der Punkte i und j , und es sei xij = 1 , falls die Rundreise die Städte i und
j direkt verbindet, xij = 0 sonst. Sowohl cij als auch xij sind also symmetrisch in
den Indizes i und j . Dann suchen wir die kleinste Länge
X
E0 = fmin
x g
cij xij (5.66)
ij
i<j
unter der Nebenbedingung
X
N
xij = 2 für alle i : (5.67)
j =1
Gleichung (5.67) besagt, daß die Reise jede Stadt genau einmal berücksichtigt, die
5.6 Kürzeste Rundreise 223
worten. Wenn wir durch den Raum aller Wege S wandern und H (S ) als Höhe anse-
hen, dann ist H (S ) ein komplexes Gebirge mit vielen Tälern, Seitentälern, Schluch-
ten und Schächten. Laufen wir also nur den Berg hinab, so werden wir mit hoher
Wahrscheinlichkeit in einem Nebental weit weg vom absoluten Minimum landen.
Die Monte-Carlo-Methode (bei T > 0) erlaubt hingegen auch mit einer gewissen
Wahrscheinlichkeit, die vom Höhenunterschied abhängt, Schritte bergauf. Wie lan-
ge aber dauert es, einen hohen Bergkamm zu überschreiten, um in ein tieferes Tal
zu kommen?
Diese Zeit kann wie im vorigen Abschnitt mit dem Arrhenius-Gesetz abgeschätzt
werden. Sei E > 0 die zu überwindende Höhendifferenz. Dann ist eine typische
Zeit
= 0 eE=T : (5.70)
Beim Abkühlen müssen wir dem Wanderer Zeit lassen, die Bergkämme zu über-
schreiten. Durch Umkehren der Gleichung (5.70) sehen wir, daß ein für die Simula-
tion entworfener Abkühlplan T (t) – dabei sei t die aktuelle Rechenzeit – möglichst
die Ungleichung
T (t) Et : (5.71)
ln 0
erfüllen sollte. Die Temperatur T darf daher als Funktion der Zeit t nur extrem
langsam sinken, um thermisches Gleichgewicht zu garantieren. In der Praxis wird
man nie so viel Rechenzeit aufwenden können, um das thermische Gleichgewicht
perfekt zu simulieren. Aber wenn wir nur dicht beim Gleichgewicht bleiben können,
werden wir dennoch eine Energie finden, die fast die Grundzustandsenergie erreicht.
Die Weglänge wird also fast optimal sein, während der tatsächliche Weg ganz anders
als der optimale aussehen kann.
Mit wenig Programmieraufwand und geringem Wissen über das Problem, aber
mit viel Rechenzeit, kann man daher mit dieser Methode des Simulierten Ausglü-
”
hens“ (simulated annealing) ein gutes lokales Minimum eines komplexen kombina-
torischen Optimierungsproblems finden. Die Methode kann leicht auf viele andere
Probleme dieser Art angewandt werden, sie konkurriert zur Zeit allerdings mit so-
genannten genetischen Optimierungsalgorithmen, die mit Populationen von Wegen
arbeiten.
Bevor wir die Einzelheiten des Algorithmus besprechen, wollen wir die kürzeste
Rundreise für den Fall abschätzen, daß N Städte zufällig und unkorreliert im Qua-
drat der Kantenlänge L verteilt sind. Wenn wir zu jeder Stadt i den Abstand ri zum
nächsten Nachbarn bestimmen, dann gilt offenbar für die kleinste Länge:
X
N
E0 ri : (5.72)
i=1
5.6 Kürzeste Rundreise 225
Für N !1 hi
kann die rechte Seite als N r geschrieben werden, wobei r der hi
hi
mittlere Nächste-Nachbar-Abstand ist. Wir wollen nun r berechnen, dabei aber
den Effekt des Randes vernachlässigen und dazu einen genügend großen Ausschnitt
der Ebene betrachten, auf der Städte mit der Dichte = N=L2 verteilt sind. Sei
w(r)dr die Wahrscheinlichkeit, daß die nächste Nachbarstadt einen Abstand zwi-
schen r und r + dr hat. w(r )dr ist also die Wahrscheinlichkeit, zwischen null und
r keinen nächsten Nachbarn zu finden, multipliziert mit der Wahrscheinlichkeit, in
dem Kreisring mit der Fläche 2r dr eine Stadt zu finden:
2 Zr 3
w(r) dr = 41 w(r0 ) dr0 5 2r dr : (5.73)
0
Diese Integralgleichung für w(r ) läßt sich unmittelbar in eine Differentialgleichung
für f (r) = 1
Rr w(r0 ) dr0 umwandeln, wenn man f 0(r) = w(r) benutzt,
0
nämlich
f 0 = 2 r f mit f (0) = 1 : (5.74)
Als Lösung erhalten wir
f (r ) = e r2 und
w(r) = 2r e r : 2
(5.75)
Der mittlere Abstand der nächsten Nachbarn ist durch w(r ) gegeben:
Z1 Z1 1 = 1 pL :
hri = r w(r) dr = 2 e r2 r 2 dr = p
2 2 N (5.76)
0 0
Damit gilt nach Gleichung (5.72) für die Länge E0 der kürzesten Rundreise (im
Limes N !1 )
p
E0 12 L N : (5.77)
l = Ep0 (5.78)
L N
kann man bis heute nur numerisch bestimmen, z. B. finden Percus und Martin l=
0:7120 0:0002 im Limes N ! 1.
226 5 Monte-Carlo-Simulationen
Algorithmus
Wie im vorigen Abschnitt müssen wir uns einfache Änderungen des Zustandes S
überlegen. Erlaubte Wege kann man durch ein Feld darstellen, das die Reihenfolge
enthält, mit der die Städte besucht werden,
wobei ik 2f g
1; :::; N die Nummer der Stadt ist. Es gibt viele Möglichkeiten, aus
einer Rundreise S eine etwas geänderte S 0 zu konstruieren. Hier wollen wir der
Einfachheit halber nur die folgende vorstellen: Wir wählen zufällig eine Position p
und eine Länge l N=2, trennen den Abschnitt ip :::ip+l aus dem Weg S heraus
und fügen ihn in umgekehrter Reihenfolge wieder ein,
Dabei ist p + l modulo N zu nehmen. Dieser Zug ist in Bild 5.12 dargestellt.
Mit N = 6 , p = 3 und l = 2 wird die Rundreise S = (1; 2; 3; 4; 5; 6) zu
S 0 = (1; 2; 5; 4; 3; 6). Wiederholte Anwendung dieses Zuges führt offenbar durch
die gesamte Menge aller möglichen Wege und kann alle Kreuzungen beseitigen.
Damit haben wir alles, was wir zur Anwendung der im vorigen Abschnitt beschrie-
2 2
1 1
3 3
6 6
4 4
5 5
benen Monte-Carlo-Simulation benötigen. Jeder versuchte Zug wird akzeptiert, falls
die neue Rundreise kürzer ist H (S 0 ) H (S ) oder eine Zufallszahl r [0; 1]
kleiner als der Boltzmann-Faktor exp
H (S 0 ) H (S ) =T ist.
2
Im letzteren Fall müssen wir jedes Mal sowohl eine Zufallszahl r als auch die
Funktion exp(:::) berechnen. Beides kann man vermeiden, indem man den Boltz-
mann-Faktor durch eine Stufenfunktion T H (S 0 ) H (S ) ersetzt. Der Zug
S S wird also immer akzeptiert, wenn die Energiedifferenz H (S 0 ) H (S) klei-
! 0
ner als T ist. Für diese Vereinfachung kennen wir keine theoretische Begründung,
5.6 Kürzeste Rundreise 227
sie wird aber seit kurzem bei der kombinatorischen Optimierung erfolgreich ange-
wandt.
Das C-Programm travel.c berücksichtigt beide Methoden. Im Quadrat der
Länge L werden N Städte zufällig verteilt. Die Koordinaten (x; y ) jeder Stadt sind
im Feld map mit der Struktur city deklariert:
typedef struct {int x,y;} city;
city map[MAXCITIES];
N ist auf den Wert 100 gesetzt, es kann aber auch als Parameter beim Aufruf von
travel übergeben werden. Dies geschieht mit
main(int argc,char *argv[])
{
...
if(argc>1) N=atoi(argv[1]);
...
Die Reihenfolge der Städte wird im Feld int path[N] festgelegt. Am Anfang
werden die Koordinaten (x; y ) der Städte zufällig und der Startweg als S = (0; 1;
: : : ; N 1) gewählt. Die Hauptschleife sieht dann folgendermaßen aus:
while (!done)
{
event();
anneal(path);
if(count++ > DRAW)
{
drawpath(path);
oldlength = length(path);
print(oldlength);
if(aut) temp = .999*temp;
count=0;
}
}
Die Funktion event() fragt den Tastaturpuffer ab. Bei laufendem Programm sind
folgende Aktionen möglich: Herauf- oder Heruntersetzen der Temperatur um 10%,
Wahl der Methode Boltzmann-Faktor oder Schwellenfunktion, Umschalten auf auto-
matische Temperaturerniedrigung und das Speichern der aktuellen Rundreisekonfi-
guration. Schließlich kann man noch die Temperatur auf den Wert temp=0 springen
lassen. Dann werden nur noch solche Züge akzeptiert, die die Weglänge verringern.
Die Funktion anneal(path) berechnet den nächsten Monte-Carlo-Schritt. Es
werden zufällig die Position pos und die Länge len gewählt, die benötigt werden,
228 5 Monte-Carlo-Simulationen
Falls diese Größe wahr ist, also den Wert 1 hat, wird durch die Standardfunktion
memcpy der neue Weg in den alten kopiert, der Zug S ! S 0 wird akzeptiert.
Insgesamt lautet die Funktion
pos=rand()*f1;
len=rand()*f2;
change(newpath,oldpath,pos,len);
newlength=changed_length(oldlength,oldpath,pos,len);
de=newlength–oldlength;
if(de==0.) return;
if((ann==1 && (de < 0 || frand() < exp(–de/temp))) ||
(ann==0 && de < temp))
{
memcpy(oldpath,newpath,N*sizeof(int));
oldlength=newlength;
flipcount++;
}
}
f1 und f2 sind vorher definierte Skalierungsfaktoren und frand() ist ein Zufalls-
zahlen-Generator, der gleichverteilte reelle Zahlen im Einheitsintervall erzeugt. Er
kann z. B. am Anfang des Programms mit
definiert werden.
5.6 Kürzeste Rundreise 229
Die neue Rundreise wird erzeugt, indem zunächst die alte Rundreise (op) in die
neue (np) kopiert wird. Dann wird zwischen pos und pos+len die Reihenfolge
der Städte umgedreht. Das sieht so aus:
void change(int np[],int op[],int pos,int len)
{
int i,j;
memcpy(np,op,N*sizeof(int));
j=len;
for(i=0;i<=len;i++)
{
np[(pos+i) % N]=op[(pos+j) % N];
j––;
}
}
Die Berechnung der Weglänge ist offensichtlich:
double length(int path[] )
{
int i,j;
double l=0.,dx,dy;
for(i=0;i<N;i++)
{
j=(i+1)%N;
dx=map[path[i]].x–map[path[j]].x;
dy=map[path[i]].y–map[path[j]].y;
l+= sqrt(dx*dx+dy*dy);
}
return (l);
}
Weitere Funktionen drawpath und print zeichnen den Weg bzw. schreiben Text
in das Graphikfenster. Nach dem Kompilieren können wir mit dem Aufruf travel
die Suche nach der kürzesten Rundreise auf dem Bildschirm beobachten und dabei
die Temperatur hoch- und herunterfahren.
Ergebnisse
Wir haben die Daten aus travel.dat mit Mathematica eingelesen und gezeich-
net. Der zufällig erzeugte Startzustand von etwa 100 Städten ist in Bild 5.13 zu se-
230 5 Monte-Carlo-Simulationen
hen. Die skalierte Weglänge l, Gleichung (5.78), hat den Wert l ' 4:8. Wir starten
bei einer Temperatur von L/8. Schon bei dieser relativ hohen Temperatur relaxiert
das System schnell auf den Wert l ' 2:2, dabei werden etwa 20% der versuchten
Züge akzeptiert. Durch langsames automatisches Abkühlen, wobei die Temperatur
nach jeweils 100 Versuchen um 10=00 erniedrigt wird, gelangt das System nach et-
wa 30 Minuten Rechenzeit auf unserem PC in die Zustände Bild 5.14 bzw. Bild
5.15. Beide Rundreisen sind lokale Minima im Energiegebirge, d. h. alle unsere
Weg (l = 0:909), allerdings sehr viel schneller als mit den beiden Abkühlverfahren.
Bild 5.16 vergleicht die beiden Resultate der Abbildungen 5.14 und 5.15. Obwohl
die Längen der beiden Rundreisen fast gleich sind, sind die Reiserouten deutlich
voneinander verschieden. Wiederholt man die Simulation mit anderen Zufallszah-
len (bei denselben Städten), so erhält man fast die gleiche Weglänge aber wieder
eine ganz andere Reihenfolge der Städte.
Wir haben die Skalierung Gleichung (5.77) überprüft, indem wir eine Rundreise
p
mit 300 Städten simuliert und mit dem Schwellenalgorithmus langsam abgekühlt
haben. Das Ergebnis l = 0:826 bestätigt die Skalierung E0 / N.
Natürlich wissen wir nie, ob wir wirklich die kürzeste Rundreise gefunden haben.
Um diese Frage zu beantworten, benötigen wir die relativ aufwendigen Methoden
der Informatik. Um aber bei einem noch wenig verstandenen Optimierungsproblem
mit geringem Aufwand eine gute Lösung zu erhalten, kann man simulated annea-
ling wohl empfehlen.
232 5 Monte-Carlo-Simulationen
Übung
Hier soll versucht werden, das Optimierungsproblem aus Abschnitt 1.3 mit der Me-
thode des simulated annealing zu lösen. Es soll ein Signal mit gegebenem Lei-
stungsspektrum übertragen werden, und dabei soll die Spitzenspannung möglichst
klein gehalten werden.
Von der an N = 64 diskreten Zeitpunkten abgetasteten Spannung U1 ; : : : ; UN
f g
sei deren Fouriertransformierte b1 ; : : : ; bN , bzw. das Leistungsspektrum bekannt:
j j j j
bs 2 = bN s+2 2 = 1 für s = 9; 10; : : : ; 17 und bs = 0 sonst. Damit das Span-
f g
nungssignal U1 ; : : : ; UN reell ist, muß bN s+2 = bs gelten.
Gesucht sind die Phasen 's , die mit bs = ei's eine minimale Spitzenspannung
j j
geben, es soll also der Wert von minf's g (max r Ur ) bestimmt werden.
Der Zustand S aus Abschnitt 5.5 ist nun eine Konfiguration möglicher Pha-
sen ('9 ; : :; '17 ), und der Energie entspricht hier die Spitzenspannung H (S ) =
j j
max r Ur . In jedem Monte-Carlo-Schritt wird die Konfiguration der Phasen zufäl-
lig geändert, z. B. durch Variation einer einzelnen, beliebig herausgegriffenen Phase.
Dies liefert eine Energieänderung, und der Algorithmus aus Abschnitt 5.5 entschei-
det daraufhin, ob die neue Konfiguration akzeptiert wird.
Das bisher beste, von einem unserer Studenten erzielte Ergebnis liegt bei H =
0:739545 . Wer diesen Wert unterbietet, möge uns dies bitte mitteilen.
Literatur
A. G. Percus, O. C. Martin, Dimensional Dependence in the Euclidean Travelling
Salesman Problem, Physical Review Letters 76, 1188 (1996).
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Cambridge University Press, 1992.
J. Schnakenberg, Algorithmen in der Quantentheorie und Statistischen Physik, Zim-
mermann-Neufang, 1995.
Anhang A
Erste Schritte mit Mathematica
Auf fast allen Rechnern wird Mathematica mit dem Befehl math aufgerufen. Bei
Systemen mit einer graphischen Oberfläche geschieht dies manchmal indirekt durch
das Anklicken eines Symbols. Mathematica meldet sich danach mit In[1]:= und
erwartet eine Eingabe, die mit R ETURN abgeschickt wird. Die Notebook-Version
von Mathematica verhält sich insofern etwas anders, als hier einzelne oder meh-
rere Befehle mit S HIFT-R ETURN übergeben werden. Mathematica ist eine inter-
pretierende Programmiersprache, bearbeitet also sofort die Eingabe und präsentiert
das Ergebnis in der Form Out[..]= : : : auf dem Bildschirm. Dabei werden alle
Ausdrücke, die vorher in derselben Sitzung definiert wurden, berücksichtigt. Man
beendet eine Mathematica-Sitzung mit In[..]:= Quit. Der Befehl Exit bzw.
C ONTROL-D auf Unix-Systemen bewirkt dasselbe.
Simple Arithmetik
In[1]:= 4 + 7
Out[1]= 11
In[2]:= 3 4.2 Leerstelle = Multiplikation
Out[2]= 12.6 Dezimalzahlen mit Dezimalpunkt
In[3]:= 234 Auch = Multiplikation
Out[3]= 24
In[4]:= 24/8 / = Division
Out[4]= 3
In[5]:= 2 3 ^ ^ = Potenz
Out[5]= 8
234 Anhang A
^
In[6]:= (3+4) 2 2(3+1)
Out[6]= 41
In[7]:= %/5 % = das letzte ausgegebene Resultat
41
Out[7]=
5
In[8]:= N[%] N[x] = numerischer Wert von x
Out[8]= 8.2
In[9]:= 22.4/(6.023 10 23) ^
Out[9]= 3.71908 10–23
In[10]:= 3 ^ 236+4
”
Potenz“ vor Punkt“ vor Strich“
” ”
Out[10]= 8
In[17]:= ?Log
Log[z] gives the natural Logarithm of z (logarithm to
base E). Log[b, z] gives the logarithm to base b.
In[17]:= Log[E, %15] %15 ist dasselbe wie Out[15]. Alle wäh-
rend einer Sitzung erzeugten In[n] und
Out[n] sind wieder aufrufbar.
Out[17]= 0.5
In[18]:= Sqrt[ 1]
Out[18]= I
In[19]:= ?I
I represents the imaginary unit Sqrt[–1].
In[19]:= Exp[IN[Pi/4]]
Out[19]= 0.707107 + 0.707107 I
In[20]:= Re[%]+IIm[%] Re[z] = Realteil von z
Im[z] = Imaginärteil von z
Out[20]= 0.707107 + 0.707107 I
In[21]:= ?Arc
ArcCos ArcCot ArcCsc ArcSec ArcSech ArcSin ArcSinh
ArcTan ArcTanh ArcCosh ArcCoth ArcCsch
In[21]:= ArcTan[1] ArcTan[x]= arctan x
Pi
Out[21]=
4
Graphik
Wir verzichten im folgenden auf die Kennzeichnung von Ein- und Ausgaben durch
das In[..] bzw. Out[..] am Zeilenanfang. Eingaben an den Rechner sind durch
Fettdruck kenntlich gemacht, alles andere sind Ausgaben vom Rechner oder unsere
Kommentare.
236 Anhang A
Listen
numlist = f2,3,4g Eine Liste von drei Zahlen. Listen werde mit geschweif-
ten Klammern fg
geschrieben.
238 Anhang A
Head[numlist] ! List . Jedes Ding hat einen Kopf. numlist ist eine
Liste.
numlist 2 ^ ! f4,9,16g . Fast alle Funktionen sind Listable .
Log[numlist] // N ! Liste der Logarithmen
Table[2, f7g] ! f2,2,2,2,2,2,2g . Table[..] macht Listen.
Table[i^3, fi,5g] ! f1, 8, 27, 64, 125g
Table[1/j, fj,3,8g] ! f 13 , 14 , 15 , 16 , 17 , 18 g
Table[x, fx,0,2,0.25g] ! f0, 0.25, 0.5, ..., 2.g
Table[expr, f..g] erzeugt Listen. Die geschweifte Klammer mit
der allgemeinen Form fi, imin, imax, dig heißt ’iterator’.
Verkürzungen der allgemeinen Form sind möglich.
Ein Semikolon (;) nach einem Ausdruck unterdrückt das nächste Out[..].
Trotzdem haben die Variablen die zugewiesenen Werte.
abc[[ 1]] ! z . Ein negativer Index entspricht der Zählung von hinten.
Permutations[f1,2,3g] ! f g
alle Permutationen von 1,2,3 .
!!liste.dat
daten2 = << liste.dat Das Gegenstück zu >> ist der Befehl << . Man
240 Anhang A
Einfache Mathematica-Programme
Wir gehen davon aus, daß mit einem Texteditor eine Datei programm1.m mit
dem folgenden Inhalt erzeugt wurde:
tion Jn (x). Es benutzt die Tatsache, daß für n > 0 die erste Nullstelle von Jn (x)
etwa bei n + 1:9 n1=3 liegt und daß die folgenden Nullstellen alle ungefähr den
Abstand haben.
besselnull[n ,k ]:=
f
Block[ f,start,regel,nullstelle,liste , g
f[x ] = BesselJ[n,x];
start = If[n==0, 2.5, n + 1.9 nˆ(1/3)];
regel = FindRoot[f[x]==0, x,start ]; f g
nullstelle = x /. regel; liste =
fnullstelle ; g
While[Length[liste] < k,
start = liste[[–1]] + Pi;
regel = FindRoot[f[x]==0, x,start ]; f g
nullstelle = x /. regel;
AppendTo[liste,nullstelle] ];
If[n > 0, PrependTo[liste,0]];
f
Plot[f[x], x,0,liste[[–1]]+1 ]; g
liste ]
<< programm2.m
besselnull[3,4] ! Plot von J3 (x) und eine Liste der ersten vier Null-
stellen von J3 (x) .
Schleifen:
Do[expr, f’iterator’g]
For[start, test, incr, body]
While[test, body]
Nest[f, expr, n]
NestList[f, expr, n]
FixedPoint[f, expr]
242 Anhang A
^ ! 1
Integrate[1/(x 4 1), x]
x
das unbestimmte Integral von 4
1.
Simplify[D[%,x]] ! der Integrand des obigen Integrals. Simplify[..]
bringt auf den Hauptnenner, kürzt gemeinsame Faktoren und versucht, das Ergebnis
auf eine möglichst einfache Form zu bringen.
Integrate[Exp[cx],fx, a, bg] ! das bestimmte Integral von ec x
Erste Schritte mit Mathematica 243
FindRoot[Cos[x]==x,fx,1g] ! f g
x –> 0.739085 , die Lösung
f g
der Gleichung cos x = x. Die Klammer x,1 bedeutet: suche eine Lösung be-
züglich x und starte die Suche bei x=1.
FindRoot[fCos[ax]==x, aSin[ax]== 1g, fx,1g, fa,1g]
Auch Gleichungssysteme lassen sich mit FindRoot[..] lösen.
^
Plot[Product[(1+x/j 2),fj,Infinityg],fx,1,4g] ! eine
glatte Funktion, die im betrachteten Bereich monoton ansteigt.
^
FindRoot[Product[(1+x/j 2),fj,Infinityg]==20,fx,3g] !
Erste Schritte mit Mathematica 245
eine Fehlermeldung, weil sich die Funktion nicht symbolisch differenzieren läßt.
^
FindRoot[Product[(1+x/j 2),fj,Infinityg]==20,fx,f2,3gg]
So geht’s. Wenn man statt eines Startwertes ein Startintervall angibt, wird das Se-
kantenverfahren benutzt.
^
Solve[ax 2+bx+c==0,x] ! die 2 Lösungen der quadratischen Glei-
chung.
Solve[ArcSin[x]==a,x] ! ffx –> Sin[a] gg
^ ^
Solve[x 5 5x 2+1 == 0, x] Zu schwierig.
^ ^
NSolve[x 5 5x 2+1 == 0, x] ! 5 numerische Nullstellen.
DSolve[y’’[x]==y[x], y[x], x] ! die allgemeine Lösung dieser
Differentialgleichung.
DSolve[y’[x]==Cos[xy[x]], y[x], x] Fehlanzeige.
NDSolve[fy’[x]==Cos[xy[x]],y[0]==0g,y[x],fx, 5,5g] !
ein Mathematica-Objekt, das InterpolatingFunction heißt.
f[x ] = y[x] /. % So kann man aus dem Objekt InterpolatingFunction eine
f g
normale Funktion machen, die sich mit Plot[f[x], x,–5,5 ] plotten läßt.
Remove["Global‘"]
^
liste = f1, 2, f[a], g[b], x n, f[b], 3.4, Sin[p] 2g ^
Position[liste, f[ ]] ! ff3g,f6gg , nämlich eine Liste aller Plätze
mit f[irgendwas].
246 Anhang A
int i, antwort;
char ch;
float f, rationale_Zahl;
long Langes_i;
double Langes_f;
Als erstes Beispiel wollen wir die Zahlen 4, 5, .., 15 auf dem Bildschirm aus-
drucken: Wir schreiben in eine Datei druck.c die Zeilen
main( )
{
int i;
for( i=4; i<16; i=i+1) printf("i=%d \n",i);
}
Jeder Befehl muß durch ein Semikolon abgeschlossen werden. Die Iterationsschlei-
fe for enthält in runden Klammern die Struktur: (Start; Abbruchbedingung; Befehl
nach jedem Durchlauf). Hinter der runden Klammer erscheint der auszuführende
f g
Befehl; mehrere solcher Befehle müssen mit ... geklammert werden, wobei
hinter jedem Befehl das Semikolon stehen muß.
Dieses Programm wird mit
cc –o druck druck.c
compiliert, und der Befehl druck schreibt die Zahlen auf den Bildschirm. Die
Druckfunktion printf erwartet als erstes Argument eine Zeichenkette ": : :", die
sowohl den Text, als auch die Formatanweisung für die zu druckende Variable i
enthält. Je nach Typ der Variablen sind folgende Druckanweisungen gebräuchlich:
Variablentyp
%d int
%ld long
%c char
%f float (Fließkomma-Darstellung)
%e float (Exponential-Darstellung)
%lf double
%s string
Das Symbol \n ist ein Steuerzeichen, das einen Zeilenvorschub bewirkt. Es ent-
spricht der R ETURN-Taste.
Die obigen Druckanweisungen sind auch für das Einlesen zu verwenden, das die
Funktion scanf( ) übernimmt:
main( )
{ double i = 0.;
for(; i<100.;)
{ printf( "Bitte Zahl eingeben \n");
Erste Schritte mit C 249
#define N 1000 wird im gesamten Programm das Symbol N durch das Symbol
1000 ersetzt.
summe = a+b;
a = b = a/b * e;
mod = a % b;
Das Gleichheitszeichen ordnet der linken Variablen den rechten Wert zu. % ist die
Modulo-Operation, mod erhält also den Rest von a/b.
summe += a;
a++; b––;
C enthält einige Abkürzungen: Die obigen Befehle ersetzen summe = summe+a;
a = a+1; b = b–1;
a>b; größer als
a>=b; größer oder gleich
a==b; gleich
a!=b; ungleich
a<=b; kleiner oder gleich
a<b; kleiner als
Wenn die obigen Relationen wahr sind, erhält der Ausdruck den Wert 1, sonst den
Wert 0. Für logische Ausdrücke gibt es keinen speziellen Datentyp, C arbeitet ein-
fach mit ganzen Zahlen vom Typ int.
a<b || c!=a oder
a<b && c!=a und
!(a<b) nicht
wird der Befehl nach else ausgeführt. Der else-Zweig muß nicht angegeben
f g
werden, und mehrere Befehle muß man als Block ::: zusammenfassen, wie das
zweite Beispiel zeigt.
switch (ch=getch())
{
case’e’: exit(0);
case’f’: scanf("%lf",&a); break;
case’s’: scanf("%s",str); break;
default: printf("Sie haben %c eingegeben",ch);
break;
}
Mehrere, eventuell verschachtelte if...else...if...else... Anweisun-
gen kann man übersichtlicher durch einen switch Befehl ersetzen. Es wird das
nächste Tastaturzeichen durch die Funktion getch() aufgerufen, an die Variable
ch übergeben und diejenige case Anweisung ausgeführt, die den entsprechenden
Wert von ch enthält. Falls der Wert nicht vorhanden ist, wird die default Anwei-
sung ausgeführt. Jeweils der letzte Befehl sollte break; sein. Damit springt das
f g
Programm an das Ende des switch Blockes ::: .
for (summe=0., i=0; i<N; i++) summe +=feld[i]; for(;;);
Die for-Schleife haben wir schon kennengelernt. Die ersten zwei Anweisungen,
durch ein Komma getrennt, werden beim Start ausgeführt. Die Schleife bricht ab,
wenn der Wert nach dem ersten Semikolon Null (also falsch) ist. i++ wird nach je-
dem Schleifendurchgang ausgeführt. Das zweite Beispiel gibt eine unsinnige End-
losschleife, die nur durch den gewaltsamen Abbruch des Programmes mit Ctrl–c
(Control- und c-Taste gleichzeitig drücken) gestoppt werden kann.
while(ch!=’e’)
{ ch=getch();
printf ("Das Zeichen %c wurde eingetippt \n",ch);
}
Die while-Schleife ist eine weitere wichtige Iteration von Befehlen. Sie wird so-
lange ausgeführt, wie der Wert in der runden Klammer ungleich 0, also wahr ist.
Die Funktion getch() liest ein Zeichen von der Tastatur und gibt es an die Va-
riable ch. Dann wird es gedruckt. Falls das Zeichen ’e’ eingetippt wird, wird die
Schleife beendet.
double v[6];
double u[5]={1.0, 1.5, 0., 6, –1.};
v[5]=u[1] * u[0];
252 Anhang B
Bei der Deklaration von Vektoren muß der Typ und die Länge des Vektors ange-
geben werden. Die Indizes laufen von 0 bis (Länge 1) und werden mit eckigen
Klammern angesprochen. v[5] hat also den Wert 1:5, v[6] ist nicht definiert.
Vektoren können bei der Deklaration initialisiert werden.
double mat[6][5];
for(i=0;i<6;i++)
{
for(sum=0., j=0;j<5;j++)
sum+= mat[i][j]*u[j];
v[i]=sum;
}
Matrizen werden durch zwei Indizes deklariert und angesprochen. Für jeden Index
ist eine separate eckige Klammer erforderlich. Der erste Index gibt die Zeile, der
zweite die Spalte der Matrix an. Im obigen Beispiel ist der Vektor v das Ergeb-
nis der Multiplikation der Matrix mat mit dem Vektor u. Die Matrix hat 6 Zeilen
i = 0; :::; 5 und 5 Spalten j = 0; :::; 4. mat enthält die Adresse des ersten Ele-
mentes mat[0][0] und mat[i] diejenige der i-ten Zeile, also des Elementes
mat[i][0]. Das ist wichtig, wenn man Matrizen oder Zeilen davon an Funktio-
nen übergeben will.
double *a, wert, b;
a = &b;
scanf ("%lf", a);
wert = *a;
Es gibt in C Variablen, die die Adresse und nicht den Wert eines Speicherplat-
zes enthalten. Sie werden durch Typ * deklariert, d. h. die Variable a enthält die
Adresse eines Speicherplatzes vom angegebenen Typ, oder a zeigt auf einen Platz
vom Typ double. Solche Variablen werden auch Zeiger genannt, und ihr Wert
wird mit *a angesprochen. Im obigen Beispiel wird die Adresse von b an a über-
geben, dann wird auf diesen Platz eine reelle Zahl eingelesen, und der Wert von
a wird an wert übergeben. Dasselbe Ergebnis für wert hätte auch der Befehl
scanf("%lf", &wert) geliefert.
In der folgenden Tabelle sind x und y vom Typ double. Winkel werden bei
trigonometrischen Funktionen im Bogenmaß angegeben.
sin(x) Sinus von x
cos(x) Kosinus von x
tan(x) Tangens von x
asin(x) arcsin(x) im Bereich [ =2; =2], x 2[ 1; 1].
acos(x) arccos(x) im Bereich [0; ], x [ 2 1; 1].
Erste Schritte mit C 253
double r;
r = rand() / (RAND_MAX +1.);
#include <math.h>
main()
{
double f(double),x;
for(x=0.;x<10.;x+=.5)
printf("\n f(%3.1lf) = %4.2e ",x,f(x));
}
Man kann eigene Funktionen definieren, hier f (x) = x2 e x =2 . Dazu muß die
2
Funktion in der aufrufenden Funktion (hier main()) deklariert und dann definiert
werden, jeweils mit den Typenangaben, auch für die Argumente. Die Befehle der
f g
Funktion f (x) stehen in einem Block ::: , und der Wert wird mit return an den
aufrufenden Funktionsnamen zurückgegeben. Wird kein Wert zurückgegeben oder
kein Argument übergeben, so wird der Typ void benutzt. Es wird nur der Wert des
Argumentes x übergeben, f kann hier also nicht den Wert der Variablen x ändern.
Wird dagegen die Adresse von x , also &x übergeben, dann kann f auch den Wert
von x ändern:
#include <math.h>
main()
{
double f(double *),x=0.;
while (x<100.) printf(" \n f(%lf)=%lf",x,f(&x));
}
for(i=0;i<n;i++) u[i]=v[i]=i;
printf(" \n %lf \n",ScalarProduct(u,v,n));
}
Erste Schritte mit C 255
Vektoren x und y angewendet werden, sie steht also nur als Abkürzung für einen
Block von Befehlen.
Vorsicht: Fallen!
Wir wollen hier einige Standardfehler auflisten, die leider oft keine Fehlermeldung
produzieren.
b = mat[i,j];
if(a=b) dosomething();
Der Programmierer meinte sicherlich a==b. Der obige Befehl weist b der Variablen
a zu und prüft dann, ob der Wert von a gleich Null ist. Falls nicht, wird die Funktion
dosomething() aufgerufen.
Alle Variablen und Konstanten sollen vom Typ Integer sein. Manche Compiler wer-
ten diesen Ausdruck von rechts nach links aus. In diesem Fall erhält der Quotient
und damit die gesamte Rechnung den Wert Null, da beim Ergebnis der Division
zweier ganzer Zahlen der Rest verloren geht. Also sollte man das Produkt in Klam-
mern setzen, dann erhält man auf jeden Fall die Zufallszahlen 0, 1 und 2.
int vector[10],i;
for (i=1; i<=10; i++) vector[i]=i*i;
Vektoren der Länge N werden mit i=0 bis i=N–1 indiziert, vector[10]=100;
weist ohne jede Warnung dem Speicherplatz nach dem für vector reservierten
Bereich den Wert 100 zu, und der Programmierer weiß nicht, was er da gerade
überschreibt!
main()
{
char *name;
printf("Wie heissen Sie? ");
scanf( "%s",name);
}
Erste Schritte mit C 257
name ist als Adresse (=Zeiger) auf eine Zeichenvariable deklariert, aber nirgends
wird der Zeiger initialisiert. Das heißt, in der Variablen name steht irgendeine un-
bekannte Zahl, die als Adresse interpretiert wird, und ab dieser Adresse wird ihre
Eingabe geschrieben und zerstört damit andere Daten. Vor diesem Fehler warnt der
Compiler, er führt ihn aber aus.
char msg[10];
msg ="Hallo";
Namen von Vektoren sind zwar Zeiger, aber keine Variablen. "Hallo" markiert die
Adresse der Zeichenkette, jedoch darf die Adresse des Vektors msg nicht geändert
werden. Der Compiler erzeugt eine Fehlermeldung. Folgendes Programm beseitigt
beide vorherigen Fehler
main()
{
char name[20],*msg;
printf(" \n Wie heissen Sie ?");
scanf("%s",name);
msg="Hello";
printf("\n %s %s \n", msg,name);
}
Der Unterschied zwischen "x" und ’x’
Der erste Ausdruck ist eine Zeichenkette, er besteht aus den beiden Zeichen ’x’
und \0. Der zweite Ausdruck ist ein einzelnes Zeichen.
int a=100;
scanf("%d",a);
scanf interpretiert a als Adresse Nr. 100 und überschreibt das, was dort gerade
steht. Richtig lautet der Einlesebefehl scanf("%d",&a);.
Literatur
B.W. Kernighan, D.M. Ritchie, Programmieren in C, Carl Hanser Verlag, 1990.
Anhang C
Erste Schritte mit UNIX
Einführung
Dieser Anhang soll dem Anfänger einen kurzen Überblick über die wichtigsten
UNIX-Befehle geben. Zusätzlich wird erklärt, wie man über das Internet an die
in diesem Buch beschriebenen Beispielprogramme kommt, wie man diese editieren
und kompilieren kann.
Unter UNIX gibt es mittlerweile viele public domain Programme, d.h. Program-
me, die man für nichtkommmerzielle Zwecke frei kopieren darf. Davon haben sich
etliche zu Standardprogrammen entwickelt. Einige werden auch hier beschrieben,
wie less, gzip und gcc, g++. Wenn diese Programme bei Ihnen nicht verfügbar
sind, können Sie den Systembetreuer bitten, diese zu installieren. Diese Programme
sind mit (*) gekennzeichnet.
UNIX ist ein Multiuser- und Multitasking-Betriebssystem. Es können mehrere
Benutzer unabhängig voneinander zur selben Zeit arbeiten und mehrere Programme
im Hintergrund gleichzeitig“ gerechnet werden. Gleichzeitig“ bedeutet, daß diese
” ”
Prozesse sich die Rechenzeit aufteilen.
Um an einem UNIX System arbeiten zu können, braucht man einen Benutzerna-
men Username und ein Kennwort Password. Diese bekommt man vom Systembe-
treuer. Jeder Benutzer hat ein eigenes Verzeichnis Home-Directory auf der Festplat-
te, in dem er seine Programme und Dateien speichern kann.
Nachdem man am Rechner den Benutzernamen und sein Passwort eingetippt hat,
befindet man sich entweder in einer shell – das heißt, der Rechner wartet auf Kom-
mandos – oder es wird eine Graphikoberfläche (üblicherweise X11) gestartet. Falls
im letzteren Fall nicht automatisch ein Eingabefenster geöffnet wurde, muß man
mit der Maus ein Fenster erzeugen. Dann können die UNIX-Befehle in das Fenster
eingetippt und mit R ETURN abgeschickt werden. Fenster können mit den Mausta-
sten verschoben, in alle Richtungen vergrößert und verkleinert und als icon in den
Hintergrund gebracht werden.
Folgende Befehlsgruppen werden in diesem Anhang beschrieben:
Dateien
Eine Datei ist eine Menge von Zeichen. Diese können Textdaten, Zahlenmengen
oder auch Programme bedeuten. Die Einheit, in der meistens die Länge von Dateien
gemessen wird, ist das Byte. Ein Byte ist eine Zahl zwischen 0 und 255. Üblicher-
weise benötigt ein Zeichen ein Byte und eine Zahl zwei bis vier Bytes Speicherplatz
in einer Datei.
Jede Datei hat einen Namen. Dieser kann unter UNIX auf fast allen Systemen
mehr als 8 Buchstaben Länge haben. Groß- und Kleinschrift wird unterschieden.
Dateien besitzen ferner Attribute wie: Name des Eigentümers, Name der Gruppe,
der sie zugewiesen ist und Rechte des Eigentümers, der Gruppe und aller anderen
Benutzer. Man kann zum Beispiel allen anderen Benutzern (abgesehen vom System-
betreuer) verbieten, die Datei zu lesen.
Die Dateien sind hierarchisch in Verzeichnisse (Directories) gegliedert. Diese
kann man mit Schubladen vergleichen. Die Wurzel (root) dieses Verzeichnisbaumes
hat das Symbol /. Unterverzeichnisse werden mit / getrennt.
Eine tyische Baumstruktur wäre zum Beispiel:
/ — /etc — /etc/motd
/etc/passwd
...
/users — /users/user1 — /user/user1/.cshrc
/user/user1/.login
...
...
...
/unix
Dabei merkt der Benutzer nicht, ob die Verzeichnisse eigene Platten oder gar Platten
an entfernten Rechnern sind. Die Shell merkt sich ein aktuelles Verzeichnis current
directory. Dieses ist am Anfang das eigene Verzeichnis. Dateinamen, die mit / be-
ginnen, werden absolut von der Wurzel aus bezeichnet. Beginnt ein Dateiname mit
260 Anhang C
˜/, so wird stattdessen das eigene Verzeichnis eingesetzt. Beginnt er mit ˜user/, wird
er relativ zu dem angegebenen Benutzer user gesehen. Alle anderen Dateinamen
werden relativ zu dem aktuellen Verzeichnis gesehen. Ein Punkt . bezeichnet das
aktuelle und zwei Punkte .. das übergeordnete Verzeichnis.
Hilfen
Mit dem Befehl man kann man sich die Beschreibung eines Befehles seitenwei-
se auf dem Bildschirm anzeigen lassen. Dabei werden Syntax und auch Optionen
und Parameter erklärt. Zum Beispiel erhält man mit dem Kommando man man die
Beschreibung des man Kommandos.
Weiß man nur ein Stichwort, nicht aber den genauen Befehl, kann man mit man
–k stichwort eine Liste der Befehle erhalten, die in ihrer einzeiligen Beschrei-
bung das Wort stichwort enthalten.
Erste Schritte mit UNIX 261
Dateimanipulation
Eine Datei kann auf komfortable Weise mit einem sogenannten Editor erstellt, bzw.
geändert werden. Dieses wird später beschrieben. Textfiles können mit cat, more
oder less(*) auf dem Bildschirm angezeigt werden. Dabei wird bei more die Da-
tei seitenweise angezeigt, und bei less kann man sogar mit Tastendruck beliebig
in dem Dokument umherspringen.
Das Kopieren einer Datei kann mit dem Unix-Befehl copy geschehen. Die Syn-
tax ist: cp eingabe ausgabe. Hierbei wird die Datei eingabe in die Datei
ausgabe kopiert. Um Verzeichnisse zu kopieren muß die Option –R angegeben
werden. Dabei werden die tieferliegenden Dateien rekursiv kopiert.
Dieselbe Syntax hat der move Befehl, der es ermöglicht, Dateien umzubenennen,
bzw. innerhalb verschiedener Directories zu verschieben: mv alt neu benennt
die Datei alt in neu um. Dies kann auch mit Directories geschehen.
Eine Datei kann man mit dem rm Befehl löschen (remove). rm file löscht
die Datei file. Diese kann dann nicht mehr wiederhergestellt werden. rm *.txt
löscht im aktuellen Verzeichnis alle Dateien mit der Extension txt. Ganze Direc-
tories einschließlich der darin enthaltenen Dateien kann man mit dem Befehl rm
–R rekursiv löschen. Hierbei sollte man aber sehr aufpassen, daß nicht aus Verse-
hen wichtige Daten gelöscht werden. Anfangs sollte man zusätzlich die Option –i
benutzen. Hier wird interaktiv“ bei jeder Datei explizit nachgefragt, ob diese auch
”
wirklich gelöscht werden soll, also zum Beispiel: rm –Ri verzeichnis.
Passwort
Das eigene Passwort kann mit dem Kommando passwd geändert werden. Hierzu
muß man das alte Passwort, das neue und (zur Sicherheit, daß man sich nicht ver-
tippt hat) noch einmal das neue eintippen. Die Passwörter erscheinen nicht auf dem
Bildschirm.
Arbeitet man auf mehreren miteinander vernetzten Rechnern, wird oft NIS (Net-
work Information Service) – früher Yellow Pages – verwendet. Dabei existiert nur
eine Passwortdatei für alle Rechner. Es gibt dann einen Server, der die Passwörter
verwaltet. In so einem Fall muß man das Kommando yppasswd verwenden.
nG springt in Zeile n
Es gibt noch wesentlich mehr Kommandos. So kann man natürlich Blöcke markie-
ren und kopieren oder auch ganze Blöcke einrücken.
264 Anhang C
Der C-Compiler
Das Übersetzen eines C-Programmes in einen ausführbaren Code geschieht in zwei
Schritten. In dem ersten wird das Programm in ein sogenanntes Objektfile über-
setzt (compiling). Dieses enthält dann das übersetzte Programm. Im zweiten Schritt
wird dieses Objekt mit Standardbibliotheken und eventuell anderen Objektdateien
zu einem ausführbaren Programm zusammengefügt (linking).
Der C-Compiler, der bei einem UNIX System mitgeliefert wird, heißt cc. Mit
dem Aufruf cc file.c wird das Programm file.c übersetzt und auch schon
gleich gebunden. Das fertige, ausführbare Programm heißt dann a.out. Sollen
Mathematikroutinen, z. B. trigonometrische Funktionen, verwendet werden, muß
die Mathematikbibliothek dazugebunden werden. Dieses geschieht mit der Option
–lm.
Wichtige Optionen sind:
–o name Das Ausgabefile heißt name statt a.out
–O optimiert den Code
–c erzeugt nur eine Objektdatei
–I dir Include-Dateien werden zusätzlich in dir gesucht
–lx Der Linker bindet die Bibliothek libx dazu
–L dir Der Linker sucht Programmbibliotheken zusätzlich in dir
Ein Standard C-Compiler, der frei verfügbar ist, ist der gcc(*) von GNU. Er liefert
oftmals schnelleren Code als der vom System mitgelieferte. Weiterhin unterstützt er
C++ mit dem Aufruf g++.
Make
Um größere Programmpakete zu übersetzen, benutzt man häufig das Hilfsprogramm
make. Es liest eine Datei namens Makefile und arbeitet die darin angegebenen
Anweisungen ab. Das Format soll hier nicht besprochen werden.
Netzwerke
Viele UNIX-Rechner sind über das Internet vernetzt. In diesem Abschnitt werden
die wichtigsten Befehle beschrieben.
Jeder am Internet angeschlossene Rechner hat eine Adresse. Diese besteht aus
vier Zahlen, die jeweils zwischen 0 und 255 liegen dürfen. Jeder Adresse ist ein Na-
me zugeordnet. So hat ftp.physik.uni–wuerzburg.de zur Zeit die Adresse
Erste Schritte mit UNIX 265
Trying...
Connected to wptx15.physik.uni–wuerzburg.de.
Escape character is ’ˆ]’.
login:
An dieser Stelle muß der Benutzer seine Benutzerkennung und sein Passwort
eingeben.
Man sollte Telnet-Sitzungen immer korrekt schließen, d.h. den fremden Rechner
mit logout verlassen. Ist mal alles schief gegangen, kommt man mit dem ange-
gebenen Steuerzeichen Escape character in ein Telnet-Menü. Dabei bedeutet das
ˆ] Zeichen das gleichzeitige Drücken der Control- und der ] -Taste. In dem Telnet-
Menü erhält man mit dem Kommando ? eine kurze Hilfe. Mit close kann die
Verbindung beendet werden.
Eine Möglichkeit, auf einem anderen UNIX-Rechner zu arbeiten, bietet das Kom-
mando rlogin. Hierbei wird der gleiche Benutzername angenommen. Mit der
Option –l lässt sich dieser explizit ändern.
get file kopiert die Datei file vom fremden auf den lokalen Rechner
put file kopiert die Datei file vom lokalen auf den fremden Rechner
mget files wie get, nur dürfen Joker im Dateinamen verwendet werden
mput files wie put, nur dürfen Joker im Dateinamen verwendet werden
Internet-Dateitransfer
Viele Einrichtungen bieten Programme an, die sich jeder frei kopieren darf. Diese
kann man sich über das Internet mit Hilfe von ftp beschaffen. Spezielle ftp-server
bieten dazu die Möglichkeit, sich als Benutzer ftp oder anonymous einzuloggen.
Als Passwort verlangen sie die eigene E-Mail Adresse. So sind auch die in diesem
Buch angegebenen Programme auf dem ftp-Server
ftp.physik.uni–wuerzburg.de
Datenkomprimierung
Zum Archivieren von Daten ist es nützlich, mehrere Programme unter einem Namen
zusammen zu speichern. Dieses wird oft mit dem Programm tar (tape archiver)
getan. Mit tar –cf file.tar dir archiviert man das Verzeichnis dir mit
all seinen Dateien und Unterverzeichnissen in die eine Datei file.tar. Mit dem
Befehl tar –tf file.tar erhält man ein Inhaltsverzeichnis des Archivs und
mit dem Befehl tar –xf file.tar wird das Verzeichnis wieder hergestellt.
Um dann noch Plattenplatz zu sparen, werden Komprimierungsprogramme ein-
gesetzt. Ein häufig verwendetes ist gzip(*) . gzip file komprimiert die Datei
file. Das Ausgabefile hat den Namen file.gz. Zum Expandieren dienen die
Befehle gzip –d file.gz oder gunzip file.gz.
Erste Schritte mit UNIX 267
Literatur
UNIX: Eine Einführung, Regionales Rechenzentrum für Niedersachsen, Universität
Hannover, 1993.
J. Gulbins, Unix, Springer Verlag, 1988.
Anhang D
Erste Schritte mit Xgraphics
#include <stdlib.h>
#include <math.h>
#include "Xgraphics.h"
main()
{
int x=MAXX/2,y=MAXY/2,r,i;
InitX();
mywindow=CreateWindow(MAXX,MAXY,"random walk");
ShowWindow(mywindow);
for(i=0;i<N;i++)
{ DrawPoint(mywindow,x,y,1);
r=rand()/(RAND_MAX+1.)*4.;
switch(r)
{ case 0: x++;break;
case 1: x––; break;
case 2: y++;break;
case 3: y––;break; }
}
getchar();
ExitX();
}
x und y sind die Pixel-Koordinaten des Teilchens im Fenster, dessen Größe durch
MAXX und MAXY festgelegt ist. Gemäß der Zufallszahl r 2 f0; 1; 2; 3g werden sie
jeweils um den Wert eins erhöht oder erniedrigt. Mit fünf Graphikbefehlen kann
man also schon interessante Bewegungen auf dem Bildschirm erzeugen. Das Pro-
gramm mit dem Namen walk.c wird mit compile walk übersetzt und mit
walk aufgerufen. Dabei müssen eventuell im File compile die entsprechenden
Pfade der eigenen Maschine eingetragen werden, und das File muß mit chmod
u+x compile ausführbar gemacht werden. Das Ergebnis sollte das Bild D.1 sein.
Wenn man dann im aufrufenden Fenster ein Zeichen eingibt, verschwindet das Bild
mit dem Zufallsweg.
Weitere Demonstrationsprogramme, die auch die anderen Fähigkeiten von Xgra-
phics zeigen, finden sich auf der Diskette.
Literatur
M. Lüders, Einführung in Xgraphics, Postscript File auf beiliegender Diskette, au-
ßerdem erhältlich über FTP unter ftp.physik.uni–wuerzburg.de als
Xgraphics.ps im Verzeichnis /pub/Xgraphics/ .
O. Jones, Einführung in das X-Window System, Hanser Verlag, 1991.
Anhang E
Programme
In diesem Abschnitt wird ein Teil der Computer-Programme abgedruckt, und zwar
fast alle Mathematica-Programme und einige der C-Programme für den PC. Aus
Platzgründen können wir leider nicht alle Quellcodes drucken, aber alle Program-
me sind auf der beiliegenden Diskette vorhanden und können selbst ausgedruckt
werden. Die Namen der Mathematica-Programme sind durchgehend von der Form
name.m. Die PC-Versionen der C-Programme wurden mit Turbo C von Borland
kompiliert und sind als name.exe auf der beiliegenden Diskette vorhanden.
Einige der C-Programme kann man mit Tasten steuern, die auf dem Bildschirm in
der Zeile Befehle angezeigt werden. Der erste Buchstabe in dem erklärenden Wort
steuert den Algorithmus; so bedeutet exit, daß die Taste e das Programm beendet.
Alle Beispiele werden auch als Programme für UNIX oder LINUX auf der Diskette
mitgeliefert. Zusätzlich können sie, dann vielleicht in verbesserter Version, vom
FTP-Server des Institutes für Theoretische Physik der Universität Würzburg über
das Internet kopiert werden (siehe Anhang C). Die Verzeichnisse dort sind:
/pub/buch/cphys/dos/
/pub/buch/cphys/mathematica/
/pub/buch/cphys/unix/
/pub/Xgraphics/
Zusätzlich gibt es im World Wide Web Informationen zu den Programmen unter der
Adresse
http://www.physik.uni–wuerzburg.de/TP3/cphys.html
summe.c
#include <stdlib.h>
#include <time.h>
main()
{
float average(float *,int);
int i;
clock_t start,end;
float dataset[10000];
clrscr();
for (i=0;i<10000;i++) dataset[i]=random(1000)/1000.;
start=clock();
for(i=0;i<99;i++) average(dataset,10000);
printf( " average = %f\n",average(dataset,10000));
end=clock();
printf( " Zeit= %f sec %d ",(end–start)/CLK_TCK,CLK_TCK);
getch();
}
plot2:=Plot[Evaluate[fliste],{x,0.,1.},
Frame –> True,
FrameLabel–>{"t/T","phi/phi0"},
PlotStyle –> Thickness[0.001]]
liste=Table[phiscal[x,N[.999 Pi]],{x,0,.99,.01}]
fouliste:=Take[Abs[Fourier[liste]],15]
plot3:= (gr1 = ListPlot[fouliste,PlotRange–>{{0,15},{–1,8}},
Frame –> True,
PlotStyle –> PointSize[0.02],
FrameLabel–>{"s","Abs[b(s)]"},
DisplayFunction –> Identity] ;
Show[gr1, Graphics[Line[{{0,0},{0,15}}]],
DisplayFunction –> $DisplayFunction ] )
f=1/Sqrt[1–m Sin[psi]ˆ2]
g=Series[f,{m,0,10}]
tseries=4 Integrate[g,{psi,0,Pi/2}] /. m–>Sin[phi0/2]ˆ2
e=phidotˆ2/2–Cos[phi]
plot4:=ContourPlot[e,{phi,–Pi,Pi},{phidot,–3,3},
Contours–>{–.5,0,.5,1,1.5,2},
ContourShading–>False,PlotPoints–>100,
FrameLabel –> {"phi", "phidot"}]
plot2:=Plot[PDF[ChiSquareDistribution[7],x],{x,0,20}]
rule = NonlinearFit[daten,f[t],t,
{{a,1.1},{om,1.1},{phi,.1},{b,.2}}]
a0=a/.rule; b0=b/.rule; om0=om/.rule; phi0=phi/.rule;
chi2min = chi2/.rule
plot3:=ContourPlot[chi2/.{phi–>phi0,om–>om0},
{a,.4,1.3},{b,–.04,.2},
ContourShading–>False,
Contours–>{chi2min+grenze[.683],chi2min+grenze[.9]},
PlotPoints–>50,FrameLabel–>{"a","b"}]
plot4:=ContourPlot[chi2/.{phi–>phi0,a–>a0},
{om,.90,1.05},{b,0.0,.15},
ContourShading–>False,
Contours–>{chi2min+grenze[.683],chi2min+grenze[.9]},
PlotPoints–>50,FrameLabel–>{"om","b"}]
g[t_]= f[t]/.rule
step:=(daten2=N[Table[{t,g[t] + .4 Random[]–.2},
{t,0,3Pi,.3 Pi}]];
NonlinearFit[daten2,f[t],t,
{{a,a0},{om,om0},{phi,phi0},{b,b0}}] )
tab:= tab = Table[{chi2,a,b,om,phi}/.step,{100}]
abtab := Map[Take[#,{2,3}]&,tab]
plot5:= ListPlot[abtab,PlotRange–>{{.4,1.2},{–0.045,.2}},
AspectRatio –> 1, Frame –> True,
FrameLabel –>{"a","b"}, Axes –> None,
PlotStyle –> PointSize[0.01]]
Programme 277
#include <math.h>
#include <graphics.h>
#define q 200
#define maxy 200
#define SHIFT 150
main()
{
int ie, n, nalt, m, p;
double sigma, pi, e, polyalt, poly, polyneu;
int gdriver=DETECT,gmode;
initgraph(&gdriver,&gmode,"\\tc");
pi=acos(–1.);
outtextxy(250,400,"Befehl: exit");
for(p = 1; p < q; p++)
{
sigma = 2.0*pi*p/q;
nalt = 0;
for(ie = 0; ie < maxy+2 ; ie++)
{
e = 8.0*ie/maxy – 4.0 – 4.0/maxy ;
n = 0;
polyalt = 1.0; poly = 2.0*cos(sigma) – e;
if( polyalt*poly < 0.0 ) n++ ;
}; /* ie–Schleife */
if(kbhit()) {getch();break;}
}; /* p–Schleife */
getch(); closegraph();
}
c[k_,sigma_][factor_. z[arg_]]:=
factor*arg[[sigma,k]]*
sign[k,sigma,arg]*z[minus[k,sigma][arg]]
n[k_,sigma_][0]:= 0
n[k_,sigma_][factor_. z[arg_]]:= factor*arg[[sigma,k]]*z[arg]
scalarproduct[a_,0] := 0
scalarproduct[a_,b_ + c_]:=scalarproduct[a,b]+
scalarproduct[a,c]
scalarproduct[z[arg1_],factor_. z[arg2_]]:=
factor* If[arg1==arg2,1,0]
H[vector_] = Expand[
–t*Sum[cdagger[k,sigma][c[k+1,sigma][vector]] +
cdagger[k+1,sigma][c[k,sigma][vector]] ,
{k,sites},{sigma,2} ] +
u*Sum[n[k,1][n[k,2][vector]] ,{k,sites}] ]
Print[""];Print[" "]
Print[" Die Hamilton – Matrix wird berechnet. " ]
Print[""]
Print[" Die Dimension dieser Matrix ist ",end,
" x ",end,"."]
h = ( hlist = Table[H[z[index[[j]]]], {j, end}];
Table[ scalarproduct[ z[index[[i]]], hlist[[j]] ],
{i,end}, {j,end}] )
Print[""]
Print[" Die Energie – Eigenwerte",
" werden berechnet."]
zustand = Chop[Table[Flatten[
{x,Sort[Eigenvalues[h/.{t –> 1.,u –> x}]]}],
{x, 0., 6., .1}]]
Print[""];Print[" "]
Print[" Die folgenden Befehle sind moeglich: "]
Print[" "]
Print[" plot1 => Vielteilchen–Spektrum in",
" Abhaengigkeit von U/t "]
Print[" "]
Print[" plot2 => Doppelbesetzung im",
" Grundzustand als Funktion von U/t "]
Print[" "]
Print[" plot3 => Vergleich: exaktes Resultat",
" fuer N –> Unendlich"]
Print[" mit endlichem N, Energie pro",
" Platz im Grundzustand"]
plot1 := Show[
Table[ListPlot[Map[{#[[1]],#[[j]]}&,zustand],
Frame–>True,Axes–>None,
Programme 285
#include <stdlib.h>
#include <graphics.h>
#include <math.h>
int maxx,maxy;
main()
{
void kanal(double);
int gdriver=DETECT,gmode;
286 Anhang E
char ch,str[100];
double xit=0.4,rmin=.88,r;
int x,y=50,i,ir;
initgraph(&gdriver,&gmode,"\\tc");
maxx=getmaxx();
maxy=getmaxy();
setcolor(YELLOW);
settextstyle(1,0,1);
outtextxy(100,maxy–80,
" Logistische Abbildung x = 4 r x (1–x)");
settextstyle(0,0,1);
outtextxy(50,maxy–30,
" Befehle : tief,hoch,clearscreen,print r,kanal,exit ");
setviewport(1,1,maxx,maxy–100,1);
r=1.–(1.–rmin)*y/(maxy–100);
while(1)
{
xit=4.*r*xit*(1.–xit);
x=xit*maxx;
putpixel(x,y,WHITE);
if(kbhit())
{
switch(getch())
{ case ’t’: if(y<(maxy–100)) y+=1;break;
case ’h’: if(y>1) y–=1;break;
default : getch();break;
case ’e’: closegraph(); exit(1);
case ’k’: kanal(r);break;
case ’p’: sprintf(str," r= %lf",r);
outtextxy(1,y,str);
break;
case ’c’: clearviewport();break;
} /* switch */
r=1.–(1.–rmin)*y/(maxy–100);
for(i=0;i<100;i++) xit=4.*r*xit*(1.–xit);
} /* if */
}/* while */
}/* main */
line(0,maxy–100,maxx,maxy–100);
while(!kbhit())
{ xit=4.*r*xit*(1.–xit);
x=xit*maxx;
y[x]++;
putpixel(x,maxy–100–y[x],WHITE);
}
getch();getch();clearviewport();return;
}
logabb.m
Print [" Logistische Abbildung"]
f[x_]=4 r x(1–x)
iterf[n_]:=Nest[f,x,n]
plot1:=Plot[Evaluate[{x,f[x],iterf[2],iterf[4]}/.r–>.87],
{x,0,1}, Frame –> True,
PlotStyle –> {{Thickness[0.002],GrayLevel[0]},
{Thickness[0.002],
Dashing[{0.003,0.003}]},
{Thickness[0.002],GrayLevel[.6]},
{Thickness[0.002],GrayLevel[0]}},
FrameLabel –> {"x","f[f[f[f[x]]]]"} ]
nf[x_,r_]=N[f[x]]
list1[r_,n_]:=NestList[nf[#,r]&,.65,n]
plot2:= (liste=list1[.87,40];
g1=ListPlot[liste,PlotStyle –> PointSize[0.02],
DisplayFunction –> Identity ];
g2=ListPlot[liste,PlotJoined–>True,
PlotStyle –> {Thickness[0.002],GrayLevel[.7]},
FrameLabel –> {"n","x(n)"},
DisplayFunction –> Identity ];
Show[g2, g1, Frame –> True,
DisplayFunction –> $DisplayFunction] )
plot3[r_:0.87464]:=(g1=Plot[nf[x,r],{x,0,1},
DisplayFunction –> Identity];
xx=Nest[nf[#,r]&,0.3,500];
li1=NestList[{nf[#[[1]],r],nf[#[[2]],r]}&,
{xx,nf[xx,r]},1000];
li2 = Flatten[Map[{{#[[1]],#[[2]]},
{#[[2]],#[[2]]}}&,li1],1];
li3=Flatten[Map[{{#[[1]],#[[2]]}}&,li1],1];
g2=ListPlot[li3,PlotRange –> {{0,1},{0,1}},
PlotStyle –> PointSize[0.015],
DisplayFunction –> Identity ];
288 Anhang E
#include <math.h>
#include <stdlib.h>
#include <graphics.h>
main()
{
int gdriver=DETECT,gmode;
int xb,yb,color=WHITE,maxx,maxy;
long nsum=0;
double k=1.,sig=.4,p=0.,x=0.,pi=M_PI,xneu,
pneu,h=0.,wind=0.,xalt,palt;
char ch,str[1000];
initgraph(&gdriver,&gmode,"\\tc");
maxx=getmaxx();
maxy=getmaxy();
outtextxy(100,maxy–70," Frenkel–Kontorova–Modell");
outtextxy(300,maxy–70," Befehle: neu, print, exit");
xalt=x; palt=p;
while(1)
{
pneu=p+k/2./pi*sin(2.*pi*x);
xneu=pneu+x;
xb=fmod(xneu+100.,1.)*maxx;
yb=(1.–fmod(pneu+100.,1.))*(maxy–100);
putpixel(xb,yb,color);
wind+=xneu–x;
x=xneu; p=pneu;
h+=k/4./pi/pi*(1.–cos(2.*pi*x))+(p–sig)*(p–sig)/2.;
nsum++;
if(kbhit())
{ switch(getch())
{case ’e’ : closegraph(); exit(1);
case ’n’ : x=xalt=(double) rand()/RAND_MAX;
p=palt=(double) rand()/RAND_MAX;
color=random(getmaxcolor())+1;
h=0.;wind=0;nsum=0;break;
case ’p’ :
sprintf(str,
" Energie= %lf Windungszahl= %lf (x,p)= %lf,%lf",
290 Anhang E
h/nsum,wind/nsum,xalt,palt);
setviewport(10,maxy–50,maxx,maxy,1);
clearviewport();
outtextxy(1,1,str);
setviewport(1,1,maxx,maxy,1); break;
default : getch();break;
}/* switch */
}/* if */
}/* while */
}/* main */
frenkel.m
Print[" Frenkel– Kontorova– Modell"]
pi = N[Pi]
k=1.
sigma=.4
nmax=1000
t[{x_,p_}] = {x + p + k/(2 pi) Sin[2 pi x],
p + k/(2 pi) Sin[2 pi x] }
list[x0_,p0_]:= NestList[t,{x0,p0},nmax]
xlist[x0_,p0_]:= Map[First,list[x0,p0]]
tilde[{x_,p_}]:= {Mod[x,1],Mod[p,1]}
listt[x0_,p0_]:= Map[tilde,list[x0,p0]]
plot1[x0_:.06,p0_:.34]:= ListPlot[listt[x0,p0],
Frame –> True, Axes –> None,
FrameLabel–>{"x","p"},
RotateLabel –> False,
PlotStyle –> PointSize[0.00]]
plot2[x0_:.06,p0_:.34]:=
(xl=Map[First, NestList[t,{x0,p0},10]];
tab=Table[{xl[[m]],k/(2 pi)ˆ2*(1–Cos[2 pi xl[[m]]])},
{m,11}];
p1=ListPlot[tab, PlotStyle –> PointSize[0.03],
DisplayFunction–>Identity];
p2=Plot[k/(2 pi)ˆ2*(1–Cos[2 pi x]),
{x,xl[[1]],xl[[11]]},
DisplayFunction–>Identity];
Show[p1,p2,DisplayFunction–>$DisplayFunction,
Frame –> True] )
plot3[x0_:.06,p0_:.34]:=
(xl=Map[First, NestList[t, {x0,p0}, 99]];
ListPlot[Mod[xl,1],
Frame –> True,FrameLabel–>{"n","x(n)"},
PlotStyle –> PointSize[0.013] ])
Programme 291
#include <graphics.h>
#include <stdlib.h>
#include <math.h>
main()
{
int gdriver=DETECT,gmode;
struct {int x;int y;} pt={10,10},pw,
p[3]={{1,1},{500,30},{200,300}};
initgraph(&gdriver,&gmode,"\\tc");
while(!kbhit())
{
pw=p[random(3)];
pt.x=(pw.x+pt.x)/2;
pt.y=(pw.y+pt.y)/2;
putpixel(pt.x,pt.y,WHITE);
}
getch();getch();
closegraph();
}
292 Anhang E
sierp.m
Print[ "Erzeugt und plotted einen Sierpinsky gasket "]
list={{{0.,0.},{.5,N[Sqrt[3/4]]},{1.,0.}}}
verv[d_]:=Block[ {d1,d2,d3},
d1={d[[1]],(d[[2]]+d[[1]])*.5,(d[[3]]+d[[1]])*.5};
d2=d1+Table[(d1[[3]]–d1[[1]]),{3}];
d3=d1+Table[(d1[[2]]–d1[[1]]),{3}];
{d1,d2,d3} ]
plot1:= Block[{listzw,plotlist},
listzw=Map[verv,list];
list=Flatten[listzw,1];
plotlist=Map[Polygon,list];
Show[Graphics[plotlist],
AspectRatio –> Automatic]]
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#define N 10
#define N2 20
float runs=0,correct=0;
if(argc==1){
printf(" Welche Eingabedatei ? ");
scanf("%s",str);
}
else strcpy(str,argv[1]);
if((fp=fopen(str,"r"))==NULL)
{ printf(" Datei nicht vorhanden ! ");exit(1); }
Programme 293
tmax = 200
dt = 0.1
phi0 = Pi/2
p0 = 0
r = 0.05
phase:=RungeKutta[{D[hamilton,p],–D[hamilton,q]},
{q, p}, {phi0,p0}, {10,dt}]
plot1:=ListPlot[phase,PlotJoined–>True,Frame –> True,
AspectRatio–>Automatic,
FrameLabel –> {"q","p"},
RotateLabel –> False,
PlotRange –> {{–2.3,2.3},{–1.85,1.85}}]
phase2:=RungeKutta[{p,–Sin[q]–r p},
{q,p},{phi0,p0},{tmax,dt}]
plot2:= ListPlot[phase2,PlotJoined–>True, PlotRange –> All,
AspectRatio–>Automatic,Frame –> True,
FrameLabel –> {"q","p"},
RotateLabel –> False,
PlotStyle –> Thickness[0.003] ]
phase3:= Euler[{D[hamilton, p], –D[hamilton, q]},
{q, p}, {phi0, p0}, {10, dt}]
plot3:= ListPlot[phase3,PlotJoined –> True, Frame –> True,
AspectRatio –> Automatic,
FrameLabel –> {"q","p"},
RotateLabel –> False,
PlotRange –> {{–2.3,2.3},{–1.85,1.85}}]
double dt=.1,r=.25,a=.5,pi,ysc=5.;
int poincare=0,done=0;
Programme 295
int maxx,maxy,xbild,ybild;
void print(),derivs(double,double*,double*),event(double*);
main()
{
int gdriver=DETECT,gmode;
int i,nok,nbad,xalt,yalt,xneu,yneu;
double y[3],f[3],t=0.,eps=1e–08;
initgraph(&gdriver,&gmode,"\\tc");
maxx=getmaxx();
maxy=getmaxy();
xbild=maxx–20;
ybild=maxy–110;
pi=acos(–1.);
y[1]=pi/2.;
y[2]=0.;
print();
while(done==0)
{
if(kbhit()) event(y);
if(poincare==1)
{
odeint(y,2,t,t+3.*pi,eps,dt,0.,&nok,&nbad,derivs,rkqc);
xalt=fmod(y[1]/2./pi +100.5,1.)*xbild;
yalt=y[2]/ysc*ybild/2+ybild/2;
rectangle(xalt,yalt,xalt+1,yalt+1);
t=t+3.*pi;
}
else
{
xalt=fmod(y[1]/2./pi +100.5,1.)*xbild;
yalt=y[2]/ysc*ybild/2+ybild/2;
odeint(y,2,t,t+dt,eps,dt,0.,&nok,&nbad,derivs,rkqc);
xneu=fmod(y[1]/2./pi +100.5,1.)*xbild;
yneu=y[2]/ysc*ybild/2+ybild/2;
if(abs(xneu–xalt)<xbild/2) line(xalt,yalt,xneu,yneu);
t=t+dt;
}
}
closegraph();
}
296 Anhang E
void print(void)
{
char string[100];
setviewport(1,1,maxx,maxy,1);
clearviewport();
settextstyle(1,0,1);
outtextxy(20,ybild+20,"Getriebenes Pendel");
settextstyle(0,0,1);
outtextxy(10,ybild+70,
"Befehle:exit,hoch(a),tief(a),start,a einlesen"
",+,–,umschalten,clear,beliebig");
rectangle(9,9,xbild+11,ybild+11);
sprintf(string,"a=%lf, r=%lf" ,a,r);
if(poincare==1)
sprintf(&string[strlen(string)]," – Poincare");
outtextxy(220,ybild+40,string);
setviewport(10,10,xbild+10,ybild+10,1);
}
Programme 297
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
double e=.5,a=0.1;
main()
{
void bild(void), print( double,double,double );
double k(double),
step(double *x,double dx,double*y,double*ym1);
int gdriver=DETECT,gmode;
int xb,ybneu,ybalt;
double dx=10./500.,y,ym1,yp1,destart=.05,de=.05,x,xp1,xm1 ;
initgraph(&gdriver,&gmode,"\\tc");
bild();
while(1)
{
x=dx/2.;y=ym1=1.;ybalt=1;
for(xb=1;xb<500;xb++)
{
yp1=step(&x,dx,&y,&ym1);
ybneu=(1.–yp1)*120;
if(abs(ybneu)>10000) break;
line(xb–1,ybalt,xb,ybneu);
ybalt=ybneu;
}
switch (getch())
{case ’e’: closegraph();exit(1);
case ’c’: print(e,de,dx);break;
default : getch();break;
case ’+’: e=e+de;print(e,de,dx);break;
case ’–’: e=e–de;print(e,de,dx);break;
case ’s’: de=destart;print(e,de,dx);break;
case ’k’: de=de/10.;print(e,de,dx);break;
case ’d’: dx=dx/2.;print(e,de,dx);break;
}/* switch */
}/* while */
}/* main */
298 Anhang E
for(i=1;i<=n;i++)
{
xp1=x+dx;xm1=x–dx;
yp1=(2.*(1.–5./12.*dx*dx*k(x))*y
–(1.+dx*dx/12.*k(xm1))*ym1)/
(1.+dx*dx/12.*k(xp1));
xm1=x;x=xp1;
ym1=y;y=yp1;
}
*xa=x;*ya=y;*ym1a=ym1;
return yp1;
}
void bild()
{
settextstyle (1,0,1);
setlinestyle(0,0,3);
rectangle(9,9,511,311);
outtextxy(30,350," Schroedinger–Gleichung ");
settextstyle (0,0,1);
outtextxy(20,390,
"Befehle : exit,klein(de),+(e),–(e),start(de),dx/2,"
"clear screen");
setlinestyle(0,0,1);
setviewport(10,10,510,310,1);
}
Programme 299
double k(double x)
{ return (–pow(x,2)–2.*a*pow(x,4)+2.*e); }
Plot[uu[x],{x,–10.,10.},PlotRange–>All,
Frame –> True, Axes –> None,
PlotStyle –> Thickness[0.002],
FrameLabel –>{"x",zs}] )
u2[x_,t_]=–12(3+4Cosh[2x–8t]+Cosh[4x–64t])/
(3Cosh[x–28t]+Cosh[3x–36t])ˆ2
plot4:=Plot3D[u2[x,t],{t,–.2,.2},{x,–5,5},PlotPoints–>50,
PlotRange –> {–10,0},
Shading –> False,
MeshStyle –> Thickness[0],
AxesEdge –> {Automatic,Automatic,{–1,1}},
ViewPoint –> {–1.78095, –2.06202, 2.5},
DefaultFont –>{"Times–Roman",16},
AxesLabel –> {"t","x","u"}]
plot5:=ContourPlot[–u2[x,t],{t,–1,1},{x,–10,10},
PlotPoints–>100,
ContourShading–>False,
PlotRange –> All,
ContourSmoothing –> 4,
FrameLabel –> {"t","x"},
RotateLabel –> False,
Contours –> {0.1,0.6,1.1,1.6,2.6,4.0,5.6}]
plot6[tt_:0.3]:= (uprime[x_]=D[u2[x,tt],x]; x=–10.0;
exactlist={{x,u2[x,tt]}}; d=0.07; upl=uprime[x]ˆ2;
While[x<10., upr=uprime[x+d]ˆ2;
d = 0.07/Sqrt[1+Max[upl,upr]];
x = x+d; AppendTo[exactlist,{x,u2[x,tt]}];
upl=upr ];
ListPlot[exactlist, PlotRange –> All,
PlotStyle –> PointSize[0.002],
Frame –> True, Axes –> None] )
plot1:=Show[Graphics3D[{PointSize[0.004],
Map[Point,unitvectors]}],
ViewPoint –> {2,3,2}]
v0 = {276., 164., 442.}/m (* vector closest to {0,0,0} *)
(* b1,b2,b3 span primitive cell *)
b1 = {–113., 172., 7.}/m
b2 = {173., 113., –172.}/m
b3 = {345., 120., 570.}/m
vp = m*(9*b1+4*b2)+{0,0,100}
plot2 := Show[Graphics3D[{PointSize[0.004],
Map[Point,tripel]}],
ViewPoint –> vp]
uni = Table[Random[],{m+2}];
tri = Table[Take[uni,{n,n+2}],{n,m}]
univec = Map[(#/Sqrt[#.#])&,tri]
plot3:=Show[Graphics3D[{PointSize[0.004],
Map[Point,univec]}],
ViewPoint–>{2,3,2}]
mzran.c
/***** Zufallszahlen *****/
#define N 1000000
unsigned long x=521288629, y=362436069, z=16163801,
c=1, n=1131199209;
unsigned long mzran()
{ unsigned long s;
if(y>x+c) {s=y–(x+c); c=0;}
else {s=y–(x+c)–18; c=1;}
x=y; y=z; z=s; n=69069*n+1013904243;
return (z+n);
}
main()
{
double r=0.;
long i;
for (i=0;i<N; i++)
r+=mzran()/4294967296.;
printf ("r= %lf \n",r/(double)N);
}
302 Anhang E
#include <graphics.h>
#include <stdlib.h>
#include <math.h>
char xf[lmax][lmax] ;
int rx,ry,maxx,maxy;
double rmax=1.,pi;
void main ()
{
void besetze(),huepfe(),aggregate(),kreissprung();
char pruefe();
int driver=DETECT,mode;
int i,j;
besetze();
huepfe();
while(1)
{
switch(pruefe())
{
case ’v’:besetze();huepfe();break;
case ’a’:aggregate();besetze();huepfe();break;
case ’h’:huepfe();break;
case ’k’:kreissprung();break;
Programme 303
}
if (kbhit())
switch(getch())
{ case ’e’: closegraph();exit(1);
default : getch();break;}
}/* while */
}/* main */
void huepfe()
{
switch(random(4))
{
case 0: rx+=1;break;
case 1: rx+=–1;break;
case 2: ry+=1;break;
case 3: ry+=–1;break;
}
}
void aggregate()
{
double x,y;
xf[rx+lmax/2][ry+lmax/2]=1;
x=rx;y=ry;
rmax= max(rmax,sqrt(x*x+y*y));
if(rmax>lmax/2.–5.) {printf("\7");getch();exit(1);}
circle(4*rx+maxx/2,4*ry+maxy/2,2);
}
void besetze()
{
double phi;
phi=(double)rand()/RAND_MAX*2.*pi;
rx=rs*sin(phi);
ry=rs*cos(phi);
}
void kreissprung()
{
double r,x,y,phi;
phi=(double)rand()/RAND_MAX*2.*pi;
x=rx; y=ry; r=sqrt(x*x+y*y);
rx+=(r–rs)*sin(phi);
ry+=(r–rs)*cos(phi);
}
304 Anhang E
char pruefe()
{
double r,x,y;
x=rx;
y=ry;
r=sqrt(x*x+y*y);
if(r>rkill) return ’v’;
if(r>=rd) return ’k’;
if(xf[rx+1+lmax/2][ry+lmax/2]
+xf[rx–1+lmax/2][ry+lmax/2]
+xf[rx+lmax/2][ry+1+lmax/2]
+xf[rx+lmax/2][ry–1+lmax/2]>0) return ’a’;
else return ’h’;
}
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
main()
{
int gdriver=DETECT,gmode;
double p=.59275;
int i,j,pr,L=700;
pr=p*RAND_MAX;
initgraph(&gdriver,&gmode,"\\tc");
for(i=0;i<L;i++)
for(j=0;j<L;j++)
if(rand()<pr) putpixel(i,j,WHITE);
getch();
closegraph();
}
#include <time.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#define L 20
#define VSEG 0xb800
int s[L+2][L+2],bf[3],done=0;
double temp;
main()
{
void setT(double);
void event(void);
void rahmen(int , int);
char ch;
int mcs,x,y,e,v;
clock_t start,end;
clrscr();
randomize();
mcs=0;
gotoxy(50,1);
printf("ISING–Ferromagnet ");
gotoxy(50,2);
printf("Monte–Carlo–Simulation");
gotoxy(50,3);
printf("Systemgroesse %d * %d",L,L);
gotoxy(1,25);
printf(
" Befehle: t(iefer),h(oeher),s(prung),e(xit),beliebig");
rahmen(2*L+3,L+2);
while(!done)
{
event();
for(x=1;x<L+1;x++) for(y=1;y<L+1;y++)
{
e=s[x][y]*(s[x–1][y]+s[x+1][y]+s[x][y–1]+s[x][y+1]);
if( e<0 || rand()<bf[e/2] )
{
s[x][y]=–s[x][y];
v=2*(x*80+2*(y–1)+2);
ch=(s[x][y]+1)*15;
poke(VSEG,v,0xf00|ch);
}
}
for(x=1;x<L+1;x++)
{
s[0][x] =s[L][x];
s[L+1][x]=s[1][x];
s[x][0] =s[x][L];
s[x][L+1]=s[x][1];
}
void event()
{
char ch;
if(!kbhit()) return;
ch=getch();
switch(ch)
{ case ’h’:setT(temp+=.05);break;
case ’t’:setT(temp–=.05);break;
Programme 307
W
U Wachstumsalgorithmus 196, 198
Überdeckung 136 Wachstumsprozeß 180, 195
Übergangswahrscheinlichkeit 204, 211, Wahrscheinlichkeit 47, 160
214, 217, 223 Wahrscheinlichkeitsdichte 181
Überholvorgang 151, 157 Wärme, spezifische 213, 220
Überlagerung 51, 67, 164 Wärmegleichgewicht 210
unendliche 161 Wechselspannung 56
Universalität 89, 189, 191, 213 Wechselstrom 56
Sach- und Namenverzeichnis 317
Wechselwirkung Zuordnung 59
attraktive 202 Zustand 103
magnetische 190 fastperiodischer 107
Wechselwirkungspotential 102 inkommensurabler 107, 110
Wegintegral 39 kommensurabler 104, 107
Weglänge, skalierte 230 stabiler 102
Welle, stehende 161 stationärer 51, 144, 161, 212
Wellenfunktion 51, 70, 74, 78, 144, 148, Zustandsgleichung 41
160, 163, 166 Zustandssumme 210
Wellenpaket 151, 161, 168, 170 Zweierzyklus 91
Gaußsches 167 Zwei-Personen-Nullsummen-Spiel 46, 49
lokalisiertes 159 Zweiphasengemisch 43
numerisch integriertes 171 Zwei-Soliton-Lösung 158
Wert, irrationaler 71 Zyklus 97, 141
while 95, 123, 139, 251
Widerstand, komplexer 56, 57
Wiederkehrzeit 159
Wilson, K. G. 213
Windungszahl 104, 107, 109
rationale 107
Witten, T. A. und Sander, L. M. 182
WorkingPrecision 94
Z
Zahl, irrationale 71, 76, 104
Zeiger 5, 252, 257
Zeit, charakteristische 168
Zeitableitung 155
Zeitentwicklung 164, 169
quantenmechanische 160
Zeitentwicklungsoperator 164
Zeitmittel 63
Zeitreihe 121
Zeitskala 168, 219
Zufallsbewegung 112, 180
Zufallsvektor 112
Zufallsweg 182, 201, 202
Zufallszahl 4, 23, 49, 113, 124, 173, 207,
226
gleichverteilte 179, 207, 215
normalverteilte 32
Zufallszahlengenerator 179, 218