La boı̂te à outils

de la
PHYSIQUE NUMÉRIQUE
Licence de physique L3 PHYTEM
Master de physique et applications M1 PF
Université Pierre et Marie Curie Paris-6 — ENS-Cachan

Ph. Depondt 1

Année 2014-2015

0.0025
0.0025
0.002
0.002
0.0015
0.0015
0.001
0.001
0.0005
0.0005
01
0
0.9
0.8
0.7
0.6
X2 0.5
0.4
0.3
0.2
0.1
0 0.4 0.5 0.6 0.7 0.8 0.9 1
0 0.1 0.2 0.3
X1

1. INSP (Institut des NanoSciences de Paris), CNRS UMR 7588 & Université P. et M. Curie Paris-6. Con-
tact : depondt@insp.jussieu.fr
2 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Table des matières

1 Introduction 7
1.1 Des méthodes numériques, pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.1 Quelques jalons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.2 . . . et quelques exemples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Plan succinct. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2 Notions pratiques de FORTRAN95. 15

2.1 Qu’est-ce qu’un langage de programmation ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Notions élémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 Instructions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.2 Déclarations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.3 Opérations élémentaires sur les nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Premières boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.2 Pratiquement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.3 Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.4 Boucles munies d’un nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Conditions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5 Entrées-sorties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.1 Écran et clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.2 Les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.3 Les formats. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6 Les fonctions intrinsèques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7 Autres boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.1 do while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.2 Boucles infinies : exit et cycle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.3 Boucles implicites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8 Tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8.2 Manipulation globale de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.8.3 Fonctions intrinsèques et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.8.4 Allocation dynamique de mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9 Fonctions et sous-programmes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.9.1 Les function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.9.2 Et les subroutine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.3 L’intention . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.4 La mise en commun de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.5 Mettre un nom de sous-programme comme argument. . . . . . . . . . . . . . . . . . . . . . . . 32
2.9.6 Les bibliothèques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.10 Les commentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.11 Une instruction sur plusieurs lignes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12 Les chaı̂nes de caractères. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12.2 Opérations sur les chaı̂nes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12.3 Conversion chaı̂ne ⇔ nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.13 Détection de fin de fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.14 FORTRAN77-90-95 : filiation et différences. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.14.1 kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.14.2 Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.14.3 Objets de type dérivé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.14.4 Pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3
4 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

2.14.5 Récursivité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3 Un prototype de TP 41
3.1 Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2 La lentille demi-boule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.1 Préliminaires analytiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.2 Écriture d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.2.3 Premiers résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.2.4 Tracé des rayons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.2.5 Au-delà de la réflexion totale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

4 Méthodes numériques. 45
4.1 Recherche des zéros d’une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.1.1 Méthode de la dichotomie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.1.2 Méthode de Newton. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.1.3 Comment s’y prendre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2 Représentation des nombres dans un ordinateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2.1 Les nombres entiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2.2 Les nombres réels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2.3 Conséquence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3 Suites et séries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3.1 Généralités et premières difficultés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3.2 Calcul des intégrales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.4 Échantillonnages, interpolation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.4.1 Interpolation linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.2 Approximation parabolique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.3 Polynômes de Lagrange. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.4 Dérivées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.5 Algèbre linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.5.1 Un exemple : la diffusion de la chaleur à une dimension. . . . . . . . . . . . . . . . . . . . . . . 55
4.5.2 Systèmes d’équations linéaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5.3 Une généralisation de la méthode de Newton à plusieurs dimensions. . . . . . . . . . . . . . . . 58
4.5.4 Problèmes de vecteurs propres et de valeurs propres ou eigenproblems. . . . . . . . . . . . . . . 59
4.6 Problèmes autocohérents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.1 Qu’est-ce donc ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.2 Formulation générale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.3 Est-ce que ça converge ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.7 Recherche des minima d’une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.7.1 Du mouvement des amibes (méthode du simplex). . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.7.2 Méthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.7.3 Recherche à une dimension : interpolation parabolique. . . . . . . . . . . . . . . . . . . . . . . 63
4.7.4 Méthode du gradient conjugué. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.7.5 Minimisation avec contrainte : les multiplicateurs de Lagrange. . . . . . . . . . . . . . . . . . . 65
4.8 Modélisation de données expérimentales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.8.1 Données et moindres carrés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.8.2 Ajustement d’une fonction linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.8.3 Ajustement d’un polynôme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.8.4 Dérivée locale d’une courbe expérimentale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.8.5 Lissage : a dirty trick ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.8.6 Ajustement non-linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.9 Systèmes d’équations différentielles ordinaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.9.1 Un exemple : les lignes de champ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.9.2 La méthode d’Euler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.9.3 La méthode d’Euler ≪ améliorée ≫ ou méthode de Heun. . . . . . . . . . . . . . . . . . . . . . 72
4.9.4 La méthode de Runge-Kutta d’ordre 4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.9.5 La méthode de Cranck et Nicholson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.9.6 Équations d’ordre supérieur à 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.9.7 Méthode de Verlet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.9.8 Le problème du pas d’intégration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.9.9 Quelle méthode choisir ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.10 Transformées de Fourier rapides. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.10.1 La transformée de Fourier en physique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.10.2 La transformée de Fourier discrète. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Physique numérique, Philippe Depondt 5

4.10.3 Filtrage de données expérimentales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

4.11 Les méthodes de Monte-Carlo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11.1 Processus stochastiques et chaı̂nes de Markov. . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11.2 Les vicissitudes de π. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11.3 La production de nombres ≪ aléatoires ≫. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.11.4 Obtenir une distribution autre qu’uniforme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.11.5 Intégration multidimensionnelle sur des domaines compliqués. . . . . . . . . . . . . . . . . . . . 89
4.11.6 Simulation de Monte-Carlo-Metropolis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.11.7 Recherche du minimum d’une fonction : le recuit simulé. . . . . . . . . . . . . . . . . . . . . . . 94
4.12 Le tri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

5 Introduction à la simulation numérique 97

5.1 Pourquoi la Simulation numérique ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2 La matière considérée comme un milieu continu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2.1 Quels types de questions se pose-t-on ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2.2 La méthode des différences finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.2.3 Les méthodes spectrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
5.2.4 Introduction aux éléments finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.3 La matière comme une collection de particules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.3.1 Matrice dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.3.2 Simulations Monte-Carlo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
5.3.3 Simulations de dynamique moléculaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.3.4 Simulations ab-initio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

6 Optimisation de code. 115

6.1 Éviter les calculs inutiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.2 Utiliser les symétries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.3 Stocker des résultats intermédiaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.4 Utilisation des caches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.5 Eviter les interruptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
6.6 Ne pas réinventer ce qui existe déjà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

7 Calculs très lourds : vectorisation et parallélisation 119

7.1 L’architecture vectorielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2 Parallèlisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2.1 Mémoire partagée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
7.2.2 Mémoire distribuée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

8 Quelques éléments de C++ 121

8.1 Avant même de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.2 Déclarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3 Structures de base diverses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3.1 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3.2 Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3.3 Sauvegardes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4.1 Tableaux de taille fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4.2 Les pointeurs : premiers pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.4.3 Tableaux dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.5 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.1 Une fonction très simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.2 Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.3 Passage d’arguments par valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.4 Passage d’arguments par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.6 Les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

9 La question du calcul formel. 127

9.1 Calcul formel, calcul numérique : quelle différence ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2.1 ax + b = 0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2.2 Le gaz de Van der Waals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
9.2.3 Modèle de Brillouin-Weiss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
9.2.4 Le projectile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.2.5 Une ≪ grosse ≫ simulation : les anneaux de Saturne. . . . . . . . . . . . . . . . . . . . . . . . . 131
6 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

9.3 Que peut-on en conclure ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

10 Bibliographie. 135
Chapitre 1
Introduction
≪ Si vous pensez que le calcul numérique, c’est l’af-
faire des autres, c’est qu’il est temps de vous recycler ≫ :
cette affirmation péremptoire, et volontairement provoca-
trice 1 , est à comprendre dans un contexte où le CEA,
le CNRS, la Communauté Européene et les grands in-
dustriels s’équipent résolument de moyens de calcul tou-
jours plus considérables. Le sigle HPC (High Performance
Computing) jaillit un peu partout. . . On parle volon-
tier, et le plus sérieusement du monde, de PetaFlops 2
(sans forcément toujours très bien comprendre de quoi il
s’agit. . .). C’est sans doute que l’enjeu en paraı̂t important
aux décideurs (et aux payeurs) à la fois pour la recherche
scientifique et pour la recherche et développement (R
& D) industriel. Les demandeurs de ce genre de calculs
lourds voire très lourds sont divers ; par exemple et dans
le désordre :
– La météorologie est l’un des utilisateurs civils les
plus importants : les prévisions au quotidien bien
sûr, mais aussi les recherches sur le réchauffement
climatique, essayer d’en prévoir les conséquences,
voire trouver des remèdes requièrent des simulations
très élaborées des mouvements atmosphériques et des
échanges chimiques et énergétiques.
– La matière condensée, les matériaux et les
nanosciences en physique et en chimie offrent
une variété incroyable de problèmes mettant en jeu
un grand nombre (entre quelques dizaines et le nom-
bre d’Avogadro !) d’atomes : des calculs classiques ou
quantiques, parfois assez simples, parfois très lourds,
sont mis en œuvre pour tenter de comprendre ou de
prédire leurs propriétés.
– Les sciences de la vie se préoccupent, au niveau micro-
scopique, de molécules énormes, extraordinairement
complexes. Des efforts considérables sont faits pour
tenter de modéliser ces objets, avec des enjeux impor-
tants : repliement de proteines, conséquences pour la
maladie d’Alzheimer ou celle de Parkinson, drug de-
sign, etc. La génomique, de son côté, doit utiliser des
bases de données colossales en utilisant des méthodes
qui doivent être efficaces et n’ont rien de trivial.
– Les sciences de l’ingénieur sont aussi très deman-
deuses. Les simulations aérodynamiques permettent
de prévoir et d’optimiser les caractèristiques d’un
avion avant même son premier vol ; un industriel
comme EDF développe des calculs souvent très lourds
dans des domaines d’une grande diversité : simula-
1. faite par un professeur de mathématiques à l’UPMC en intro-
duction à un colloque intitulé Penser PetaFlops en mai 2008.
2. 1015 floating point operations per second. La première machine
≪ pétaflopique ≫ a fonctionné au printemps 2008. L’étape suivante
est l’ExaFlops : 1018 flops. . .
7
tion d’irradiation de matériaux divers ou régulation
de la distribution d’électricité ; les fabriquants de tur-
bines qui cherchent à optimiser leur fonctionnement
simulent les phénomènes très complexes liés aux in-
stabilités dans les chambres de combustion.
Il n’y a guère de domaine qui échappe : même la finance
recrute des scientifiques capables de modéliser sur ordina-
teur ! Un(e) physicien(e) de formation, que ce soit dans un
environnement recherche ou industriel peut difficilement
ignorer ce domaine dont l’importance est de plus en plus
massive, même si il/elle n’est pas directement impliqué(e)
dans des calculs légers ou lourds.
L’évolution fulgurante de la capacité de calcul
disponible ne peut toutefois être utile et profitable que s’il
y a des personnes compétentes pour s’en servir de façon
pertinente et donc convenablement formées : il s’agit là
d’une double compétence à la fois scientifique dans la disci-
pline d’origine (physique, chimie, mathématiques, science
de la vie, etc.) et de simulation : ≪ Some jog along with the
technology while others lag behind 3 . . . ≫. Ce monde évolue
rapidement et le but de ce cours est de fournir les bases et
les démarches permettant de s’y repérer.
L’expérience tend à montrer que ce cours de Physique
numérique surprend parfois un peu ceux à qui il s’adresse.
Il commence, en effet, par de la programmation et quelques
notions d’Unix : serait-ce alors un ≪ cours d’info ≫, comme
on l’entend souvent appeler ? Très rapidement toutefois,
après quelques semaines, on ne parle plus, ou presque
plus, d’informatique ou de programmation : c’est sup-
posé acquis ; on parle de physique principalement, parfois
ornée d’un peu de mathématiques appliquées. En outre,
cette physique ne paraı̂t, parfois, guère familière à des
étudiants habitués à résoudre des problèmes dont la so-
lution analytique est connue : c’est qu’ici, justement, l’ob-
jectif est de résoudre des problèmes pour lesquels il n’y
a pas de solution analytique, c’est-à-dire l’immense ma-
jorité. . . L’informatique est alors pour nous un outil - qu’il
faut bien sûr maı̂triser - pour s’attaquer à des problèmes
de physiques variés. Le charme de cet enseignement, pour
les enseignants mais aussi souhaitons-le pour ceux qui le
reçoivent, une fois - répétons-le - l’outil acquis, est qu’il ne
se cantonne pas à tel ou tel domaine de la physique, mais
qu’il pioche ses exemples dans des champs aussi variés que
possible, dans des questions souvent très contemporaines,
avec des approches parfois inattendues.
Le présent polycopié déborde assez largement le strict
minimum nécessaire à la réussite à l’examen. . . c’est volon-
3. ≪ Certains accompagnent le peloton tandis que d’autres
traı̂nent derrière. ≫
8 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

taire : à chacun de sélectionner ce qui lui paraı̂t utile, les Un autre exemple, moins célèbre sans doute, est l’ensem-
séances de travaux dirigés et de travaux pratiques étant ble des opérations qui, pendant la Révolution Française,
de bons guides en la matière 4 . ont abouti à la définition du mètre, en remplacement
du maquis d’unités de l’Ancien Régime, par un système
uniforme et rationnel. On voulait que le mètre fût uni-
1.1 Des méthodes numériques, versel (on aurait certes put choisir comme référence les
unités en vigueur à Paris, mais l’idéal universaliste des
pour quoi faire ? révolutionnaires l’interdisait) et l’on choisit ainsi une
référence qui pût être commune à toute l’humanité : la dix-
À titre de provocation, on pourrait dire que l’objet de ce
millionième partie du quart du méridien terrestre. Encore
cours est de faire aussi peu d’informatique que possible. Il
fallait-il en mesurer la longueur. . . On envoya donc deux
s’agit plutôt d’utiliser les ressources fournies par les ordi-
mathématiciens-astronomes réputés pour leur précision
nateurs pour tenter de traiter des problèmes de physique
et le soin avec lequel ils menaient leurs observations
aussi variés que possible, afin, soit de se simplifier la vie
(Jean-Baptiste-Joseph Delambre (1749-1822) et Pierre-
et gagner du temps en faisant faire par un ordinateur des
François-André Méchain (1744-1804)) équipés des instru-
calculs fastidieux que l’on pourrait sans doute faire soi-
ments de visée les plus élaborés, mesurer entre Dunkerque
même, soit au contraire de s’attaquer à des questions que
et Barcelone la longueur de l’arc de méridien de Paris : en
l’on ne pourrait en aucun cas traiter avec une feuille de
déterminant très précisément la latitude des deux villes
papier et un crayon. . . Nous chercherons ainsi dans divers
(à partir de la hauteur de l’Étoile Polaire et de quelques
domaines de la physique des problèmes, de préférence peu
autres) on en déduirait aisément la longueur du méridien
susceptibles d’une solution analytique, afin de les traiter
complet.
numériquement à l’aide d’un calcul sur ordinateur, l’ob-
jectif étant d’apprendre comment aborder une question de Il fallait donc établir un réseau de triangles qui recou-
façon qu’un calcul permette d’y répondre de manière sat- vre complétement l’arc de méridien compris entre les deux
isfaisante, quitte à la reformuler au passage pour la faire villes, mesurer avec une précision méticuleuse les angles
entrer dans un cadre propice à ce genre de traitement. aux sommets de tous ces triangles afin d’en calculer la
longueur des côtés, puis par trigonométrie, la longueur
de l’arc. Cette épopée (racontée par Ken Alder dans The
1.1.1 Quelques jalons. . . measure of all things, Free Press (2002)) dura sept ans
(1792-1799) dans une France en proie à toutes sortes de
Il ne faut cependant pas croire que les calculs numé- violences (les invasions, les guerres révolutionnaires, la
riques aient attendu l’invention de l’ordinateur pour voir Terreur, Thermidor. . .) : dans les jours qui suivirent la
le jour. Au XVIIe siècle déjà, l’invention des logarithmes fuite de Louis XVI à Varennes, Delambre avec son at-
par John Napier (1550-1616) fut une révolution (Miri- tirail de longue-vues et d’instruments, et, pire encore,
fici logarithmorum canoni descriptio, Edimbourg (1614)) : son ordre de mission signé par le roi fugitif, fut arrêté
une multiplication se transformait en addition -beaucoup à plusieurs reprises comme ≪ espion ≫ ; un peu plus
plus aisée-, une extraction de racine carrée en division tard, Méchain resta bloqué en Catalogne quand l’Espagne
par deux ! L’astronome Johannes Kepler (1571-1630) qui bourbonnienne et la France républicaine se trouvèrent en
découvrit l’ellipticité des orbes planétaires, se livra à des guerre ; Méchain dut aussi lutter en permanence contre
calculs numériques vertigineux dans, par exemple, son œu- un état psychologique dépressif lié à son inquiétude quant
vre principale, l’Astronomie Nouvelle (Astronomia Nova, à la qualité de ses mesures. Les deux hommes revinrent
(1609) ). Ainsi, par exemple, pour évaluer les positions au enfin à Paris en 1799 pour présenter leurs résultats :
cours du temps d’une planète alors qu’elle parcourt ce qui une conférence internationale de mathématiciens devait :
n’est encore qu’un ≪ ovoı̈de ≫ avec une vitesse variable 5 , 1o vérifier et valider la cohérence de leurs observations, et
il divise la trajectoire en 360 petits segments et additionne 2o en déduire la longueur du mètre.
les résultats obtenus pour chaque segment : c’est ce que
l’on appelle maintenant une discrétisation. Kepler, lui, ap- Il fallait donc, pour la deuxième partie de ce tra-
pelait cela un ≪ morcellement numérique ≫ et se plaig- vail, faire des calculs de trigonométrie sur une surface
nait de ce que ce calcul fût ≪ mécanique et ennuyeux ≫ : sphérique. On savait cependant qu’outre les montagnes
comme son employeur, l’empereur Rudolf II., ne payait dont il fallait bien sûr tenir compte, la Terre n’était pas
son salaire qu’occasionnellement, il n’avait pas les moyens une sphère parfaite mais plutôt un ellipsoı̈de de révolution
d’employer lui-même un assistant pour l’aider. . . Il con- légèrement applati aux pôles : toutefois, le choix d’un arc
naissait d’ailleurs les tables de logarithmes de Napier et de méridien situé à des latitudes intermédiaires (le 45˚par-
en établit lui-même dans ses Tables Rodolphines (Tabulæ allèle passe à Bordeaux et donc coupe l’arc Dunkerque-
Rudolphinæ, (1627) ). Barcelone non loin de son milieu) permettait d’espérer
obtenir une valeur moyenne qui pût servir de référence.
4. Le chapitre 5, en particulier doit être considéré comme la suite On fit alors une découverte complétement inattendue :
logique du cours, mais n’en fait à proprement parler partie. le géoı̈de n’était pas régulier mais recouvert de bosses
5. Jusqu’alors, on croyait, Copernic, Tycho Brahe et Galilée y
et de creux. La valeur du rayon de courbure de la sur-
compris, que les mouvements planétaires étaient des mouvements
circulaires uniformes, ou des combinaisons de mouvements circulaires face terrestre dépendait de l’endroit où il était mesuré,
uniformes, ce qui permettait un calcul facile des positions planétaires or la précision magnifique des observations de Delambre
futures. Kepler, comme on le sait, introduisit, à cause d’un désaccord et Méchain, le soin méticuleux -voire obsessionnel dans
de 8 minutes d’angle dans la position de Mars, les orbes, d’abord
ovoı̈des puis elliptiques, parcourues à vitesse variable ; les prédictions
le cas de Méchain- avec lequel elles avaient été réalisées
en devenaient beaucoup plus difficiles : il fallut attendre Newton pour ne permettaient pas de mettre ce résultat sur le compte
voir la résolution de ce problème. d’erreurs ou d’imprécisions de mesure. Après de longues
Physique numérique, Philippe Depondt 9

Curseur transparent

Réglette

a b
Graduations logarithmiques
a.b
Figure 1.1 – La règle à calcul, héritière des tables de logarithmes de John Napier, en usage jusqu’à la fin des années
1970. La réglette pouvait coulisser dans une gorge aménagée dans la règle et le curseur pouvait glisser sur l’ensemble.
Pour faire le produit de deux nombres a et b (par exemple pour convertir des calories en joules), on déplaçait la réglette
de telle façon que son origine se trouve en face de la graduation a de la règle, puis on déplaçait le curseur jusqu’à la
graduation b de la réglette pour lire le résultat : comme les graduations étaient logarithmiques, on additionnait ainsi
deux logarithmes pour obtenir le produit de leurs arguments.

tergiversations, on finit néanmoins par fixer la valeur du
mètre à 443,296 lignes (une unité en vigueur à Paris alors)
et l’on fondit le fameux mètre-étalon en platine irridié du
pavillon de Breteuil.
Au-delà de l’histoire plus ou moins anecdotique, on
devine en arrière-plan les prodigieux calculs numériques
que les mathématiciens de la conférence ont dû faire
(outre les travaux de dégrossissage réalisés par Delambre
et Méchain : corrections pour l’altitude, la réfraction atmo-
sphèrique, la température, etc.) armés d’une plume pour
écrire et d’une table de logarithmes. Il ne se répartirent
même pas la tâche, car pour plus de sûreté, chaque par-
ticipant devait faire indépendamment l’intégralité des cal-
culs en utilisant ses propres méthodes ! On reste pantois
devant la dextérité et l’acharnement calculatoires que cela
représente. . .
Un peu plus tard, au XIXe siècle, Urbain Le Verrier
étudia les perturbations observées dans l’orbite d’Uranus
et postula l’existence d’une autre planète jusqu’alors in-
connue. Il calcula la position de cette planète et le di-
recteur de l’observatoire de Berlin, Johann Galle, vit
à l’endroit indiqué, le 23 septembre 1846, la nouvelle
planète, Neptune : un triomphe pour le valeureux cal-
culateur ! On imagine sans peine cependant l’énorme
labeur que représentèrent, pour Le Verrier, ces calculs,
entièrement faits à la main. . .
Cependant, l’idée d’automatiser des calculs ennuyeux
est ancienne. Le baron Gaspard de Prony était chargé
pendant le Premier Empire d’établir des tables pour le
calcul de l’impôt foncier : pour cela, il divisa le tra-
vail en trois grands blocs. La première partie, la plus
noble, était confiée à des mathématiciens : il s’agis-
sait de décomposer tous les calculs nécessaires en séries
d’opérations élémentaires. La deuxième tâche consistait à
organiser le travail et à compiler les résultats. La troisième,
faire les calculs réduits à des opérations très simples, fut
confiée à une armée de calculateurs humains dont la seule
qualification était d’être capable de faire des additions.
L’étape suivante fut franchie par Charles Babbage, un
gentleman philosopher britannique du début du XIXe
siècle qui eut l’idée d’associer cette décomposition des cal-
culs en tâches élémentaires avec une calculatrice du type
de celle de Pascal et un système de cartes perforées issu
des métiers à tisser Jacquard. Malheureusement, malgré
un financement public conséquent, et une ≪ communica-
tion ≫ - comme on dirait maintenant - efficace assurée
par Ada Byron 6 , les réalisations pratiques ne donnèrent
jamais satisfaction, à cause semble-t-il des frottements ex-
cessifs des mécanismes.
La première réalisation pratique de calculs massifs au-
tomatisés est due à Herman Hollerith qui inventa une ma-
chine pour traiter les données du recensement américain
de 1890 à l’aide de cartes perforées. Le résultat (62 622
250 habitants) fut obtenu en six semaines au lieu de sept
ans pour le recensement précédent. Fort de ce succès, Hol-
lerith fonda en 1896 la Tabulating Machine Company qui
changea de nom en 1924 pour devenir International Busi-
ness Machines : ibm. . . spécialisée dans la fabrication de
calculatrices mécaniques de bureau, parfois mûes par des
moteurs électriques, ou utilisant des cartes perforées.
Un effort de recherche important sur le calcul automa-
tique fut mené aux États-Unis pendant la deuxième guerre
mondiale poussé en grande partie par le Ballistic Research
Laboratory. Il fallait calculer les trajectoires des projectiles
tirés par divers armements afin de fournir des tables de
pointage aux artilleurs. Pour chaque nouvelle munition, il
fallait produire une nouvelle table. Une armée d’employés,
dotés de calculatrices mécaniques de bureau, faisait ces
calculs, mais à la fin de la guerre, était littéralement sub-
mergée par l’afflux de munitions de tous types et de tous
calibres produits par une industrie de guerre en plein ef-
fort. . . La première calculatrice électronique, l’ENIAC en
1945, était un monstre de 30 tonnes comportant 17 468
tubes à vide 7 et consommant 150 kW. La panne d’un seul
tube arrêtait la machine qui occupait un bâtiment à elle
toute seule et nécessitait un système de refroidissement
puissant pour évacuer la chaleur produite ! Les premiers
ordinateurs virent le jour à la fin des années 1940, trop
tard pour participer à l’effort de guerre.
6. la fille du poète.
7. il n’y avait pas encore de transistors et encore moins de circuits
intégrés.
10 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Rapidement, les banques, les compagnies d’assurance 8
et toutes les entreprises astreintes à une comptabilité
lourde comprirent l’usage qu’elles pouvaient faire de ces
nouvelles machines et constituèrent un marché important
pour les constructeurs. Cependant, la demande de calculs
toujours plus importants venant des scientifiques, physi-
ciens et astronomes en tête, n’a jamais cessé d’être pres-
sante, toujours de quelques ordres de grandeur au-delà
de ce que pouvaient fournir les ordinateurs les plus puis-
sants du moment : cette histoire se poursuit actuellement,
certains calculs quantiques, par exemple, se chargeant,
par leurs exigences en termes de puissance de calcul, de
ramener à une saine modestie les fabriquants des pro-
cesseurs les plus éblouissants !
dispensable à leur dextérité calculatoire. . . les calculettes
électroniques n’ayant détrôné l’invention de Napier qu’à
la fin de la décennie. Un livre de ≪ mathématiques com-
putationelles 9 ≫ régulièrement réédité jusqu’à la fin des
années 80 explique, dans un chapitre d’introduction inti-
tulé ≪ General rules of computation work ≫, que si l’on
veut construire une table des valeurs de la fonction :
ex + cos x p
y= + 1 + sin2 x
1 + x2
il faut faire sur une feuille de papier un tableau à 12
colonnes donnant, pour la première la liste des valeurs
de x, la deuxième celles de x2 , la troisième ex , etc., la
douzième donnant enfin la liste des valeurs de y (voir la
table 1.1) : il n’est pas inutile de réaliser que tous les cal-
culs scientifiques étaient réalisés de la sorte jusqu’à un
passé somme toute récent à l’échelle d’une vie humaine 10 .

Sur l’histoire de l’informatique, on se reportera avec

profit aux ouvrages suivants :

Ph. Breton Histoire de l’informatique, La

Découverte (1987)
M. Campbell-Kelly & Computer. A history of the
W. Aspray information machine, Basic Books
(1996)
Ph. Breton Le premier ordinateur copiait le
cerveau humain, La Recherche
290 (1996) p. 80

1.1.2 . . . et quelques exemples.

Au début du XXe siècle, le mathématicien Henri
Poincaré, étudiant le problème dit ≪ à N corps ≫ par
exemple N − 1 planètes et leur soleil, découvrit la ≪ sen-
siblité aux conditions initiales ≫ qui interdit de trou-
ver des solutions générales aux systèmes d’équations
différentielles produites par ces problèmes : une infime
différence dans les conditions initiales suffit à induire
un comportement radicalement différent du système. Au-
tant dire que, malgré le déterminisme intrinsèque de la
mécanique newtonienne, un tel système devient rapide-
ment imprévisible 11 . Toutefois, malgré cette découverte
fondamentale, Poincaré ne put guère aller plus loin et
l’on en resta là jusque vers les années 1960. C’est
alors que le mathématicien-météorologue américain Ed-
ward Lorenz 12 se mit à résoudre sur ordinateur des
équations différentielles qui visaient à simuler le com-
portement de l’atmosphère terrestre : il redécouvrit alors
des systèmes au comportement irrégulier similaire à
Figure 1.2 – Page de garde de la table de logarithmes ce qu’avait prédit Poincaré. Le triangle simulation-sur-
Bouvart et Ratinet (édition 1957) en usage dans les classes ordinateur/théorie/expérience donna naissance à un do-
scientifiques des lycées jusque dans les années 1970. maine de recherches nouveau et toujours actif de nos
jours : le chaos, la turbulence, les fractals. . ., tout ce qui a
À titre de témoignage de la rapidité avec laquelle la vie trait à la dynamique des systèmes non-linéaires. Il fallait
des scientifiques a changé, rappelons qu’encore au début évidemment pour cela que l’on pût faire des simulations
des années soixante-dix, les élèves des classes préparatoires
passaient plusieurs heures par semaine à remplir des 9. Voir la référence [2] dans la bibliographie. Il s’agit certes d’un
livre soviétique et l’informatique est sans doute l’un des domaines
colonnes de chiffres, stylo d’une main, table de logarithmes dans lequel le retard de l’Union soviétique était sensible.
(figures 1.2 et 1.3) de l’autre, un entraı̂nement jugé in- 10. Pour fixer les idées, précisons que l’espèce Tyranosaurus Rex
était déjà éteinte depuis quelques années. . .
8. Du point de vue des constructeurs d’ordinateurs, ce genre de 11. Voir par exemple : David Ruelle, Hasard et chaos, Odile Jacob
clients avait l’avantage d’être largement solvable, un encouragement (1991).
fort à faire les investissements nécessaires à la production de calcu- 12. À ne pas confondre avec l’éthologiste autrichien Konrad
latrices rapides et fiables ! Lorentz et ses oies.
Physique numérique, Philippe Depondt 11

Figure 1.3 – Une page de la table de logarithmes Bouvart et Ratinet. Admettons que l’on cherche le produit 0,1263 ×
18,17 ; une calculette donne 2,2949. Avec la table, il faut d’abord chercher 1263, soit 120 puis la sixième ligne pour 126
et enfin la colonne 3 : on y trouve 10140. La même opération pour 1817 donne 25935. La somme de ces deux nombres
est 36075. En cherchant dans la table, on trouve que 39078 correspond à 2295, reste à décaler la virgule convenablement
pour obtenir le résultat. Si l’on veut avoir 5 chiffres significatifs, il faut utiliser les tables de multiplication fournies
dans la marge pour faire des interpolations linéaires. Avec un peu d’habitude, ça va assez vite, plus vite en tous cas
que la multiplication à la main !

sur ordinateur, car le calcul analytique est insuffisant :
d’ailleurs maintenant, la météorologie nationale est un des
plus gros consomateurs civils de calcul sur les ordinateurs
les plus puissants.
Dans un autre domaine, les expériences faites par ex-
emple à l’aide du rayonnement synchrotron produit dans
des laboratoires tels que SOLEIL à Orsay et l’ESRF
à Grenoble, produisent une grande quantité de données
numériques qui ne se traduisent pas immédiatement par
des informations de type physique : par exemple, les po-
sitions des atomes d’une protéine, qui en comporte des
centaines voire des milliers, destinée à soigner telle ou telle
maladie. Survient alors une tâche assez difficile, la ≪ modé-
lisation de données d’expérience ≫ qui consiste à ajuster
un modèle théorique aux données expérimentales con-
nues, en tenant compte des barres d’erreur expérimentales.
Il s’agit en général de minimiser autant que possible
l’écart entre les données empiriques et les prédictions du
modèle théorique : cette minimisation, une optimisation
du modèle si l’on préfère, est établie en ajustant un nom-
bre souvent élevé de paramètres (les positions atomiques,
la caractérisation de l’agitation thermique) et ne peut pra-
12 Licence de physique L3 : PHYTEM,
1 2 3 4 5 6 7 8
ex +cos x
x x2 ex sin x cos x x
e + cos x 1 + x2
1+x2
(1)2 (3) + (5) 1 + (2) (6)/(7)
0
0.1
0.2
0.3
0.4
...
ex + cos x p
Table 1.1 – Feuille de calcul pour la fonction y = + 1 + sin2 x, à remplir, colonne par colonne, à l’aide
1 + x2
d’une machine à calculer mécanique ou électro-mécanique. . .
Table 1.2 – Un article du journal Le Monde en 1957, les
derniers progrès de la prévision météorologique, il y a un
demi-siècle :
Une machine à prédire le temps
Quel temps fera-t-il demain ? Vieille question à laquelle les of-
fices météorologiques s’efforcent de répondre. Mais voici que la
machine électronique vient à leur secours. On connaı̂t les ap-
titudes extraordinaires de ces ordinateurs, véritables cerveaux
de remplacement, doués de raisonnement et d’une fabuleuse
mémoire, qui peuvent aujourd’hui répondre en quelques sec-
ondes à des questions qui embarasseraient plus d’un auditoire
savant.
C’est à des machines semblables que le Bureau météorologique
américain demande de travailler pour lui, au moins pour un cer-
tain nombre de calculs. Ce bureau centralise des milliers d’ob-
servations qu’une armée de savants, de ballons-sondes, toute
une flotille de bateaux, tout un réseau de postes et de sta-
tions disséminés aux quatre coins du monde, glanent quoti-
diennement et à chaque instant sur terre, sur mer et dans le
ciel.
Rien n’a changé dans le système, si ce n’est qu’une grande par-
tie des opérations mathématiques, la plus dure, la plus longue,
est confiée à l’ordinateur. A chaque instant on introduit dans
la machine, sous forme de bandes magnétiques, de nouvelles
observations, de nouveaux chiffres, qui sont la nourriture de
ce cerveau surhumain, et les savants n’ont plus qu’à tirer leurs
conclusions. Ils peuvent ainsi annoncer, avec une plus grande
sûreté de diagnostic, l’évolution du temps pour des périodes de
vingt-quatre, quarante-huit et même soixante-douze heures.
(Le Monde, le 25 juillet 1957, reproduit le 25/07/2007).
tiquement se faire qu’à l’aide d’un ordinateur.
L’étude des systèmes désordonnés est aussi grosse con-
sommatrice de moyens de calcul. Par exemple, une chaı̂ne
linéaire harmonique d’atomes, tous de masse m, est par-
courue de vibrations de type onde plane xℓ = u ei(ωt−kℓa) ,
où xℓ est le dépacement de l’atome ℓ par rapport à sa po-
sition d’équilibre et a est la distance interatomique. Un
calcul classique 13 à partir des équations du mouvement :
m ẍℓ = C(xℓ+1 − 2xℓ + xℓ−1 )
donne la pulsation ω en fonction du vecteur d’onde k, c’est-
à-dire la relation de dispersion :
r
C ka
ω(k) = 2 sin
m 2
13. Voir, par exemple : Charles Kittel, Introduction to Solid
StatePhysics, New York : Wiley, (1986).
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
9 10 p 11 12
sin2 x 1 + sin2 x 1 + sin2 x y
p
(4)2 1 + (9) (10) (8) + (11)
où C est la constante de force entre deux atomes. Main-
tenant, si la chaı̂ne comporte des impuretés de masse
m′ réparties aléatoirement, le problème devient beaucoup
plus difficile à résoudre. On montre cependant sans grande
difficulté que la solution est donnée par la recherche des
valeurs propres et vecteurs propres d’une énorme matrice
n × n, appelée ≪ matrice dynamique ≫ où n est le nom-
bre d’atomes de la chaı̂ne. Le problème est très facile à
résoudre numériquement à l’aide d’un sous-programme de
bibliothèque, alors que le désespoir guette quiconque ten-
terait de le résoudre à la main. . .
On pourrait objecter à ce qui précède qu’un problème
de physique qui nécessite plus qu’une règle de trois pour
être résolu est un problème mal posé. L’art du physicien
théoricien n’est-il pas justement de faire des approxima-
tions adroites de façon à rendre résolubles ces problèmes
tout en isolant les principes importants ? L’intérêt n’est-il
pas plutôt dans les concepts que dans les techniques de
calcul plus ou moins laborieuses ?
Cette objection est parfaitement recevable et c’est tou-
jours une bonne démarche que de tenter de réfléchir à
une question avant de se lancer dans des calculs effrénés.
Il y a cependant des limites qui souvent arrivent très
vite : imaginons un pendule simple qui subit un frotte-
ment aérodynamique. Il pend verticalement et on le lance
avec une vitesse initiale donnée, suffisamment fort pour
qu’il passe à la verticale au dessus de son point d’équilibre
pour retomber de l’autre coté. Combien de tours fera-t-
il autour de son axe avant de se mettre à osciller ? Il est
clair qu’on est fort loin des conditions où l’on peut faire
les approximations usuelles (angle petit). En attendant de
trouver le concept adéquat, il n’est peut-être pas stupide
de faire une petite simulation numérique sur un ordina-
teur : cela ne représente guère plus que quelques dizaines
de lignes de programme et quelques secondes de simulation
sur une machine même de puissance médiocre. . .
Il ne faut pas croire non plus que le calcul numérique
sur ordinateur se limite à la physique : les prévisions
météorologiques (voir la table 1.2) sont évidemment un
cas bien connu, mais aussi les simulateurs de vol permet-
tent à des pilotes d’essais de tester le comportement d’un
nouvel avion sans risquer leurs vies et des simulateurs
d’opérations permettent à des chirurgiens de s’entraı̂ner
sans risquer celles de leurs patients ! Le dossier de la revue
Pour la Science (voir la bibliographie, ref. (20)) consacré
à la modélisation informatique parcourt quelques thèmes
≪ à la mode ≫. . .
Physique numérique, Philippe Depondt 13

1.2 Plan succinct.

La première étape est l’apprentissage d’un langage de
programmation. Il faut pouvoir ≪ dire ≫ à l’ordinateur ce
que l’on veut qu’il fasse. Le langage le plus adapté au cal-
cul scientifique est le fortran95. Son concurrent, le lan-
gage C, plus généraliste et plus adapté à la programmation
système -le système d’exploitation unix est programmé
en C-, nécessiterait un apprentissage plus long, qui n’ap-
porterait rien de plus à notre objectif, sans apporter la
puissance qu’offre fortran95 en particulier dans la ma-
nipulation des tableaux. Afin d’illustrer l’objectif de ce
cours, cette première partie est suivie d’un chapitre dont
le but est de montrer sur un exemple la façon dont on
procède pour aborder un problème et en particulier es-
sayer d’expliciter ce qui est attendu lors des séances de
travaux pratiques.
La deuxième étape consistera à passer en revue les
méthodes les plus utilisées par les physiciens, autant que
possible à l’aide d’exemples tirés de la physique. L’accent
ne sera pas forcément mis sur les détails les plus intimes
des algorithmes, car des mathématiciens seraient sûrement
plus à même de le faire que des physiciens dont ce n’est
pas le centre d’intérêt principal : de fait, la pratique des
physiciens est souvent d’utiliser des sous-programmes de
bibliothèque existants et éprouvés que l’on ≪ appelle ≫ à
partir d’un programme spécifique à un problème donné.
L’effort portera donc plutôt sur les contraintes que ces al-
gorithmes peuvent exercer sur les problèmes que se posent
les physiciens, éventuellement sur les pièges qu’ils recèlent.
En gros, il s’agit d’essayer de répondre à trois questions :
≪ comment ça marche ? ≫, ≪ quelles conséquences cela

peut-il avoir pour moi, physicien ? ≫ et bien sûr : ≪ qu’est-

ce que je peux faire avec ? ≫. Une ouverture est donnée sur
la simulation numérique.
La troisième étape consistera à utiliser un logiciel de cal-
cul formel pour tenter de résoudre les mêmes problèmes
que précédemment. Dans certains cas, le caractère con-
vivial et automatique du logiciel tout fait fera des miracles,
dans d’autres en revanche, ça sera moins convaincant. . .
mieux vaut savoir se repérer, d’autant que, là encore, des
pièges subsistent.
Ainsi ce cours se veut, non pas un cours d’≪ infor-
matique pour physiciens ≫ mais un cours pratique de
≪ Physique numérique ≫ c’est-à-dire des méthodes qu’u-

tilisent les physiciens pour résoudre un grand nombre de

problèmes de physique.
14 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 2
Notions pratiques de FORTRAN95.
Les notes ci-dessous ont pour but de donner rapide-
ment au lecteur la capacité d’écrire des programmes ; elles
ne remplacent pas, bien sûr, un cours systématique 1 . Il
s’agit ici d’un outil dont la maı̂trise est un préalable in-
dispensable à tout travail de calcul numérique : il n’est
pas utile de connaı̂tre toutes les subtilités du Fortran95,
mais il faut impérativement être capable d’écrire rapi-
dement des programmes simples ≪ qui marchent ≫ car,
sinon, les séances de travaux pratiques destinées à faire
de la physique que l’on espère intéressante avec cet outil,
en deviendraient suprêmement ennuyeuses pour tous, en-
seignants compris. . .
2.1 Qu’est-ce qu’un langage de
programmation ?
Un ordinateur, lorsqu’il exécute un programme, lit
l’une après l’autre dans sa mémoire des instructions
élémentaires, par exemple : ≪ aller chercher un nombre
à tel emplacement dans la mémoire ≫ ou ≪ multiplier tel
nombre par tel autre ≫. Ce schéma correspond à la célèbre
≪ machine de Turing ≫ qui sert de modèle théorique à
l’immense majorité des ordinateurs (figure 2.1) : instruc-
tions et données sont inscrites sur un même support ap-
pelé mémoire 2 . La mémoire est constituée d’emplacements
correspondant chacun à une adresse et contenant chacun
une instruction ou une donnée : on peut se représenter
cette mémoire comme une espèce de long ruban divisé en
cases, chacune d’entre elles ayant un numéro, comme les
maisons le long d’une rue, chaque numéro constituant une
≪ adresse ≫.
La ≪ machine ≫ lit dans la mémoire les instructions
et les exécute l’une après l’autre séquentiellement 3 . Une
instruction peut être l’ordre d’aller lire une donnée à
l’adresse en mémoire indiquée par cette instruction, ou
de modifier une donnée ou encore d’inscrire une donnée à
une autre adresse dans la mémoire : on peut donc modifier
le contenu de la mémoire.
Chaque instruction est désignée par un code binaire
constitué de 0 et de 1, et chaque emplacement dans
1. voir par exemple J. F. Kerrigan, réf. [6] dans la bibliographie,
ou, plus récent et plus complet M. Metcalf et al., réf. [18].
2. Le terme mémoire date des années 1940, lorsque John Von
Neumann s’est préoccupé de réalisations pratiques de la machine
de Turing qui dans son esprit devaient être des cerveaux artificiels.
Avant, on parlait, plus prosaı̈quement, de storage en anglais, soit
stockage.
3. d’où l’expression ≪ machine séquentielle ≫ que l’on retrouve
fréquemment : il s’agit simplement d’une machine qui exécute les
instructions l’une après l’autre, par opposition aux machines dites
≪ parallèles ≫.
15
la mémoire est aussi désigné par une adresse binaire.
C’est ce qu’on appelle le langage machine. Réaliser un
programme consiste donc à fournir à l’ordinateur une
séquence d’instructions de ce type pour qu’il la place
dans sa mémoire pour exécution ; or il est rapidement
fastidieux d’aligner des listes fort longues de 1 et de 0,
sans compter les risques d’erreurs que cela comporte ! Un
premier progrès fut de remplacer le code binaire d’une
instruction par un mot-clef, par exemple load (pour
charger en mémoire), et d’écrire les adresses en décimal
(ou en hexadécimal) plutôt qu’en binaire. Cela donne
quelque chose qui peut ressembler à :
load 150 aller chercher un nombre à l’adresse 150
add 200 additionner avec le contenu de l’adr. 200
store 220 ranger le résultat a l’adresse 220
C’est nettement plus lisible que :
0011010100101100011111100100001001110101...
Un programme spécial, en général fourni avec l’ordinateur
et appelé assembleur traduit alors toutes ces instructions
en binaire ou langage machine, puis on peut faire exécuter
le programme (voir les tables 2.1 et 2.2).
L’assembleur permet de faire beaucoup de choses,
presque tout, à vrai dire : à une époque (les années
80) où les mémoires disponibles n’étaient pas ce qu’elles
sont devenues, la programmation en assembleur permet-
tait d’écrire des programmes efficaces et peu encombrants,
au détriment évidemment de la facilité et du temps passé
à la programmation, car tout cela reste très ≪ proche de
la machine ≫ et certainement assez peu convivial 4 .
L’étape suivante fut donc de créer des langages dits
≪ évolués ≫ avec lesquels on puisse faire aisément des
instructions beaucoup plus compliquées comme, par ex-
emple :
x = a*exp(i*(omega*t+phi))
qui ressemble beaucoup à l’expression mathématique :
x = a ei(ωt+ϕ)
et où x et i sont des nombres complexes, les autres vari-
ables étant réelles, exp désignant évidemment l’exponen-
tielle et * la multiplication. Un autre programme ap-
pelé compilateur doit alors décomposer ces instructions
évoluées en instructions élémentaires, les coder en bi-
naire et affecter des adresses en mémoire à toutes les
4. J’ai, personnellement, quelques souvenirs cuisants à ce titre :
à la suite -entre autres- d’une erreur dans le calcul d’une adresse,
un programme pouvait très bien écrire une donnée à un emplace-
ment réservé à une fonctionalité de base du système, ce qui était
évidemment plutôt catastrophique !
16 Licence de physique L3 : PHYTEM,
1 2 3 4 150 151
charger add. ranger aller retour
16
4
41
14
150 200 220 en 10 en 1
1.
3.
Figure 2.1 – La machine théorique de Turing. Le curseur lit les instructions les unes après les autres et la machine les
exécute. Par exemple : aller lire une donnée à un emplacement de la mémoire vive, ou sauter à une autre instruction,
etc.
Table 2.1 – Pour comprendre comment ≪ ça marche ≫ :
quelques éléments d’assembleur
L’unité centrale (CPU ou Central Processing Unit) d’un or-
dinateur ne travaille pas directement dans la mémoire vive :
elle a ses propres emplacements mémoires appelés ≪ reg-
istres ≫. Elle doit donc aller chercher en mémoire vive les
grandeurs nécessaires à un calcul, les copier dans ses reg-
istres, faire les opérations requises et stoker les résultats dans
la mémoire. Pourquoi toutes ces complications, pourquoi ne
pas tout stocker d’emblée dans les registres de l’unité cen-
trale ? Tout simplement parce qu’ils sont très peu nombreux, de
l’ordre de la dizaine. . . Certains ordinateurs très puissants -et
extrêmement coûteux- possèdent des registres en grand nom-
bre ce qui accélère considérablement les calculs mais suppose
un budget conséquent !
Mettons que l’ordinateur utilisé possède deux registres à usage
général appelés ≪ accumulateurs ≫, désignés par A et B dans
lesquels on peut placer des nombres, par exemple. L’instruc-
tion pour charger le contenu d’un emplacement mémoire dans
le registre A est LDA et celle pour B est LDB (les syntaxes sont
données ici à titre indicatif : cela dépend du processeur). On
peut donc écrire, par exemple :
LDA $40B6
ce qui signifie ≪ charger le contenu de $40B6 dans le registre A,
le symbole $ indiquant que l’adresse est donnée en hexadécimal
(en base 16), soit : $40B6= 4 × 163 + 0 × 162 + 11 × 16 + 6 soit
16566.De même :
ADDA $B003
additionne le contenu du registre A avec le contenu de l’em-
placement $B003 et place le résultat dans A.(Suite : table 2.2)
variables pour produire un programme exécutable : cette
traduction, ce programme exécutable est généralement
stocké sur le disque dur de l’ordinateur dans un fichier
dit ≪ exécutable ≫ qu’il suffit d’invoquer (en général en
tapant son nom sur le clavier) pour qu’il s’exécute. Ainsi,
lorsqu’on écrit un programme, que ce soit en fortran,
C, pascal ou autre, on doit d’abord créer, à l’aide d’un
éditeur de texte 5 comme emacs, xedit, kedit, vi (pour
les amateurs), voire ed, un fichier que l’on appelle le
≪ fichier source ≫ qui contient les instructions que l’on
a écrites en langage évolué. Ce fichier source n’est pas
exécutable : il ne contient que des caractères, a priori inu-
tilisables en l’état par l’unité centrale. On doit alors com-
piler le programme pour obtenir un fichier exécutable, et
enfin lancer l’exécution de celui-ci. Bien, évidemment, à
5. et non un traitement de texte, dont les fonctionnalités (mise en
page, correction orthographiques, effets divers) sont infiniment plus
riches qu’un simple éditeur qui se borne à enregistrer les caractères
que l’on tape au clavier pour les inscrire dans un fichier texte sur le
disque dur.
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
200 201 220
58
64
2.
Table 2.2 – Suite de la table 2.1
Un autre registre très important est le ≪ compteur ordinal ≫ :
il contient l’adresse de la prochaine instruction qui doit être
lue. Le contenu de ce registre est incrémenté automatique-
ment chaque fois qu’une instruction est lue, sauf si l’instruction
précédente est une instruction dite ≪ de branchement ≫. Ainsi,
le CPU lit une instruction, incrémente le compteur ordinal,
exécute l’instruction, puis lit l’instruction suivante, incrémente
le compteur, exécute l’instruction, etc. C’est ce qu’on appelle
une ≪ architecture séquentielle ≫.
Cependant, si l’instruction lue est une instruction de branche-
ment, celle-ci modifie le contenu du compteur afin de forcer la
lecture d’une autre instruction que la suivante. Ce branchement
est en général soumis au contenu d’un registre ≪ d’état ≫ qui
dit si une grandeur dernièrement traitée et positive ou négative,
s’il y a eu un dépassement de capacité, etc. On peut modifier
le registre d’état à l’aide d’instructions de comparaison, par
exemple :
CMPB $310F
compare le contenu du registre B avec celui de l’emplacement
$310F et modifie le registre d’état en conséquence, puis
BGE $11DA
nous expédie à l’adresse mémoire $11DA, si le résultat de la com-
paraison est positif (B veut dire branch et GE signifie Greater
or Equal ), pour y lire une instruction. On obtient ainsi la pos-
sibilité d’instructions soumises à condition ; reste toutefois à
espérer que l’emplacement en question contient bien une in-
struction, c’est une source de ≪ plantages ≫ spectaculaires,
mais là réside une grande part du charme désuet de l’assem-
bleur !
Si l’on souhaite un plat un peu plus corsé encore, on peut placer
un nombre désignant une adresse dans un emplacement de la
mémoire. Par exemple :
LDA #$0114
place le nombre (et non le contenu de l’adresse) dans le registre
A,
STA $041E
place ce nombre à l’emplacement $041E
LDB [$041E]
charge dans B, non pas le contenu de $041E, mais le contenu
de l’adresse elle-même contenue dans $041E. Ainsi
INC $041E
incrémente le contenu de cette adresse, et
LDB [$041E]
permet d’aller chercher ce qui se trouve à l’emplacement suiv-
ant : en accroissant pas à pas le contenu de l’emplacement
$041E on peut parcourir l’un après l’autre toute une série d’em-
placements successifs dans la mémoire. Les amateurs de lan-
gage C auront reconnu ici un embryon de pointeur. En for-
tran ce genre de situation est géré par les tableaux.
chaque modification du fichier source, il faut re-compiler
Physique numérique, Philippe Depondt
et relancer l’exécution 6 !
Le fortran est le premier de ces langages évolués à
avoir vu le jour, mais beaucoup d’autres ont suivi : al-
gol, cobol, pl1, basic, pascal, forth, C, ada, oc-
cam, C++. . . Pour ce qui est de la programmation sci-
entifique, outre fortran, seul le langage C++ semble
survivre.
Le sigle fortran signifie ≪ formula translator ≫ (tra-
ducteur de formules) : l’idée est donc de coder des for-
mules de façon aussi proche que possible de ce que l’on
fait lorsqu’on écrit des équations à la main et de traduire
ceci en instructions exécutables par l’ordinateur. C’est à
première vue une gageure, mais, en fait, fortran est un
langage simple, bien adapté au calcul scientifique. Mis
au point dans sa première version par John Backus en
1956, il n’a pas cessé d’évoluer depuis et ses variantes sont
nombreuses tant les façons de programmer ont évolué. En
effet, les moins jeunes de vos enseignants ont appris le
fortranIV et ont travaillé avec des cartes perforées : ils
ont bien sûr des anecdotes à raconter sur des paquets de
cartes s’échappant de leur carton et se répandant sur le
sol ou de cartes abı̂mées après de nombreux usages (après
tout, il ne s’agissait que de morceaux de papier bristol)
se coinçant dans le lecteur et dont il fallait aller chercher
les débris avec une pince à épiler ! Le bruit des machines
à perforer 7 a marqué un certain nombre de générations
de programmeurs. . . À la fin des années soixante-dix et
au début des années quatre-vingt, les cartes perforées dis-
parurent, remplacées d’abord par des télétypes puis par
l’ensemble écran-clavier que nous connaissons maintenant.
Le fortranIV avait bien des défauts. Il comportait
des instructions (go to et if ≪ arithmétique ≫) capa-
bles de produire des logiques échevelées, bondissant d’un
bout à l’autre du programme en des itinéraires dignes d’un
plat de spaghettis : autant dire que ce n’était pas très
lisible et générateur d’erreurs retorses. Entre-temps, les
idées liées à la programmation dite ≪ structurée ≫ s’étaient
développées, incarnées entre autres par le langage pascal,
et le fortran a intégré une bonne part de ces concepts.
La dernière norme officielle de fortran est for-
tran2008 : fortran77 est maintenant obsolète. En-
tre fortran90 et fortran2008, les différences sont
marginales, du moins pour l’usage que nous en ferons. De
fait, fortran90 ou fortran95 constitue, pour l’essen-
tiel, la norme sur les gros calculateurs dédiés aux calculs
lourds.
Nous utiliserons ici la norme fortran95, principale-
ment pour sa capacité à travailler sur des tableaux de
nombres de façon très confortable et efficace 8 . De bons
compilateurs fortran95 (g95 et gfortran 9 ) et il n’y a
6. il existe des environnements intégrés, en particulier sous Win-
dows, dans lesquels ces étapes sont plus ou moins automatiques et
donc quasiment invisibles.
7. Il y eut aussi l’étape ruban perforé qui permettait, avant les
bandes, disquettes et autres supports magnétiques, d’enregistrer des
données : cet engin était -justement- surnommé ≪ la mitrailleuse ≫ !
8. Les programmes écrits en fortran77 peuvent être compilés
avec un compilateur fortran95.
9. Le compilateur g95 est aisément téléchargeable sur
http://g95.org/. Le compilateur gnu (Le mot anglais gnu
désigne le gnou, une espèce de buffle, et le sigle gnu signifie : GNU’s
Not Unix, un exemple d’autoréférence typique d’un certain humour
informatique) gfortran est disponible comme faisant partie des
distributions Linux (Debian, Ubuntu, Fedora) et, convenablement
installé, il paraı̂t raisonnablement efficace à condition d’utiliser
l’option d’optimisation -O3.
17
donc guère de raison de s’en priver. D’autres compilateurs,
comme le compilateur Intel produisent parfois des codes
plus rapides à l’exécution, mais le bénéfice reste marginal
pour les calculs faits ici.
Dans les notes qui suivent, nous suivrons le ≪ format li-
bre ≫ (ou free form) qui permet de s’affranchir de l’obliga-
tion de s’en tenir aux colonnes 7 à 72 comme au bon vieux
temps des cartes perforées. . . Les compilateurs s’en acco-
modent en principe sans problème encore que quelques
facéties soient possible : on peut alors tenter d’utiliser
l’option de compilation -ffree-form, voire lire le manuel
d’utilisation du compilateur. . .
La compilation s’effectue par la commande :
gfortran monboprog.f90 -o monboprog
monboprog.f90 (ou tout autre nom se terminant par
.f90) est le fichier, dit ≪ fichier source ≫ créé avec un
éditeur comme emacs, qui contient toutes les instruc-
tions écrites en fortran 10 . L’option -o (pour output)
indique au compilateur où il doit placer le résultat de
son travail, ainsi le fichier monboprog contient le pro-
gramme exécutable, c’est-à-dire sa traduction en langage
machine 11 . Evidemment, si l’on utilise un autre com-
pilateur que gfortran (par exemple g95, pgf90 12 ou
xlf90 13 ), il faut remplacer gfortran par le nom du com-
pilateur.
Edition : emacs monboprog.f90 &
Compilation : g95 monboprog.f90 −o monboprog
Exécution : ./monboprog
Figure 2.2 – Le cycle de mise au point d’un programme :
édition du fichier-source, compilation, exécution. La com-
pilation permet de détecter les erreurs de syntaxe que l’on
corrige par un retour à l’étape d’édition. À l’exécution, la
prudence impose de tester le programme, en général en
faisant des calculs dont on connait le résultat : les erreurs
ainsi détectées renvoient aussi à l’édition. En principe, le
cycle converge assez vite. . .
Le résultat de la compilation est donc, quand tout s’est
bien passé, un programme exécutable qu’il reste à faire
10. certains compilateurs fortran90 exigent que le nom du fichier
source se termine par .f. Pour d’autres, la terminaison .f signifie
≪ format fixe ≫ et la terminaison .f90, ≪ format libre ≫
11. On peut fabriquer une commande personnelle de compilation,
par exemple en créant un fichier appelé gf95 dans lequel on met
la ligne : gfortran $1.f90 -o $1. Ce fichier peut alors être rendu
exécutable par la commande : chmod +x gf95. Pour compiler un pro-
gramme, il suffira dorénavant de taper : gf95 monboprog. Selon les
besoins, gf95 peut être modifié ensuite pour inclure d’autres options
de compilation comme -O3 (optimisation) ou des bibliothèques de
calcul.
12. compilateur commercial de Portland Group.
13. compilateur ibm.
18 Licence de physique L3 : PHYTEM,
travailler, mais en général, au premier essai, il reste des er-
reurs de programmation que le compilateur détecte : il faut
alors corriger le programme-source en tenant compte des
diagnostics fournis par le compilateurs et re-compiler. . .
jusqu’à ce que ça marche ! (figure 2.2).
Table 2.3 – Qu’est-ce qu’un système d’exploitation ?
On doit, on l’a vu, mettre dans la mémoire vive de l’ordinateur
le ou les programmes que l’on utilise ainsi que les données cor-
respondantes. C’est une des tâches du système d’exploitation :
quand, sous unix, on tape le nom d’un programme, un autre
programme (ou plusieurs autres programmes) qui fait partie
du système d’exploitation, lit les caractères que l’on tape sur
le clavier, au passage reproduit ces caractères sur l’écran, puis
va lire le fichier exécutable au bon endroit sur le disque dur,
l’installe en mémoire et lance son exécution. Éventuellement, il
fera apparaı̂tre un message du genre file not found ou toute
autre chose de ce style. . . Si plusieurs programmes doivent
s’éxécuter en même temps, ou si plusieurs utilisateurs travail-
lent en même temps sur le même ordinateur, c’est le système d’-
exploitation qui répartira les ressources (mémoire, processeur,
disque dur, imprimantes, etc.) entre les programmes et les util-
isateurs. C’est aussi au système d’exploitation que l’on a à faire
lorsqu’il faut s’identifier comme utilisateur (login et mot de
passe).
Le système d’exploitation unix date du début des années
1970 ; il a d’abord été installé sur des stations de tra-
vail ≪ moyennes ≫ mais il a rapidement envahi le monde
des ordinateurs destiné au calcul scientifique. Le premier
système d’exploitation de Microsoft, dos (1981), est une ver-
sion extrêmement simplifiée d’unix, en particulier, il est mono-
utilisateur, alors qu’Unix est multi-utilisateur, c’est-à-dire que
plusieurs personnes peuvent utiliser simultanément le même
ordinateur : c’est particulièrement important sur les grosses
machines et les serveurs. En 1991, Linus Torvalds créa linux,
une version, complète cette fois-ci, d’unix utilisable sur des or-
dinateurs personnels. Les machines utilisées pour les travaux
pratiques de ce module tournent sous linux.
Un grosse partie de la tâche du système d’exploitation est de
gérer les périphériques, en particulier, les disques (d’ailleurs
le nom dos signifie disk operating system), car c’est là que
se trouvent les données et les programmes. Un disque dur
est en général structuré en répertoires : une partie du disque
est réservée au système d’exploitation, une autre aux utilisa-
teurs (en général home). Chaque utilisateur a son propre sous-
répertoire et souvent les utilisateurs sont organisés en groupes
(par exemple phys, math, chim,. . .). Si vous tapez par exemple
la commande pwd (print working directory), vous obtiendrez
quelque chose qui peut ressembler à :
/home/phys/enseign/depondt
c’est-à-dire que le répertoire de travail courant depondt est en
fait un sous-répertoire d’enseign, lui-même un sous-répertoire
de phys, etc. La commande ls (list) donne la liste des fichiers
et sous-répertoires présents dans un répertoire. On peut créer
un répertoire (que l’on choisit d’appeler par exemple td1)
par la commande mkdir td1 (make directory) par exemple
et changer de répertoire par cd td1 (change directory) : pwd
donnera alors /home/phys/enseign/depondt/td1.
Depuis le milieu des années 1980, les systèmes d’exploita-
tion comportent également les icônes et fenêtres devenues cou-
tumières : quand on clique sur une icône, on ≪ dit ≫ au système
de lancer le programme correspondant au lieu de taper son nom
sur le clavier. gnome ou kde sont des systèmes de fenêtrage
qui viennent se greffer sur linux, mais on peut très bien tra-
vailler sur des machines qui en sont dépourvues : c’est un peu
moins convivial. . . mais parfois plus robuste !
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Table 2.4 – Quelques commandes Unix de base
Beaucoup de choses peuvent être faites sous Unix en cliquant
sur des icônes : les gestionnaires de fenêtre tels que kde ou
gnome sont devenus très similaires à Windows ou MacOS.
Il est bon cependant de connaı̂tre les commandes de base
d’Unix, d’une part parce que les icônes sont loin d’être ca-
pables de tout faire et de l’autre, il est souvent sensible-
ment plus rapide de taper une commande dans un ter-
minal que de déployer tout l’arsenal, graphique en par-
ticulier, qui accompagne les gestionnaires de fenêtres et
d’icônes et qui est généralement gourmand en ressources.
mkdir make directory créer un répertoire
pwd print working directory nom du répertoire courant
cd change directory changer de répertoire
cp copy copier des fichiers,
rm remove effacer des fichiers
mv move déplacer un fichier
more more voir le contenu d’un
fichier texte.
lpr line printer imprimer
a2ps ASCII to postscript imprimer un fichier texte
emacs éditeur de texte
g95 compilateur fortran
man manual manuel en ligne
Par exemple : cp machin nouveau machin crée un fichier qui
est la copie de machin. On peut déplacer ou copier d’un
répertoire à un autre : mv td1/prog.f td2 déplacera le fichier
prog.f du répertoire td1 au répertoire td2.
La plupart des commande ont des options marquées par un
tiret -, par exemple : g95 prog.f90 -O3 -o prog utilise deux
options (optimisation, et nom du fichier de sortie), ou : lpr
-Ppr1 figure.ps précise sur quelle imprimante l’impression
doit se faire. Pour trouver les possibilités d’une commande et
les options qu’elle peut utiliser : man nom de commande.
Finalement, le répertoire courant est marqué par un point : .
et le répertoire situé au-dessus du courant par deux points :
.., ainsi cd . ne fait rien, mais cd .. remonte d’un cran dans
la hierarchie des fichiers. Si l’on veut copier un fichier d’un
autre répertoire vers le répertoire courant, on peut faire, par
exemple, un cp /home/machin/truc/fichier origine . , où
le point “.” est la destination de la copie.
Table 2.5 – Le BIOS ou Basic Input/Output System.
Le BIOS est un programme qui est directement installé par le
constructeur sur la carte-mère (c’est-à-dire la carte qui com-
porte le processeur, la mémoire vive, etc.) de l’ordinateur et
qui peut donc démarrer dès la mise sous tension alors qu’au-
cun périphérique n’est encore opérationnel. C’est lui qui, après
avoir identifié les périphériques disponibles, charge le système
d’exploitation qui se trouve, lui, généralement sur le disque
dur, un CD, voire une disquette ou une autre machine acces-
sible par réseau.
2.2 Notions élémentaires.
2.2.1 Instructions.
Une instruction très simple de fortran peut être par
exemple :
a = b + c
elle signifie :
1. que l’on désigne par a, b et c trois emplacements dans
la mémoire vive de l’ordinateur,
2. que l’on prend le contenu des emplacements b et c,
Physique numérique, Philippe Depondt 19

3. que l’on en fait la somme (cela suppose qu’il s’agit de i = i + 1

nombres)
n’a rien d’absurde : il s’agit simplement de l’ordre d’aug-
4. que l’on met le résultat dans l’emplacement a. menter la valeur de i de 1 (on prend i, on lui ajoute 1 et
on met de résultat dans i). En revanche :

a = b + c a + b = 3*x + c ! ATTENTION, CECI N’A AUCUN SENS

est totalement dépourvu de sens pour l’ordinateur car l’-

expression a + b à gauche du signe = ne désigne pas un
emplacement dans la mémoire. . . pire encore :
a = b = c ! CA NE PLAIRA PAS DU TOUT AU COMPILATEUR

à droite du premier signe =, il y a une expression b = c qui

ne peut pas être évaluée, puisque ce n’est pas une valeur,
c’est une instruction !

2.2.2 Déclarations.
Tout ceci suppose cependant que l’on ait déjà ≪ dit ≫ à
l’ordinateur que a, b et c sont des emplacements de la
mémoire destinés à contenir des nombres, par exemple des
Ceci n’est pas un = nombres réels : c’est ce qu’on appelle une déclaration. Ainsi
la déclaration :
real :: a, b, c
Figure 2.3 – Le signe = dans une instruction n’est pas
une égalité mathématique ! déclare que l’on va occuper trois emplacements mémoire
dorénavant appelés a, b et c et que l’on mettra des nom-
Il ne faut surtout pas s’imaginer que le signe = ci-dessus bres réels dedans 14 . Comme on peut changer la valeur
soit une égalité mathématique ! Il s’agit d’une instruction, du contenu de ces emplacements, on les appelle vari-
d’un ordre que l’on donne à l’ordinateur : on lui ≪ dit ≫ de ables. Un nom de variable peut être simplement une lettre
calculer la valeur numérique de ce qui se trouve à droite comme a ou x, ou alors une combinaison de lettres et de
du signe égal et de le placer dans l’emplacement de la chiffres à condition de commencer par une lettre, par ex-
mémoire désigné par le symbole qui se trouve à sa gauche.
emple : agecpt, y2, zmax, mais pas : 2pi ou s*3 (* est
On peut considérer le signe égal comme une affectation ou
une flèche : un caractère spécial désignant la multiplication). Le car-
actère “ ” ≪ blanc souligné ≫ ou underscore est également
a = b autorisé : pere ubu ou nbr pas. La longueur peut aller
peut être compris comme jusqu’à 31 caractères : age du capitaine. Il ne faut pas
utiliser les lettres accentuées, cédilles, trémas, et autres
a ← b signes diacritiques. Enfin, fortran ne fait pas la distinc-
on met b dans a. Cela a quelques conséquences pratiques, tion entre lettres majuscules et minuscules (Zmin est iden-
ainsi tique à zmin) alors que le système d’exploitation unix le
a = b fait (les fichiers resultats et Resultats sont distincts).
On peut déclarer des nombres entiers, par exemple :
(mettre b dans a) et
integer :: i, m, nbrpas
b = a
ou des nombres complexes :
(mettre a dans b) ne signifient pas la même chose et les
deux instructions : complex :: z, s

a = b
b = c
Table 2.6 – Liste des types de variables :
ne signifient pas que les trois nombres a, b et c soient déclaration type des variables
égaux ! Cela signifie : ≪ prendre le contenu de l’emplace- integer entier
ment désigné par la lettre b et le mettre dans a, puis mod- real réel
ifer le contenu de b en y mettant le contenu de c ≫. Donc, double precision réel en double précision
après coup, a et b peuvent être différents. De même, l’or- complex complexe
dre des instructions a une importance : mettons que l’on double complex complexe en double précision
ait affecté les valeurs, respectivement, 1, 2 et 3 à a, b et c.
character chaı̂ne de caractères
Les deux instructions ci-dessus aboutiront à avoir 2 dans
a et 3 dans b et c. Mais si l’on intervertit les instructions : logical variable logique

b = c Toutes les déclarations doivent figurer au

a = b début du programme, avant les instructions dites
alors, a, b et c contiennent la valeur 3. . . Il s’agit donc bien 14. On utilise ici la forme fortran90 destinée à prendre assez rapi-
de deux instructions exécutées l’une après l’autre dans l’or- dement le relais de la forme fortran77 : real a, b, c, également
dre donné dans le programme. Finalement, l’instruction : acceptée par g95.
20 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

≪ exécutables ≫. Une instruction du type a = 3*b - c L’instruction end marque la fin du programme. L’in-
avec laquelle on ≪ dit ≫ à l’ordinateur de faire quelque struction program donne un nom au programme qui peut
chose est exécutable, une déclaration où l’on réserve de être distinct du nom du fichier-source qui le contient.
l’espace pour des variables ne l’est pas.
En fortran, il existe ce que l’on appelle des
déclarations implicites, survivance des anciennes versions Table 2.7 – Liste des opérations sur les nombres :
de ce langage de programmation, qu’il est formellement
déconseillé d’utiliser 15 . Pour les rendre inopérantes, on L’addition s’écrit : + e.g. : a + b
utilise l’instruction : La soustraction s’écrit : - e.g. : 3. - x
La multiplication s’écrit : * e.g. : a*b
implicit none
La division s’écrit : / e.g. : p/q
La mise à la puissance s’écrit : ** e.g. : x**p
2.2.3 Opérations élémentaires sur les
nombres.
On peut mélanger les types integer, real, double
Un programme élémentaire pourrait donc être : precision, complex et double complex au sein de la
program addition ! DEBUT DU PROGRAMME même expression. Ainsi :
implicit none ! PAS DE DECLARATIONS IMPLICITES
real :: a, b, c ! DECLARATION DE 3 VARIABLES REELLES complex :: z, t
! DEBUT DES INSTRUCTIONS EXECUTABLES integer :: k = 392
b = 1.414 ! PLACER LA VALEUR 1.414 DANS b real :: x = 1.03 , y = 0.707
c = 1.732 ! PLACER LA VALEUR 1.732 DANS c z = (3.7,9.03)
a = b + c ! SOMMER & PLACER LE RESULTAT DANS a t = x**2 + (k-1)/z**y
write(*,*) a ! IMPRIMER LE CONTENU DE a
end ! FIN DU PROGRAMME calcule x2 + k −y 1 . Le résultat est un nombre complexe.
z
Noter qu’un nombre complexe s’écrit en donnant parties
qui calcule la somme de 1,414 et 1,732 et imprime le
résultat (instruction write). Il faut noter que le passage réelle et imaginaire entre parenthèses et séparées par une
à la ligne signifie la fin d’une instruction, à la différence virgule.
d’autres langages comme pascal ou C. On peut cepen-
dant écrire plusieurs instructions par ligne en les séparant
par un point-virgule, ainsi : 2.3 Premières boucles.
program addition
implicit none 2.3.1 Pour quoi faire ?
real :: a, b, c L’une des grandes qualités des ordinateurs est leur ca-
b = 1.414 ; c = 1.732 ; a = b + c pacité à effectuer des calculs répétitifs avec des valeurs
write(*,*) a numériques différentes. Imaginons par exemple que l’on
end veuille calculer x3 pour x variant de -10 à +10 par pas de
La décimale des constantes réelles est marquée par un 0,1. On pourrait bien sûr écrire :
point et non une virgule (1.414 et non 1,414). Une con- implicit none
stante réelle doit comporter un point : 1. est une con- real :: x = -10.0, y
stante réelle, mais 1 est une constante entière, 2./3. est y = x**3
une constante réelle qui vaut 0,666667, alors que 2/3 est x = x + 0.1 ; y = x**3
une constante entière, résultat de la division du nombre x = x + 0.1 ; y = x**3
entier 2 par le nombre entier 3, elle vaut donc zéro ! x = x + 0.1 ; y = x**3
On peut aussi utiliser la notation dite ≪ scien- x = x + 0.1 ; y = x**3
tifique ≫ (comme avec une calculette) pour les nombres x = x + 0.1 ; y = x**3
réels, 1, 6 10−19 s’écrit : 1.6e-19, c’est plus économique ...
qu’aligner de nombreux zéros. . . La lettre e ne désigne pas
etc. L’instruction x = x + 0.1 prend la valeur de x en
ici une variable mais indique l’exposant 16 . mémoire, lui rajoute 0,1 et écrit le résultat dans le même
L’affectation de valeurs initiales à certaines variables emplacement : le contenu de x est donc augmenté de 0,1.
peut être faite directement dans la déclaration : Donc, x commence par valoir -10, puis −10 + 0, 1 = −9, 9
program addition et l’on calcule y, puis 9,8 avec un nouveau calcul de y, etc.
implicit none On remarque cependant que la séquence :
real :: a, b = 1.414, c = 1.732
a = b + c x = x + 0.1 ; y = x**3
write(*,*) a
end doit être répétée autant de fois que l’on veut faire le calcul
(ici, 201 fois).
15. La raison en est que si l’on fait une faute de frappe en tapant le
nom d’une variable (par exemple nb pas au lieu de nbr pas), l’ordi-
nateur créera simplement une nouvelle variable, avec des résultats. . .
imprévisibles ! Si l’on rend obligatoire la déclarations de toutes les 2.3.2 Pratiquement. . .
variables, alors le compilateur détectera en principe une variable
non-déclarée et produira un message d’erreur approprié. Une façon plus élégante de procéder consiste à utiliser
16. on peut parfaitement écrire une instruction du type : e = une boucle afin de répéter un grand nombre de fois le même
1.6e-19, il n’y a aucune confusion possible. calcul en faisant varier un paramètre, ainsi :
Physique numérique, Philippe Depondt 21

implicit none 2.3.3 Boucles imbriquées

integer :: i
real :: x, y Les boucles peuvent être imbriquées les unes dans les
do i = -100, 100 autres :
x = 0.1*i
y = x**3
enddo do k = kmin, kmax
...
signifie que l’instruction y = x**3 doit être répétée pour do ix = ixmin, ixmax
...
toutes les valeurs de l’indice i allant de -100 à 100 :
enddo
ainsi x prend successivement les valeurs -10., -9.9, . . .-
...
0.1, 0., 0.1,. . .9.9, 10. 17 et l’on doit calculer y pour cha- enddo
cune de ces valeurs. L’instruction enddo marque la fin du
≪ bloc ≫ : toutes les instructions comprises entre do et

enddo font partie du même ensemble qui doit être exécuté ainsi, la boucle interne sur x s’exécutera pour chaque
pour chaque valeur de i. valeur de k et les instructions qu’elle comporte se
Il faut remarquer au passage qu’à chaque tour de la répéteront donc (kmax-kmin+1)*(ixmax-ixmin+1) fois :
boucle la variable y est modifiée et que donc les anciennes cela peut faire beaucoup. Par exemple, si kmax=1000,
valeurs sont oubliées : à la fin, seule la dernière valeur kmin=1, ixmax=10000, ixmin=1, la boucle interne
calculée reste. Il faut donc penser à faire quelque chose s’exécutera 107 fois, et si elle prend 10−3 seconde à
des valeurs intermédiaires si on en a besoin : les écrire par l’exécution, le programme, lui, prendra 104 s soit 2h45mn !
exemple. Ainsi, Si maintenant, la boucle externe est elle-même imbriquée
dans une autre boucle, on obtient très facilement un pro-
implicit none gramme très lourd. . .
complex :: z, zim=(0.0,1.0)
integer :: i
real :: omega = 6.283185, t
do i = 0, 1000 2.3.4 Boucles munies d’un nom
t = 0.1*i
z = exp(zim*omega*t) ; write(*,*) t, z Quand plusieurs boucles sont imbriquées, il est parfois
enddo utile de leur donner un nom afin de clarifier le début et la
fin de chacune :
va calculer z = eiωt pour t variant de 0 à 100, par pas de
0, 1 et écrire les résultats sur l’écran. Noter la déclaration
boucle1 : do k = kmin, kmax
du nombre imaginaire i dans la variable zim, dont la partie
...
réelle est nulle et la partie imaginaire égale à 1. ...
Un autre exemple : boucle2 : do i = imin, imax
...
implicit none
...
integer :: k, s2 = 0
enddo boucle2
do k = 1, 10
...
s2 = s2 + k**2
...
enddo
enddo boucle1
calcule la somme des 10 premiers carrés.
Le pas de la boucle est implicitement égal à 1, mais on
peut le choisir explicitement :
2.4 Conditions.
do k = 1, 10, 2
s2 = s2 + k**2 Il arrive que l’on veuille que certaines instructions ne
enddo s’exécutent que dans certaines conditions. Par exemple, si
l’on a calculé une quantité y, on peut en vouloir la racine
calcule la somme 12 + 32 + 52 + 72 + 92 , et : carrée uniquement si y est positif :

do k = 10, 1, -1
...
enddo
descend de 10 à 1.
Note ≪ esthétique ≫ : les instructions du bloc compris
dans la boucle sont décalées d’une ou plusieurs colonnes,
c’est l’indentation. Cela ne présente aucun caractère obli-
gatoire et ne fait pas partie des règles du langage, mais
c’est une bonne habitude qui rend la lecture des pro-
grammes nettement plus facile.
17. On note au passage que l’expression 0.1*i mélange une con-
stante réelle et un entier : le résultat est réel.
if( y > 0.0 ) then
z = sqrt(y)
endif
La fonction sqrt qui calcule la racine carrée (square root)
est dite ≪ intrinsèque ≫ parce qu’elle fait partie des fonc-
tions que tout compilateur fortran doit fournir.
L’expression y > 0.0 est du type logique, cela signifie
qu’elle ne peut prendre que deux valeurs : .TRUE. (vrai)
si y > 0 et .FALSE. (faux) si y ≤ 0.
Deux écritures sont possibles pour les opérateurs
logiques, première et deuxième colonnes ci-dessous :
22 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

> .gt. > (greater than) if( y < 0.0 ) write(*,*) ’y est negatif !’
< .lt. < (less than) z = sqrt(y)
>= .ge. ≥ (greater or equal )
<= .le. ≤ (less or equal ) Ici, on se borne à mettre un message d’avertissement, mais
== .eq. = (equal ) l’instruction suivante s’exécutera de toutes façons et le
/= .ne. 6 = (not equal ) programme donnera la valeur NaN (Not a Number ) à z.
.and. et On peut aligner autant de else if que l’on souhaite 18 .
Cependant si l’on a une série de possibilités à envisager,
.or. ou
l’instruction select case 19 peut être plus commode. Par
.not. contraire d’une expression logique exemple :
Ne pas oublier les points de part et d’autre des implicit none
opérateurs logiques de la deuxième colonne. L’opérateur integer :: a
logique == qui est une comparaison, est distinct du signe write(*,*) ’entrer un nombre’; read(*,*) a
≪ d’égalité ≫ = qui signifie en fait ≪ mettre quelque chose
select case( a )
dans une variable ≫. L’expression : case( : 1 )
write(*,*) ’a est plus petit ou egal a 1’
a == b
case( 10 : )
est une expression logique qui prend une valeur, soit vraie write(*,*) ’a est plus grand ou egal a 10’
soit fausse, et case (2 : 3 )
write(*,*) ’a est entre 2 et 3’
a = b case default
write(*,*) ’a est entre 4 et 9’
est une instruction qui place la valeur de b dans a. . ., ainsi, end select
end
integer :: a, b
logical :: ok Un autre exemple, pour convertir des unités anglo-
ok = a == b saxonnes en unités métriques :
signifie que la variable logique ok prend la valeur .TRUE. program metre
si a et b sont égaux et .FALSE. sinon. implicit none
On peut aussi utiliser des variables logiques de façon real, parameter :: c = 0.3048, kt = 1.852, &
plus compliquée : mph = 1.609, &
gallon = 3.7854118, lbs = 0.45455
logical :: ok real :: l
real :: x, y character(len=10) :: unit
...
... ! le premier argument de la ligne de commande est la
ok = y > 0.0 .and. x <= y ! quantite, le deuxieme l’unite.
if (.not. ok ) then ! s’il n’y a pas deux arguments, poser la question
write(*,*) ’Il y a un probleme quelque part’ ! explicitement
stop if ( command_argument_count() >= 2 ) then
endif call get_command_argument(1,unit)
read(unit,*) l ! convertir la chaine de caracteres
L’instruction stop arrête l’exécution du programme.
! en reel (cf ’chaines de caracteres’)
On peut prévoir une alternative : si une condition est call get_command_argument(2,unit)
vérifiée, on fait une chose, sinon on fait autre chose : else
if( y >= 0.0 ) then write(*,’("Entrer la longueur et l’’unite ",$)’)
z = sqrt(y) read(*,*) l, unit
else endif
write(*,*) ’y est negatif’ select case(trim(unit))
stop case (’ft’,’feet’,’foot’,’pieds’,’pied’)
endif write(*,*) l*c,’ metres’
case (’in’,’inch’,’inches’,’pouces’,’pouce’)
Le deuxième volet de l’alternative peut être lui-même write(*,*) 1000.*l*c/12.,’ mm’
soumis à condition :
18. Pour bien apprécier le confort (et la sécurité) qu’apporte la
if( y >= 0.0 ) then structure if(...) then, il faut rappeler le fonctionnement du if
arithmétique en usage dans les premières version du langage for-
z = sqrt(y) tran :
else if ( y > -0.0001 ) then if(k) 100,101,102
write(*,*) ’y est compris entre -0.0001 et 0.0 :’ 100 ....
write(*,*) ’on le considere comme presque nul’ go to 103
z = 0. 101 ....
else go to 103
102 ...
write(*,*) ’y est franchement negatif’
103 ...
stop ce qui signifie que si k est négatif, l’on va à l’étiquette 100, si k est
endif nul, alors on va en 101 et sinon en 102, après quoi, l’instruction située
en 103 est exécutée. Bien évidemment, rien n’empêche, par exemple,
Si l’on n’a qu’une instruction à exécuter dans le if, on un go to 101 n’importe où ailleurs dans le programme. . .
peut la fusionner dans l’instruction if : 19. héritière du go to calculé d’antan.
Physique numérique, Philippe Depondt 23

case(’m’,’metres’) program racines

write(*,*) l/c,’ ft’ implicit none
case(’kt’,’kts’,’knots’,’noeuds’) real :: xmin, xmax, dx, x, y
write(*,*) l*kt,’ km/h’ integer :: i, imin, imax
case(’nm’) write(*,*) ’** Ce programme calcule **’
write(*,*) l*kt,’ km’ write(*,*) ’** une serie de racines carres **’
case(’mph’) write(*,*) ’Tapez sur le clavier’
write(*,*) l*mph,’ km/h’ write(*,*) ’les valeurs de xmin et xmax :’
case(’mile’,’miles’) read(*,*) xmin, xmax
write(*,*) l*mph,’ km’ write(*,*) ’Donnez egalement le pas :’
case( ’gal’, ’gallon’, ’gallons’) read(*,*) dx
write(*,*) l*gallon, ’l’ imin = xmin/dx ; imax = xmax/dx
case(’lbs’, ’lb’, ’pound’, ’pounds’,’livre’, ’livres’)do i = imin, imax
write(*,*) l*lbs, ’kg’ x = i*dx
case default if( x < 0.0 ) then
write(*,*) ’unite inconnue’ write(*,*) ’x est negatif : x=’, x
end select else
end y = sqrt(x)
write(*,*) ’la racine carree de ’,x, ’ est ’, y
de sorte que l’on obtient, par exemple : endif
~$ metres 175 lbs enddo
79.54625 kg end

2.5 Entrées-sorties. 2.5.2 Les fichiers.

2.5.2.1 Fichier texte
Il s’agit des instructions d’écriture et de lecture.
Ce que l’on écrit sur l’écran disparaı̂t assez rapidement.
Si l’on veut conserver des résultats de calcul afin de les
2.5.1 Écran et clavier. relire ou les traiter avec un autre programme ou encore
L’instruction : les utiliser pour tracer une courbe, il faut les écrire dans
un fichier du disque dur de l’ordinateur. Pour cela, il faut
write(*,*) x commencer par ≪ dire ≫ que l’on veut écrire dans un fichier
avec l’instruction open :
écrit sur l’écran du terminal la valeur de x. Si x vaut
3,14159, on obtiendra 3.14159. En revanche : open(1,file=’resultats’)

write(*,*) ’x’ Ainsi, on fait le lien entre le fichier resultats et l’unité

écrira la lettre x sur l’écran, puisque ’x’ désigne une
chaı̂ne de caractères. Par exemple :
write(*,*) ’x=’, x
donnera : x= 3.14159, l’ordinateur commence par écrire
la chaı̂ne de caractères x=, puis la valeur de la variable x.
L’instruction :
read(*,*) x
lit sur le clavier du terminal la valeur de x. Ainsi :
read(*,*) x
write(*,*) ’Vous venez de taper x=’, x
a pour effet que le programme arrivant à l’instruction read
s’interrompt pour attendre que l’on tape quelque chose sur
le clavier, puis repart pour exécuter l’instruction suivante.
Le premier * dans (*,*) après read et write représente
l’unité d’écriture ou de lecture, c’est à dire l’endroit où
l’on écrit ou où l’on lit : il s’agit du clavier à la lecture et
de l’écran à l’écriture. Le deuxième représente le format,
c’est-à-dire, par exemple pour un nombre réel, le nom-
bre de colonnes qu’il doit occuper et le nombre de chiffres
après la décimale : on peut le préciser explicitement, mais
en général le format * (list directed format en anglais ou :
format contrôlé par la liste [des arguments]), où l’ordina-
teur doit se débrouiller avec ce qu’on lui fournit, convient
très bien.
Voici donc un programme qui résume ce qui précède :
1 : maintenant, si l’on écrit dans cette unité, cela revient
à écrire dans ce fichier, par exemple :
open(1,file=’resultats’)
write(1,*) x, y
write(1,*) ’Age du capitaine = ’, agdcpt
écrit dans le fichier resultats.
Lorsqu’on a fini d’écrire on ≪ ferme ≫ le fichier à l’aide
de
close(1)
Ce que l’on obtient est un fichier texte que l’on peut
lire et modifier (sous unix et non dans le programme lui-
même) à l’aide d’un éditeur comme emacs ou vi, par ex-
emple :
emacs resultats &
ou bien, si l’on souhaite seulement le lire sans en modifier
le contenu :
more resultats
Si, dans un même programme, l’on fait plusieurs
écritures à la suite les unes des autres, elles se placeront
les unes derrière les autres dans le fichier tant que l’on ne
ferme pas le fichier avec un close. Mais, si après un close,
l’on refait un open sur le même fichier, on se retrouve au
début de celui-ci et une nouvelle écriture va donc écraser
ce qui s’y trouvait déjà : prudence !
La lecture dans un fichier se fait de la même façon :
24 Licence de physique L3 : PHYTEM,
open(10, file=’donnees’)
read(10,*) a, b, c
close(10)
On peut ouvrir plusieurs fichiers simultanément à con-
dition de leur donner des numéros d’unité différents :
open(10, file=’coefficients’)
open(11, file=’bornes’)
open(12, file=’polynome’)
read(10,*) a, b, c
read(11,*) xmin, xmax, dx
imin = xmin/dx ; imax = xmax/dx
do i = imin, imax
x = i*dx
y = (a*x + b)*x + c
write(12,*) x, y
enddo
close(10) ; close(11) ; close(12)
end
Caveat ! Imaginons que l’on ait écrit un programme
dans un fichier-source calcul.f90. On compile avec la
commande habituelle et on lance l’exécution. . ., or dans le
programme, il y a les instructions :
open(10,file=’calcul.f90’)
write(10,*) x, y, z
close(10)
Question : qu’arrivera-t-il au programme-source ?
Ce sont des choses que l’on voit régulièrement arriver,
au grand désarrois des victimes, car il ne reste plus alors
qu’à tout retaper même si calcul.f90 comportait des cen-
taines de lignes ! Un homme - ou une femme - prévenu(e)
en vaut deux. . .
2.5.2.2 Fichier binaire
L’écriture d’un fichier texte suppose que les nombres
qui sont stockés en binaire dans la mémoire vive de
l’ordinateur soient traduits du binaire en caractères al-
phanumériques : par exemple le nombre entier 19 s’écrit
10011 en binaire et doit être converti en un caractère 1
suivi du caractère 9 avant d’être écrit comme du texte.
Il arrive que l’on ait à produire un très grand nombre
de nombres et que cette conversion prenne un temps de
calcul non négligeable, sans compter la taille du fichier
résultat. Dans ce cas, on peut avoir intérêt à écrire di-
rectement du code binaire dans le fichier. Evidemment,
dans ces conditions on ne peut plus lire ce fichier avec un
éditeur ou l’imprimer sur une imprimante, mais cet in-
convénient n’est pas très important dans le cas présent :
qui irait lire directement un fichier de plusieurs centaines
de kilo-octets de nombres ? Le but ici est de stocker des
données en vue d’une utilisation ultérieure à l’aide d’un
autre programme 20 .
Lors de l’ouverture, il suffit de spécifier que le fichier
doit être ≪ non-formatté ≫ :
open(1,file=’nfich binaire’,form=’unformatted’)
Les instruction d’écriture et de lecture se passent alors
de spécification de format :
write(1) x, y, z
read(1) a, b, c
20. Il faut aussi signaler qu’un tel fichier est moins transportable
qu’un fichier texte : le codage binaire dépend du processeur et si l’on
veut utiliser des données sur une autre machine que celle où elles ont
été produites (par exemple un gros calculateur vers un PC linux),
alors il est parfois indispensable de passer par l’étape texte.
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
2.5.3 Les formats.
Pour une écriture en mode texte, fichier ou écran, on
peut préciser la façon dont on veut que les choses soient
écrites. Ainsi,
write(*,’(i5)’) k
écrira le nombre entier (i pour integer ) k avec 5 chiffres.
On notera la syntaxe : la deuxième * du write est rem-
placée par : ’(...)’ où les trois points désignent la de-
scription du format. De même :
write(*,’(f10.3)’) r
doit écrire le nombre réel (f pour float, c’est-à-dire à
décimale flottante) r avec 10 caractères (y compris le point
de la décimale) dont 3 après la ≪ virgule ≫ : 123456.789 ou
1.414 (avec 5 espaces, représentés ici par le symbole
, pour compléter). Si l’on doit écrire plusieurs nombres
à la suite de la même façon, il n’est pas utile de répéter
explicitement le format, il suffit de le faire précéder du
nombre de fois que l’on veut l’utiliser :
write(*,’(3f12.4)’) x,y,z
écrira trois nombres réels sur 12 caractères (soit 36
colonnes en tout, sachant qu’une feuille de papier ou un
terminal font en général 80 colonnes) avec chacun 4 chiffres
après la décimale, par exemple :
1234567.8912 3.14161048576.4321
attention, dans cet exemple, il y a bien trois nombres,
mais le dernier occupe les 12 colonnes, et donc, il n’y a
pas d’espace qui le sépare du précédent.
On peut mettre des chaı̂nes de caractères dans un for-
mat :
write(*,’("L’’age du capitaine est : ")’)
write(*,’(i2," ans")’) age_captain
Dans ce cas, il vaut mieux, bien sûr, que le capitaine ne
soit pas centenaire. . . Noter que l’apostrophe doit être re-
doublée (sinon le compilateur interprête cela comme la fin
de la chaı̂ne de caractères).
Le format exponentiel ( ou ≪ notation scientifique ≫)
est une autre possibilité pour les réels, par exemple :
ev =1.6e-19
write(*,’("eV=",e13.5)’) ev
donne : eV= 0.16000E-18, soit 13 caractères, dont 5
après la virgule. Le format g (général) combine f et e
x = 1. ; ev = 1.6e-9
write(*,’("x=",g13.5," eV = ",g13.5)’) x, ev
donne : x= 1.00000 eV = 0.16000E-08. C’est assez
commode lorsqu’on veut écrire des nombres dont on ne
connait pas a priori l’ordre de grandeur, tout en contrôlant
la place qu’ils prendront pour une mise en page.
La lettre x dans un format signifie un espace, le symbole
/ un passage à la ligne. Au contraire, $ inhibe le passage
à la ligne après un write 21 . Par exemple :
write(*,’("Donnez l’’age du capitaine : ",$)’)
read(*,*) agecpt
Lors de l’exécution du programme, la question et la
réponse apparaı̂tront sur la même ligne du terminal.
Les chaı̂nes de caractères peuvent s’écrire avec le format
a:
salut = "Bonjour"
write(*,’(a7)’) salut
21. Là encore, c’est une syntaxe qui est en train, d’évoluer : main-
tenant, on écrit plutôt, write(*,’("Donnez l’’age du capitaine :
")’,advance=’no’)
Physique numérique, Philippe Depondt 25

2.6 Les fonctions intrinsèques. 2.7 Autres boucles.

fortran fournit un grand nombre de fonctions in- 2.7.1 do while
trinsèques comme sqrt déjà vu et qui permet de calculer
la racine carrée de son argument. La boucle do while permet des logiques plus com-
En voici quelques unes : pliquées que celles qu’on a déjà vues, par exemple :
sqrt racine carrée open(1,file=’donnees’)
abs valeur absolue read(1,*) x
exp exponentielle do while ( x > 0. )
log logarithme write(*,*) ’La racine de’,x,’ est’, sqrt(x)
log10 logarithme décimal read(1,*) x
sin sinus enddo
asin arcsinus close(1)
cos cosinus
va lire des valeurs de x dans le fichier tant que la dernière
acos arccosinus
valeur de x reste positive, et à la première valeur négative
tan tangente
trouvée, l’on passera à l’instruction close.
atan arctangente
–Exercice : trouver pourquoi l’on a mis le write avant
int troncature d’un réel en entier
le read.
nint arrondi d’un réel (nearest integer )
L’avantage de ce type de boucle est que l’on peut faire
real partie réelle d’un nombre complexe des choses assez sophistiquées ; c’est séduisant, souvent ef-
aimag partie imaginaire d’un nombre complexe ficace, mais parfois dangereux, ainsi :
conjg conjugué d’un nombre complexe
trim troncature d’une chaı̂ne de caractères implicit none
après le dernier non-blanc real :: x, dx = 0.1
len trim nombre de caractères de la chaı̂ne tronquée ....
x = 1.0
Par exemple : do while ( x > 0.0 )
implicit none ...
real :: e0, t, omega, tfin, dt x = x + dx
integer :: it, itfin ..
... enddo
itfin = tfin/dt
do it = 0, itfin –Exercice : montrer pourquoi cette boucle va tourner
t = it*dt ; write(1,*) t, e0*cos(omega*t) indéfiniment. . .
enddo
Les arguments des fonctions trigonométriques sont en ra- 2.7.2 Boucles infinies : exit et cycle.
dians, donc si l’on veut travailler en degrés, il faut faire la
conversion : On peut aussi faire des boucles ≪ infinies ≫ dont on ne
sort que grâce à exit :
real :: pi, angle
pi = acos(-1.0) do
write(*, ’("Donnez un angle en degres : ",$)’) write(*,’("Entrer un nombre positif : ",$)’)
read(*,*) angle read(*,*) x
write(*,*) ’le sinus de ’, angle,’ degres’ if ( x >= 0. ) exit
write(*,*) ’est ’, sin(pi*angle/180.) write(*,*) "Apprenez a lire !"
La différence entre int et nint est que si x vaut, par ex- enddo
emple 1,6, alors int(x) donne 1 alors que nint(x) donne y = sqrt(x)
2.
Tant que l’on entrera des nombres négatifs, on aura droit à
On peut utiliser une fonction comme argument d’une
l’aimable invitation d’apprendre à lire, mais dès le premier
autre, ainsi, par exemple, le module d’un nombre com-
nombre positif, le programme en calculera la racine carrée.
plexe z s’écrit
√ : sqrt(z*conjg(z)), la transcription de L’instruction cycle permet de répéter une boucle par-
l’expression zz ∗ . tiellement :
La commande info g77 permet d’accéder, après
quelques manipulations, à la liste des fonctions in- do
trinsèques connues par g77 (il y en a beaucoup) ainsi qu’à write(*,’("Entrer un nombre positif : ",$)’)
leur mode d’emploi. Ces renseignements sont donnés en read(*,*) x
anglais, mais il n’est pas mauvais de se frotter de temps if ( x < 0 ) cycle
en temps à ce genre de documentation. Ces informations y = sqrt(x)
ne sont évidemment valides en toute rigueur que pour g77, write(*,*) ’La racine carree de’,x,’ est ’, y
toutefois les fonctions les plus usuelles sont communes ; si if( x == 0. ) exit
enddo
le compilateur utilisé ne reconnait pas une fonction sup-
posée intrinsèque 22 , il faut alors consulter une documen- en type réel, et realpart(z), partie réelle d’un complexe, alors que
tation spécifique (Fortran95/2003 explained par exemple). la norme fortran95 prévoit que real prenne justement la partie
réelle si son argument est complexe si bien que realpart n’existe
22. Par exemple, g77 fait la distinction entre real(z), conversion pas.
26 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

à chaque fois que l’on tape un nombre négatif, l’on obtien- 2.7.3 Boucles implicites.
dra la requête d’un nombre positif sans que le calcul de la
Plutôt qu’écrire :
racine ne soit fait ; en revanche, si l’on entre un nombre
positif, on en obtiendra la racine, et enfin si ce nombre est do i = 1, n
nul (strictement : on verra un peu plus loin ce que cela write(1,*) x(i)
signifie) on sort de la boucle. enddo
Autre exemple : vérifier qu’un fichier existe déjà avant
de tenter de l’ouvrir en lecture, on peut écrire :

! declaration d’une chaine de 40 caracteres write(1,*) ( x(i), i = 1, n )

! qui devra contenir le nom du fichier
La différence est que dans le deuxième cas tous les éléments
character (len=40) :: n_fic ! nom de fichier
du tableau 24 sont écrits sur la même ligne, sauf si on le
logical :: ok ! variable logique
précise par format. Plus concis encore, si x est un tableau :
do write(1,*) x
write(*,’(‘‘Nom du fichier de donnees : ‘‘,$)’)
read(*,*) n_fic ! lire au clavier le nom du fichier écrit tout le tableau.
! inquire est une commande FORTRAN permettant de On peut faire la même chose avec read.
! verifier l’existence du fichier
inquire(file=n_fic,exist=ok) ! existe: ok = .TRUE.
if ( ok ) exit ! et on n’insiste pas
! sinon, il faut recommencer
2.8 Tableaux.
write(*,’(‘‘Fichier non trouve’’)’)
Les tableaux de nombres sont l’équivalent informatique
enddo
open(10,file=n_fic) ! ouverture du fichier des vecteurs et des matrices : on peut ainsi désigner
... plusieurs nombres par une seule variable ; le vecteur V
de dimension n désigne l’ensemble de ses n éléments
Les boucles infinies, assorties de exit et cycle, tendent vi , i ∈ [1, n], la matrice A de dimension (n, m) désigne
à remplacer le do while, souvent considéré comme ob- tous les n × m éléments aij , le tenseur T de rang 3 désigne
solète. Le until du pascal n’existe pas en fortran : de tous les éléments tijk , et ainsi de suite. Comme dans ces
fait, exit et cycle sont beaucoup plus riches, puisqu’ils exemples, un ou plusieurs indices entiers servent à indiquer
peuvent être placés n’importe où dans la boucle, et non l’élément voulu du tableau. Avec les tableaux, on acquiert
seulement au début comme while ou à la fin comme la capacité à traiter, comme s’il s’agissait d’une seule en-
until 23 . tité, un grand nombre de données, pour ainsi dire ≪ d’un
Si les boucles ont un nom, exit et cycle en tiennent coup ≫ !
compte :

l1 : do 2.8.1 Déclaration
...
La déclaration d’un tableau est faite en indiquant les
l2 : do
valeurs extrêmes des indices de chacune des dimensions
...
du tableau, par exemple :
if ( age_du_capitaine < 0 ) exit l1
... real, dimension(1:100) :: x
if ( ok ) cycle l2
... déclare un tableau à un seul indice qui va de 1 à 100, c’est-
enddo l2 à-dire un tableau unidimensionnel de réels à 100 éléments
... ou un vecteur à 100 coordonnées si l’on préfère. Le i-ème
enddo l1 élément est désigné par x(i) ; i est bien entendu un entier.
Par exemple :
Le exit l1 fait sortir de la boucle l1, la plus externe, alors
que l’instruction se trouve dans la boucle la plus interne : real, dimension(0:100) :: x
ça permet de sauter par dessus un niveau d’imbrication. real :: pi = acos(-1.0)
integer :: i
23. L’intérêt de ces structures est réel, toutefois pour relativiser,
notons qu’en fortranIV, on pouvait très bien fabriquer des logiques do i = 0, 100
similaires à ce que permettent exit et cycle, l’esprit était simple-
x(i) = cos(i*pi/100.)
ment moins orienté ≪ programmation par bloc ≫ et il fallait s’as-
treindre à un minimum de discipline, par exemple : enddo
do 100 i = 1, 1000000
... remplit un tableau de 101 éléments avec les valeurs prises
c ici l’equivalent d’un ‘‘cycle’’ par cos θ avec θ ∈ [0, π] par pas de π/100.
if ( x .gt. y ) go to 100 On peut faire des déclarations du genre :
...
c ici l’equivalent d’un ‘‘exit’’ real, dimension(-100:100) :: x
if ( z .le. 0. ) go to 200
...
100 continue
ce qui donne dans ce cas un tableau à 201 éléments dont
200 ... l’indice varie de -100 à 100, et alors, on peut accéder à des
Il était prudent d’éviter de placer l’étiquette 200 à l’autre bout éléments comme par exemple x(-20).
du programme, du moins si l’on avait l’ambition d’écrire un code
≪ maintenable ≫. . . 24. voir les tableaux dans la section suivante.
Physique numérique, Philippe Depondt 27

La déclaration real, dimension(100) :: x est correspondant et toutes les boucles s’adaptent automa-
équivalente à real, dimension(1:100) :: x 25 . tiquement.
Pour les tableaux à plusieurs dimensions, il faut spécifier Finalement, il est possible d’initialiser un tableau dans
les valeurs extrêmes de chacun des indices : la déclaration, comme un scalaire :
integer, dimension(1:25,-2:2) :: a real, dimension(-2:2) :: x=(/-4,-2,0,2,4/)
ici, x(-2) = -4, x(-1) = -2, etc. Une boucle implicite
déclare un tableau à deux dimensions d’entiers de 25 × 5. peut aussi être utilisée pour le même résultat :
Le premier indice va de 1 à 25, le deuxième de -2 à 2.
integer :: i
Un élément est donc désigné, par exemple, par a(i,j) ou real, dimension(-2:2) :: x=(/ (2*i, i=-2,2) /)
a(12,-1).
L’exemple suivant :
2.8.2 Manipulation globale de tableaux
integer :: i
complex, dimension(200) :: s 2.8.2.1 n d’un coup ! (mieux que le petit tailleur)
complex :: im = (0.,1.)
On peut faire des calculs en manipulant les éléments de
real :: omega, t
tableaux un à un dans des boucles comme dans les exem-
omega = 2*acos(-1.0)
do i = 1, 200 ples ci-dessus ; c’est d’ailleurs ce que l’on faisait jusqu’à
t = (i-1)*0.005 ; s(i) = exp(im*omega*t) l’apparition de fortran90 26 . La manipulation globale
enddo de tableaux est sans doute l’apport le plus important de
fortran90 par rapport aux langages qui l’ont précédé ;
déclare un tableau complexe de 200 éléments et le remplit. c’est aussi un ingrédient qui facilite beaucoup les calculs
Il peut être commode de remplacer une dimen- numériques dès qu’ils deviennent un peu lourds.
sion explicitement fixée à une certaine valeur, du type Admettons que les éléments du tableau c doivent être
dimension(100), par dimension(n) où n est un nombre la somme des éléments correspondants des tableaux a et
entier. Il faut alors déclarer n comme un paramètre, c’est-
b:
à-dire un nombre dont on ne peut pas changer la valeur
en cours d’exécution du programme. Ainsi : integer, parameter :: n = 1000
integer :: i
integer, parameter :: l = 20, m = 100, n = 30 real, dimension(n) :: a, b, c
real, dimension(l,m) :: x !....
real, dimension(m,n) :: y ! il faudrait lire les elements de a et b
real, dimension(l,n) :: z ! dans un fichier par exemple.
integer :: i, j, k do i = 1, n
c(i) = a(i) + b(i)
open(10,file=’fichier.x’) ! lecture x enddo
do j = 1, m
do i = 1, l En fortran90, la boucle peut se résumer en une seule
read(10,*) x(i,j) instruction :
enddo c = a + b ! ici on fait n additions.
enddo
close(10)
le compilateur se chargeant de vérifier que tous les
open(10,file=’fichier.y’) ! lecture y
tableaux concernés ont bien la même dimension. . . On
do j = 1, n
peut donner explicitement les bornes :
do i = 1, m c(1:n) = a(1:n) + b(1:n)
read(10,*) y(i,j) ce qui a le même résultat que ci-dessus : ça n’a au-
enddo cun intérêt dans cet exemple, mais imaginons que l’on
enddo veuille additionner la première moitié du tableau a avec la
close(10) deuxième moitié du tableau b et inversement, la deuxième
do j = 1, n ! produit matriciel moitié de a avec la première de b :
do i = 1, l
z(i,j) = 0. c(1:n/2) = a(1:n/2) + b(n/2+1:n)
do k = 1, m c(n/2+1:n) = a(n/2+1:n) + b(1:n/2)
z(i,j) = z(i,j) + x(i,k)*y(k,j) ou bien que l’on ne s’intéresse qu’aux éléments impairs :
enddo
c = 0. ! initialisation de c
enddo
c(1:n:2) = a(1:n:2) + b(1:n:2)
enddo
le dernier indice étant le pas, comme pour une boucle do 27 .
déclare 3 tableaux de 20 × 100, 100 × 30 et 20 × 30, lit les
26. Plus précisément, certains constructeurs d’ordinateurs à ca-
valeurs des éléments de x et y dans des fichiers et fait le pacité vectorielle avaient commencé à produire dans les années 1980
produit des deux matrices dans z (attention à la différence des compilateurs fortran8X spécifiques à leurs machines : for-
entre le chiffre 1 et la lettre l). tran90 est l’héritier de ces innovations.
Malgré son apparente complexité, l’avantage de cette 27. Il faut toutefois faire un peu attention car la norme ne garan-
tit pas que les opérations effectuées dans un traitement global de
façon de déclarer les tableaux est que si l’on veut, dans une tableau se fassent dans l’ordre des indices de sorte que si un calcul
nouvelle version du programme, changer une dimension dépend d’un résultat obtenu précédemment sur un élément d’indice
d’un tableau, il suffit de changer la valeur du paramètre inférieur, il faut écrire explicitement une boucle. En revanche, cer-
tains ordinateurs sont optimisés pour ce genre de calcul et un traite-
25. à la différence du langage C pour lequel les tableaux commen- ment global, quand il est possible, peut se traduire par un gain de
cent avec l’élément 0. temps sensible.
28 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

2.8.2.2 where c’est, encore une fois, l’équivalent d’une boucle car x et y
ne sont pas des scalaires mais des tableaux de nombres et,
Finalement, les conditions s’expriment à l’aide de where
avec une syntaxe très proche du if, sauf qu’évidemment en une ligne, est concentré un calcul de 5000 sinus. . .
il s’agit maintenant de tableaux pris globalement : fortran90 offre en outre une panoplie de fonctions
intrinsèques spécialement destinées aux opérations sur
integer, parameter :: n = 5000 les tableaux, par exemple, pour obtenir la somme des
real, dimension(n) :: x, y éléments d’un tableau :
! ....
where ( x >= 0.) integer, parameter :: n = 2048
y = sqrt(x) real, dimension(n) :: x
else where real :: y
y = 0. ! ....
end where y = sum(x)

on calcule donc les racines carrées de tous les éléments ou de façon plus sophistiquée, la somme des éléments posi-
positifs du tableau x, et l’on annule y pour les éléments tifs d’un tableau :
négatifs de x : c’est l’équivalent de la boucle :
integer, parameter :: n = 6723
integer, parameter :: n = 5000
real, dimension(n) :: x
real, dimension(n) :: x, y
real :: y
integer :: i
! ....
! ....
y = sum(x, mask = x >= 0.)
do i = 1, n
if ( x(i) >= 0.) then ce qui suit mask devant être un tableau logique de la bonne
y(i) = sqrt(x(i)) dimension. La moyenne des racines carrées donnerait :
else
y(i) = 0. y = sum(sqrt(x), mask = x >= 0.)/count(x >= 0.)
endif
enddo La fonction intrinsèque count compte le nombre de fois
où la condition est vraie.
2.8.2.3 forall Si le tableau est multidimensionnel, on spécifie la di-
mension sur laquelle la somme doit être faite :
Imaginons toutefois que l’on veuille, par exemple, créer
la matrice identité d’ordre n : integer, parameter :: n = 237, m = 53
  real, dimension(n,m) :: x
1 0 0 ... 0 0 real, dimension(m) :: y
 0 1 0 ... 0 0  ! ....
 
 0 0 1 ... 0 0  y = sum(x, dim = 1, mask = x >= 0.)
 
I= . . . . 
 .. .. .. . . ... ..
. n
  X
 0 0 0 ... 1 0  donne : yj = xi,j , ∀j ∈ [1, m], le résultat est donc
0 0 0 ... 0 1 i=1
xi,j ≥ 0
il faut pouvoir accéder aux termes diagonaux de la ma- évidemment un tableau. On peut écrire de façon plus suc-
trice : une boucle do peut faire l’affaire, mais celle- cinte :
ci impose que les opérations demandées soient ef-
fectuées séquentiellement dans l’ordre indiqué par l’indice ; y = sum(x, 1, x >= 0.)
sur certains ordinateurs cela peut sensiblement ralentir
l’exécution. L’instruction forall est très similaire à do La fonction product, d’usage similaire, fait le produit
mais lève cette contrainte, ainsi : des éléments d’un tableau.
Xn
real, dimension(n,n) :: id ! matrice identite Le produit scalaire z = xi yi s’obtient avec
... i=1
id = 0. ! mise a zero des n*n termes dot product :
forall ( i = 1:n ) id(i,i) = 1.0 ! n termes diagonaux
integer, parameter :: n = 8000
Noter que la syntaxe est un peu différente que celle de do. real, dimension(n) :: x, y
On a aussi : real :: z
! ....
forall ( i = 1:n ) z = dot_product(x,y)
...
end forall m
X
et le produit de deux matrices ci,j = ai,k bk,j avec
k=1
2.8.3 Fonctions intrinsèques et tableaux matmul :
Les fonctions intrinsèques du fortran s’accommodent
integer, parameter :: n = 100, m = 50, p = 32
très bien de tableaux, par exemple :
real, dimension(n,m) :: a ! attention au
integer, parameter :: n = 5000 real, dimension(m,p) :: b ! dimensionnement
real, dimension(n) :: x, y real, dimension(n,p) :: c ! des tableaux
! .... ! ....
y = sin(x) c = matmul(a,b)
Physique numérique, Philippe Depondt 29

Nom Type Description

Fonctions mathématiques
count(l,mask,dim) entier nombre de fois où le tableau logique l est vrai, selon la
dimension dim quand mask est vrai
dot product(a,b) numérique, même type que a et b produit scalaire des tableaux unidimensionnels a et b
matmul(a,b) numérique, même type que a et b produit des deux matrices a et b
maxloc(a,dim,mask) entier position du plus grand élément du tableau a selon la
dimension dim quand mask est vrai.
maxval(a,dim,mask) entier ou réel valeur du plus grand élément du tableau a selon la
dimension dim quand mask est vrai.
minloc(a,dim,mask) entier position du plus petit élément du tableau a selon la
dimension dim quand mask est vrai.
minval(a,dim,mask) entier ou réel valeur du plus petit élément du tableau a selon la
dimension dim quand mask est vrai.
product(a,dim,mask) numérique, du même type que a produit des éléments du tableau a selon la dimension dim
quand mask est vrai
sum(a,dim,mask) numérique, du même type que a somme des éléments du tableau a selon la dimension dim
quand mask est vrai
Transformations de tableaux
cshift(a,shift,dim) indifférent permutation circulaire des éléments du tableau a selon la
dimension dim. Si shift est positif, déplacement de
shift positions à gauche, sinon à droite
eoshift(a,shift, indifférent décalage des éléments du tableau a selon la dimension dim.
boundary,dim) Si shift est positif, déplacement de shift positions à gauche,
sinon à droite. Les éléments manquants à l’extrémité sont
remplacés par ceux de boundary, ou zéro si boundary absent.
pack(a,mask, indifférent transforme le tableau multidimensionnel a en un tableau
vector) unidimensionnel quand mask est vrai, les éléments filtrés
par mask étant remplacés par ceux du vecteur vector
unpack(a,mask, indifférent transforme le tableau unidimensionnel a en un tableau
missing) multidimensionnel quand mask est vrai, les éléments filtrés
par mask étant remplacés par ceux de missing. La forme
du tableau résultant est celle de mask

Table 2.8 – Quelques fonctions de manipulation globale de tableaux.

Noter que le résultat fourni par cette fonction est lui-même
une matrice.
Un résumé (non exhaustif) de quelques fonctions que
l’on est amené à utiliser assez souvent est donné dans la
table 2.8 28 .
2.8.4 Allocation dynamique de mémoire
Une déclaration est, comme on l’a déjà vu, une
réservation d’espace dans la mémoire vive de l’ordinateur.
Ainsi, real :: x déclare une variable réelle x et, de ce
fait, réserve 4 octets (ou 32 bits) en mémoire, parce que
c’est la place qu’occupe un réel en simple précision 29 : ces
4 octets sont donc affectés à cette variable et ne peuvent
pas être utilisés à autre chose. De même, lorsqu’on déclare
un tableau, par exemple real, dimension(n) :: x, on
réserve n fois 4 octets. On comprend donc que cette
réservation doive être faite avant l’exécution du pro-
gramme : si l’on veut changer la taille d’un tableau, cela
revient à modifier la taille de l’espace qu’il occupe en
mémoire ; il faut arrêter l’exécution du programme, mod-
ifier le code source, recompiler et relancer l’exécution 30 .
Il existe cependant des quantités de situations dans
28. NE PAS apprendre ce tableau par cœur !
29. pour la plupart des ordinateurs courants. L’usage de mots de
64 bits commence toutefois à se répandre assez rapidement.
30. ou alors, en fortran77, en l’absence d’allocation dynamique
de mémoire, on prévoyait large : on réservait par exemple 1 000 000
d’emplacements pour n’en utiliser finalement que quelques uns.
lesquelles on aimerait pouvoir modifier la taille d’un
tableau en cours d’exécution : par exemple, si l’on a
écrit un programme qui calcule la moyenne des éléments
d’un tableau de nombres de longueur quelconque, il serait
agréable de pouvoir entrer la taille du tableau, puis le di-
mensionner, puis faire le calcul sans avoir à recompiler le
programme à chaque fois que le nombre de nombres dont
on veut la moyenne a changé !
L’allocation dynamique de mémoire permet de déclarer
un tableau sans en donner la taille, puis de lui donner
une taille en cours d’exécution, de le supprimer puis de lui
donner une autre taille, etc. Par exemple :
! declaration d’un tableau unidimensionnel
! sans taille fixe
real, dimension(:), allocatable :: x
integer :: n
!...
write(*,’(‘‘Entrer le nombre d’elements ‘‘,$)’)
read(*,*) n
! affectation d’une taille donnee au tableau
allocate(x(n))
!... ici on fait des calculs
deallocate(x) ! desaffectation
! on recommence avec un tableau plus petit
! qui commence en zero au lieu de un
allocate(x(0:n/2-1))
!...
deallocate(x)
On gère ainsi la mémoire occupée pour ainsi dire ≪ au
30 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

vol ≫, ou plutôt, dynamiquement dans le jargon con- real :: s

sacré. . . s = 0.
do i = 1, m
s = s + i*z(i)
2.9 Fonctions et sous-program- enddo
bsom = s/sum(z)
mes. end ! fin de la function bsom

Rien n’oblige à écrire tous les calculs que l’on veut faire La première partie est ce qu’on appelle le ≪ programme
dans un même programme : c’est même assez déconseillé ! principal ≫, la seconde, la fonction 32 . L’appel de la fonc-
Pour des raisons, ne serait-ce que de lisibilité, on a très tion dans le programme principal est fait normalement, ici
souvent intérêt à découper un gros problème en plusieurs dans une instruction
petits pour lesquels les possibilités de se tromper sont plus write(*,*) bsom(x,n)
faibles 31 . De plus, si le même type de calcul doit être
mais cela pourrait être dans une expression comme
répété à plusieurs endroits du programme (par exemple
un calcul d’intégrale), ce n’est pas la peine de le repro- r = sqrt(2.0)*bsom(x,n) - k
grammer plusieurs fois. Si, enfin, on a déjà écrit (et testé)
un programme qui sait faire un certain type de calcul (par l’usage d’une fonction est donc très similaire à celle des
exemple, calculer une intégrale numérique ou résoudre un fonctions intrinsèques du fortran, comme sin, exp, etc.
système linéaire d’équations), il est utile de pouvoir le Dans la définition de la fonction, on doit écrire explicite-
récupérer et l’insérer dans le programme que l’on est en ment l’expression donnant la valeur de la fonction : si
train de faire sans avoir à le reécrire. Il existe en outre, et l’on oublie l’instruction bsom = s/sum(z), il n’y aura pas
l’on verra dans ce cours un certain nombre d’exemples de d’erreur détectée, le calcul sera fait normalement, mais le
leur utilisation, des bibliothèques de sous-programmes et résultat ne sera pas transmis au programme appelant. La
de fonctions extrêmement riches, telles linpack, lapack, fonction doit se terminer par l’instruction end qui en mar-
nag, imsl. . ., dans lesquelles on peut puiser sans vergogne que la fin, comme le programme principal.
et ainsi éviter de réinventer la roue.
Fonctions et sous-programmes sont donc des ingrédients 2.9.1.2 Les arguments et les variables d’une
essentiels ! function.
Dans cet exemple, la fonction réelle bsom calcule le
2.9.1 Les function. barycentre des éléments de z. Le tableau z est un argu-
ment de la fonction ( function bsom(z,m) ). Dans l’appel
2.9.1.1 Définir une function. de bsom, le premier argument est le tableau x qui doit avoir
On peut écrire ses propres fonctions en plus des fonc- le même type et le même nombre d’éléments que z dans la
tions intrinsèques. On les utilise de la même façon que définition de la fonction : la correspondance entre les vari-
les fonctions intrinsèques mais évidemment, il faut aussi ables du programme principal et celles de la fonction est
les définir, alors que les fonctions intrinsèques sont bien donnée par l’ordre dans lequel elles apparaissent dans l’ap-
sûr prédéfinies. Pour cela, on place les instructions corre- pel et la définition de la fonction. En effet x est la première
spondantes, par exemple dans le même fichier-source que variable qui apparaı̂t dans l’appel de bsom(x,n) dans le
le programme lui-même, mais en dehors de celui-ci (avant programme principal et z est la première dans la définition
program ou après end. Par exemple, supposons que l’on
real function bsom(z,m). Ainsi, x dans le programme
veuille calculer le barycentre, à une dimension, d’un en-
semble de nombres lus dans un fichier : principal et z dans la fonction désignent la même variable ;
de même pour n et m.
program calcul ! debut du programme principal
implicit none 1er, 2e argument
integer, parameter :: n = 100 write(*,*) bsom( x, n) appel, dans p. princ.
real, dimension (1:n) :: x
real :: bsom
ll
← correspondance
real function bsom( z, m) définition
open (1, file=’machin’)
read(1,*) x Attention ! Ce n’est pas parce qu’une variable a le même
close(1) nom dans une fonction qu’une autre dans le programme
write(*,*) ’Le barycentre des elements de X est : ’ principal qu’il s’agit de la même chose ; au contraire, ces
write(*,*) bsom(x,n) ! appel de bsom deux variables même si elles ont le même nom n’ont au-
end ! fin du programme principal cun rapport ! En revanche, une variable du programme
principal représente strictement la même chose qu’une
real function bsom(z,m) ! debut de la function bsom autre, même de nom différent, dans la fonction à condi-
implicit none tion d’avoir été transmise comme argument dans l’appel
integer :: i, m et la définition de la fonction comme dans l’exemple ci-
real, dimension(1:m) :: z
dessus 33 .
31. c’est ce que l’on appelle avec quelque pédanterie ≪ l’analyse Ainsi, la variable x du programme principal est iden-
descendante ≫, c’est-à-dire que l’on divise un problème P a priori tique à la variable z de la fonction, mais la variable s de
compliqué en plusieurs sous-problèmes P1 , P2 , . . ., puis chaque sous-
problème est redivisé en P1,1 , P1,2 , . . . , P2,1 , . . ., etc. On arrête quand 32. ou plus précisèment la définition de la function.
tous les sous-sous-sous-. . .-problèmes sont tellement élémentaires 33. La seule chose qui soit transmise est l’adresse du premier
qu’il n’y a plus de problème ! élément du tableau x. C’est en fait un pointeur masqué !
Physique numérique, Philippe Depondt 31

la fonction bsom est complètement indépendante de ce qui

peut être déclaré dans le programme principal : il pourrait end
très bien y avoir une autre variable s dans le programme
principal sans qu’il y ait la moindre interaction entre les Le sous-programme baryc utilise les données rx, ry, rz,
deux. et masse, ainsi que le nombre de masses impliquées, pour
Lorsqu’on apprend à programmer, c’est une source d’er- rendre les coordonnées du centre de masse et la masse
reur classique et cela paraı̂t inutilement compliqué, mais totale.
à l’usage c’est un grand avantage car ainsi la fonction Noter la différence avec une fonction : on peut
bsom, une fois écrite et testée, est indépendante du cadre insérer l’appel d’une fonction dans une expression,
dans lequel elle est utilisée, on peut donc s’en servir dans écrire : write(*,*) bsom(x,n)/pi ou bien : xtot =
un grand nombre de circonstances sans se préoccuper du 3.*bsom(x,n) + w, mais un sous-programme doit être
détail de la façon dont elle est écrite. Par exemple, on peut appelé par un call. Par ailleurs, une fonction doit être
très bien avoir oublié qu’il y a des variables s et z dans
déclarées car elle a un type : entier, réel, double précision,
bsom, et faire dans le programme principal un appel du
type : logique. . . en revanche, un sous-programme ne doit pas
être déclaré mais bien sûr, ses arguments, eux, doivent
z = bsom(s,m) l’être, car un sous-programme ne prend pas de valeur, mais
se borne à modifier certains de ses arguments.
sans conséquence dramatique, à condition que, dans le pro-
Les autres remarques concernant l’indépendance des
gramme principal, s soit un tableau de m éléments et z un
variables d’une fonction vis-à-vis de celles du programme
scalaire réel.
principal et le dimensionnement des tableaux transmis
Il faut donc se rappeler qu’en fortran, il n’y a pas
comme argument sont aussi valables dans le cas d’un sous-
de variables globales, toutes les variables doivent être ex-
programme.
plicitement transmises de programme appelant à fonction
ou sous-programme.
2.9.3 L’intention
2.9.2 Et les subroutine. On voit, dans l’exemple ci-dessus par exemple, que cer-
tains arguments sont des données que la subroutine doit
Une fonction souffre de la limitation qu’elle ne peut pro- utiliser pour faire ses calculs (m, x, y, z, n), d’autres (mt,
duire qu’une seule valeur comme résultat : ainsi, si l’on gx, gy, gz) des résultats qu’elle doit calculer : les premiers
veut calculer plusieurs choses, il faut faire un sous-pro- sont donc ≪ en entrée ≫, les autres ≪ en sortie ≫, sans que
gramme (subroutine). Par exemple, si l’on veut calculer, rien dans la syntaxe n’indique cette différence. C’est ici
dans l’espace à trois dimensions, le barycentre d’un en- qu’intervient l’idée ≪ d’intention ≫ ou intent en anglais.
semble de masses (donc trois nombres) ainsi que la masse On spécifie, dans les déclaration du sous-programme, si un
totale (un quatrième nombre), on peut procéder comme argument est en entrée ou en sortie, ainsi :
suit : subroutine baryc( gx, gy, gz, mt, x, y, z, m, n )
implicit none
program cmasse
integer, intent(in) :: n
implicit none
real,intent(out) :: gx, gy, gz, mt
integer, parameter :: n = 100
real, dimension(1:n), intent(in) :: m, x, y, z
real, dimension(1:n) :: masse, rx, ry, rz
real :: ogx, ogy, ogz, mtot
mt = sum(m)
integer :: i
gx = dot_product(x,m)/mt
gy = dot_product(y,m)/mt
open(1, file=’masses’)
gz = dot_product(z,m)/mt
do i = 1, n
read(1,*) rx(i), ry(i), rz(i), masse(i)
end
enddo
close(1) Cela a deux conséquences : 1o c’est plus clair pour le pro-
grammeur, 2o le compilateur détectera une erreur si, par
call baryc (ogx,ogy,ogz,mtot,rx,ry,rz,masse,n)
exemple, on essaie de modifier un argument déclaré in.
write(*,*) ’Masse totale : ’, mtot L’intent(inout) existe aussi, pour les arguments dont
write(*,*) ’Coordonnees du centre de masse : ’ on doit utiliser la valeur en entrée, mais que l’on doit
write(*,*) ogx, ogy, ogz également modifier.
end
2.9.4 La mise en commun de variables.
subroutine baryc( gx, gy, gz, mt, x, y, z, m, n ) On a vu que fonctions et sous-programmes étaient à
implicit none peu près étanches vis-à-vis du monde extérieur, à l’excep-
integer :: n tion, évidemment, des variables transmises comme argu-
real :: gx, gy, gz, mt ments : c’est un avantage, mais, c’est parfois un peu rigide.
real, dimension(1:n) :: m, x, y, z On peut alors mettre en commun des variables entre pro-
gramme et sous-programme ou entre sous-programmes ou
mt = sum(m) fonctions différents, à l’aide de modules. Imaginons, par
gx = dot_product(x,m)/mt exemple, un code comprenant un programme principal et
gy = dot_product(y,m)/mt des sous-programmes qui utilisent tous la grandeur π et
gz = dot_product(z,m)/mt les conversions entre degrés et radians. Plutôt que redéfinir
32 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

ces grandeurs dans chaque programme et sous-programme, par le programme principal. Si l’on ne veut pas modifier A
on peut commencer par faire un module, placé au début (si c’est un programme compliqué surtout si on ne l’a pas
du fichier source : écrit soi-même, c’est toujours un peu dangereux), il suffit
de faire un module pour mettre ces variables en commun
module trig_consts
! definition de constantes trigonometriques entre le programme principal et B : on saute, pour ainsi
implicit none dire, par-dessus A !
real, parameter :: pi = acos(-1.0)
real, parameter :: deg_rad = pi/180. 2.9.5 Mettre un nom de sous-programme
real, parameter :: rad_deg = 180./pi
end
comme argument.
Admettons que l’on ait écrit une fonction somdef qui
il s’agit simplement de déclarations (ici de paramètres, sache calculer une intégrale définie : il faut lui transmet-
mais ce n’est pas obligatoire) et, le cas échéant, d’affecta- tre comme argument, outre les bornes xmin et xmax de
tions de valeurs. Dans un programme ou sous-programme l’intégrale et la précision eps souhaitée, le nom de la fonc-
dans lequel on veut utiliser ces variables, il faut spécifier tion à intégrer. Par exemple :
au début des déclarations
xmin = 0. ; xmax = acos(-1.0)
use trig_consts write(*,*) somdef( xmin, xmax, eps, sin )
et les variables pi, deg rad et rad deg sont utilisables sanssi l’on veut calculer l’intégrale de 0 à π de sin x. Cepen-
autre forme de procès ; ainsi, si theta est un angle donné dant, si l’on procède sans précaution, le compilateur di-
en degrés : agnostiquera que la variable sin n’est pas déclarée, et
sin_theta = sin(deg_rad*theta)
dira quelque chose qui peut ressembler à : Error: Symbol
’sin’ at (1) has no IMPLICIT type, ce qui est ab-
est correct même si deg rad n’a pas été déclaré dans le surde puisqu’il s’agit d’une fonction intrinsèque. . . C’est
programme. Quand on fait cela, il faut faire un peu atten- que dans ce contexte là, il ne reconnait pas sin comme
tion, puisque si l’on a une autre variable pi dans un des une fonction : il faut donc le préciser dans les déclarations
programmes qui utilisent ce module, il y aura un conflit avec intrinsic.
détecté par le compilateur. Cependant, comme il faut faire
real :: xmin, xmax, eps, somdef
appel explicitement par use aux modules dont on a be-
intrinsic :: sin
soin dans chaque sous-programme qui l’utilise, les dégats
34 ...
potentiels restent limités : on peut très bien imaginer
xmin = 0. ; xmax = acos(-1.0)
des structures comme :
write(*,*) somdef( xmin, xmax, eps, sin )
module blabla
De même, s’il s’agit d’une fonction mafct que l’on a écrite
! acceleration de la pesanteur terrestre
soi-même, il faut la déclarer par external
real, parameter :: g=9.81
end real :: xmin, xmax, eps, somdef
external :: mafct
program truc ...
use blabla ! rappel du module blabla xmin = .. ; xmax = ..
implicit none write(*,*) somdef( xmin, xmax, eps, mafct )
real :: p, m = 75
p = m*g Les mêmes règles s’appliquent pour les sous-
write(*,*)’Poids =’,p programmes 35 .
call machin(p) Ce sont là les seuls cas d’utilisation de intrinsic et
end external : quand on ne transmet pas comme argument le
nom d’un sous-programme ou d’une fonction à un autre
subroutine machin(poids)
sous-programme ou fonction, il est complètement inutile
implicit none ! ici pas de module blabla
real, intent(in) :: poids d’utiliser ces déclarations 36 .
real :: g= 2.
write(*,*) ’Poids a’,g ,’ g =’, poids*g 2.9.6 Les bibliothèques.
end
2.9.6.1 Pour quoi faire ?
La variable g de machin n’a rien à voir avec celle du mod-
ule et du programme principal, puisque machin n’utilise Imaginons que l’on ait écrit une série de sous-
pas le module blabla (il n’y a pas use blabla). programmes, par exemple des calculs d’intégrale, dont le
Outre la définition de constantes, un des usages les plus code-source, c’est-à-dire écrit en Fortran, est placé pour
courants des modules est quand un programme principal chaque sous-programme dans un fichier dont le nom se ter-
appelle un sous-programme A qui lui-même en appelle un mine par .f90. Pour réutiliser ces sous-programmes dans
autre B. A priori, les seules variables connues du sous- d’autres programmes, on peut bien sûr simplement inclure
programme B sont celles que lui a transmises A, or il se 35. Certains compilateurs plus anciens n’acceptent que l’ancienne
peut très bien qu’il ait besoin d’autres grandeurs utilisées syntaxe external mafct (sans les :).
36. Cette affirmation est en fait un peu péremptoire. . ., on peut
34. De ce point de vue, on reste assez loin des variables globales imaginer des situations où cela peut être nécessaire, par exemple
du C dont les auteurs du langage disent eux-mêmes que ce n’est pas si l’on a écrit soi-même un sous-programme dot product qui risque
ce qu’ils ont fait de mieux ! (B. W. Kernighan, D. M. Ritchie, Le d’entrer en conflit avec la fonction intrinsèque de même nom ; la
langage C, Masson (1997), p. 33.) déclaration external résout alors le problème.
Physique numérique, Philippe Depondt 33

les fichiers correspondants à l’aide de directives include
’nom de fichier.f90’, c’est d’ailleurs ce que l’on fait
souvent.
Toutefois, il arrive que ces sous-programmes aient eux-
même besoin d’autres sous-programmes pour fonction-
ner. Par exemple, les programmes de calcul de tran-
formée de Fourier vont tous utiliser le même algorithme,
linéaire, il y a par exemple lapack qu’en général, il suffit
d’invoquer à la compilation par :
g95 mon big prog.f90 -llapack -o mon big prog
Cela suppose évidemment que l’on ait la documentation
qui va avec, mais c’est généralement facile à obtenir via
Internet. C’est très souvent ainsi que l’on travaille dans
≪ le monde réel de la simulation ≫ : pour résoudre un

mais vont différer selon que l’on veut une transformée problème, on identifie une méthode de résolution dont
directe ou inverse : ainsi le programme que l’on ap- le noyau réside dans un algorithme connu (inversion de
pelle ne fait qu’appeler un autre programme en modifi- matrice, transformée de Fourier, valeurs propres, . . .) et
ant éventuellement un signe ; il faudrait alors inclure ex- l’on trouve le programme de bibliothèque convenable, on
plicitement les deux sous-programmes, ce qui suppose que l’appelle et on compile l’ensemble avec l’invocaton de la
l’on connaisse spécifiquement comment tout cela est orga- bibliothèque idoine : un appréciable gain de temps !
nisé : autant dire que c’est rarement le cas quelques années
après l’écriture initiale. Une bonne solution est alors de
constituer une bibliothèque (library en anglais 37 ). 2.10 Les commentaires.
Une bibliothèque est un fichier dans lequel sont re-
On peut, et c’est même conseillé, commenter ses pro-
groupés un ensemble se sous-programmes déjà compilés grammes, d’ailleurs les exemples donnés ci-dessus compor-
et dans lequel le compilateur peut aller pêcher ce dont il a tent des commentaires. Pour cela, il suffit d’utiliser le sym-
besoin, par exemple un sous-programme de calcul de trans- bole ! qui marque le début d’un commentaire qui ne sera
formée de Fourier et tous les sous-programmes auxquels donc pas interprété comme une instruction à exécuter :
celui-ci fait appel : dans le programme principal, il suffira
de faire un call du sous-programme voulu. ! ceci est un commentaire, mais la ligne
! qui suit est une instruction
read(*,*) x
2.9.6.2 Créer une bibliothèque personnelle.
C’est très utile quand on veut pouvoir s’y retrouver dans
On a donc écrit un certain nombre de sous-programmes un programme écrit quelques temps avant, par exemple :
et de fonction (dûment testés, bien sûr. . .) placés dans des
fichiers machin 01.f90, machin 02.f90, truc real.f90, !-----------------------------------------------
truc dbl prec.f90, etc. Si on compile tout cela par g95 ! Ceci est un programme ecrit le 06-11-98
! par Tycho Brahe
*.f90, le compilateur refusera de la faire parce qu’il n’y a
! Il comporte trois boucles imbriquees
pas de programme principal : il faut donc inhiber l’éditeur !
de lien 38 avec l’option -c et pendant qu’on y est, on peut ! Mise a jour (adaptation free form) le 18-12-01
demander une optimisation du code avec l’option -O3. ! par Johannes Kepler
Cela donne : !-----------------------------------------------
g95 -c -O3 *.f90 ....
on obtiendra alors une série de fichiers machin 01.o, ! debut de la grande boucle
machin 02.o, truc real.o, truc dbl prec.o, etc. Ces do i = 1, n
fichiers doivent alors être inclus dans un fichier d’archive : ......
ar rv libmabib.a *.o ......
Le fichier libmabib.a contient la bibliothèque mabib. On ! debut de la moyenne boucle
do j = 1, m
peut alors supprimer tous les fichiers intermédiaires :
........
rm -f *.o ........
Pour utiliser cela, il suffit de compiler normalement ! debut de la petite boucle
son programme principal, dans lequel il y a des call do k = 1, l
machin 01(arg1, arg2), avec la commande : ......
g95 big prog.f90 -Lrepertoire de mabib -lmabib ......
-o big prog ......
où repertoire de mabib est le répertoire où se trouve enddo
le fichier libmabib.a. Si l’on peut placer le fichier ! fin de la petite boucle
libmabib.a dans le répertoire /usr/local/lib 39 , ......
l’option -L n’est plus nécessaire. ......
enddo
! fin de la moyenne boucle
2.9.6.3 Utiliser une bibliothèque existante. .....
.....
Il est toutefois assez rare que l’on ait à créer une enddo
bibliothèque de toutes pièces : l’essentiel des algorithmes ! fin de la grande boucle
courants a déjà été programmé, compilé, testé, etc., il
est inutile -voire nocif- de les refaire ! Pour l’algèbre Si chaque série de points (.....) représente plusieurs cen-
taines d’instructions, les commentaires qui en marquent le
37. attention aux faux amis : en anglais, library signifie bib-
liothèque (l’endroit où l’on emprunte des livres) alors que librairie
début et la fin ne sont pas de trop. . .
(l’endroit où l’on achète des livres) se dit bookstore. . . Le point d’exclamation placé ailleurs qu’en colonne 1,
38. c’est ce qui fait le lien entre programmes et sous-programmes. transforme la fin de la ligne en commentaire, sans en af-
39. il faut pour cela les droits de super-utilisateur. fecter le début :
34 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

x = a + b ! a partir d’ici c’est un 2.12.2 Opérations sur les chaı̂nes

z = (x/p)**1.5 ! commentaire, mais le debut de
k = mod(j,6) ! ces lignes s’execute normalement
On peut faire quelques opérations sur les chaı̂nes de car-
actères, par exemple :
Les déclarations de variables sont souvent un bon en-
i = len_trim(salut)
droit pour mettre des commentaires :
donne le nombre de caractères remplis de la chaı̂ne (4 dans
program capitaine le cas Ciao même si la chaı̂ne est déclarée avec 7 char-
implicit none actères).
! ce programme calcule l’age du capitaine
integer, parameter :: n = 100 ! nbr de points de character (len=7) :: salut = ’Bonjour’
! discretisation character (len=3) :: c
real :: age_captain ! age du capitaine c=salut(1:3)
real, dimension(n) :: work ! zone de travail donnera Bon dans c puisque l’on prend les caractères de
1 à 3. Il est aussi possible d’ajouter des caractères à une
chaı̂ne en utilisant l’opération // :
2.11 Une instruction sur plusieurs
integer l
lignes. character (len=40) :: nfichier1
character (len=20) :: nfichier2
Il arrive qu’une instruction soit trop longue pour tenir
sur une ligne : il faut donc la prolonger sur la ligne suiv- write(*,’("Entrer un nom de fichier : ",$)’)
ante. Pour cela, il suffit de placer le caractère & à la fin de read(*,*) nfichier1
la ligne pour indiquer que la ligne suivante en est la suite :
write(*,*) ’L’’age du capitaine est ’, ag_cpt, & l = len_trim(nfichier1) ! l = longueur reelle
’ mais on manque un peu de place ’, & ! du nom de fichier
’: d’’ailleurs, on est oblige’, & nfichier2=nfichier1(1:l)//’.res’
’ de s’’etaler sur plusieurs lignes’ ! on prend la partie de la chaine nfichier1
! qui est remplie et on ajoute ’.res’ apres
Ici, l’instruction prend quatre lignes. Si l’on interrompt
une chaı̂ne de caractère, il faut mettre & à la fin de la ligne write(*,*) "Fichier resultat : ", nfichier2
et au début de la ligne suivante : open(1,file=nfichier1) ; open(2,file=nfichier2)
write(*,*) ’L’’age du capitaine est ’, ag_cpt, & Ainsi, si l’on répond à la question ≪ Entrer un nom de
’ mais on manque un peu de place & fichier ≫ par : machin, on obtiendra :
&: d’’ailleurs, on est oblige & Fichier resultat : machin.res
&de s’’etaler sur plusieurs lignes’

comparer avec l’exemple précédent. . . 2.12.3 Conversion chaı̂ne ⇔ nombres

On peut donc fabriquer automatiquement des noms de
2.12 Les chaı̂nes de caractères. fichiers ; toutefois, il est utile de pouvoir insérer des nom-
bres dans ces noms, par exemple res calc dt0.001.dat
pour signifier que ce calcul a été fait avec dt=0.001. Il faut
2.12.1 Déclaration donc convertir ce nombre en chaı̂ne de caractères. Il ex-
Une variable de type chaı̂ne de charactères doit être iste une fonction intrinsèque char qui permet de partir du
déclarée avec le nombre de caractères qu’elle peut con- code ASCII d’un caractère pour écrire ce caractère : c’est
tenir, par exemple : assez lourd, car il faut décomposer le nombre en dizaines,
centaines, connaı̂tre les codes ASCII. . . Il est beaucoup
character (len=7):: salut plus simple d’utiliser les instructions d’entrée-sortie qui
indique que salut peut faire 7 caractères. Par exemple : font aussi ce genre de conversion par le biais de ce qu’on
appelle un ≪ fichier interne ≫, qui consiste à remplacer
salut=’Bonjour’ l’unité d’écriture par une chaı̂ne de caractères :
Mais rien n’empêche : integer :: i
character (len=21) :: nom_fich
salut=’Ciao’
! initialisation de la cha^
ıne de caracteres
où seuls les quatre premiers caractères sont remplis. En nom_fich = ’res_calc_dt_0.000.dat’
revanche, do i = 1, 8
! completer les caracteres numeriques
salut=’Guten Tag’ write(nom_fich(12:16),’(f5.3)’) 0.001*i
risque d’être un peu décevant, il serait judicieux de ...
enddo
déclarer salut avec 9 caractères au moins. . .
On peut, dans un sous-programme ou une fonction, Evidemment, cela suppose un certain soin et il est pru-
déclarer une chaı̂ne de caractères sans longueur définie,
dent de vérifier que le nom de fichier obtenu est bien ce
à condition qu’elle soit transmise comme argument : que l’on attendait ! Ensuite, il est aisé de produire automa-
subroutine char_process(str,a,b,c,d) tiquement des noms de fichiers explicites.
character (len=*) :: str Les fichiers internes fonctionnent aussi pour l’écriture,
par exemple, le programme metres ci-dessous lit les ar-
le sous-programme se débrouillera avec la chaı̂ne str guments de la commande qui l’invoque, ainsi quand on
quelle qu’en soit la longueur. tape :
Physique numérique, Philippe Depondt 35

$ metres 6500 pieds lecture :

on obtient open(1,file=nfichier)
1981.200 metres do i = 1, n ! mais quelle valeur donner a n ?
read(1,*) x
Le programme est aussi une illustration de select case : ...
program metres enddo
implicit none
Une bonne solution est de faire une boucle infinie dont on
real, parameter :: c = 0.3048 ! conversion
sort quand une condition de fin de fichier est rencontrée :
real :: l
character (len=10) :: unite open(1,file=nfichier)
do
! si le nombre d’arguments est >= 2, lire les deux read(1,*,iostat=i) x
! premiers, sinon, lire classiquement au clavier if( i < 0 ) exit
if ( command_argument_count() >= 2 ) then ...
call get_command_argument(1,unite) ! 1er argument enddo
! Le 1er argument est la longueur que l’on veut
! convertir, c’est donc un nombre, or on a une chaine la spécification iostat=i où i est une variable entière
! de caracteres qu’il faut convertir en reel par place dans i un diagnostic du résultat de l’opération
! unite interne d’entrée-sortie. Tant que i reste positif ou nul, la lecture
read(unite,*) l ! on lit la chaine pour obtenir l se poursuit. La fin du fichier ou une erreur de lecture pro-
call get_command_argument(2,unite) ! 2eme argument duira une valeur négative, et la lecture s’arrête.
! le 2eme argument est le nom de l’unite qui reste
! une chaine de caracteres : donc pas de conversion.
else 2.14 FORTRAN77-90-95 : filiation
write(*,’("Entrer la longueur et l’’unite ",$)’)
read(*,*) l, unite et différences.
endif
Le langage fortran ne cesse d’évoluer : la première
! trim est une fonction intrinseque qui reduit une norme officielle et indépendante d’un constructeur, for-
! chaine de caracteres a sa partie utile (sans espaces) tran66 ou fortranIV, date de 1966. fortran77, en
select case(trim(unite)) 1977, introduisait des structures comme if-then-else,
case (’ft’,’feet’,’foot’,’pieds’,’pied’) les chaı̂nes de caractères et des instructions d’entrée-sortie
write(*,*) l*c,’ metres’ élaborées comme open. En 1991, la norme fortran90 fut
case (’in’,’inch’,’inches’,’pouces’,’pouce’)
définie et les premiers compilateurs cray et ibm sont ap-
write(*,*) 1000.*l*c/12.,’ mm’ ! 1 ft = 12 in
case(’m’,’metres’)
parus en 1994. Enfin, la norme fortran95 est devenue
write(*,*) l/c,’ ft’ opérationnelle en 1999 sur des gros calculateurs de type
case default cray et ibm. . . en attendant fortran2003 !
write(*,*) ’unite inconnue’ Si fortran95 apporte surtout des modifications de
end select détail par rapport à fortran90, celui-ci constitue
end une évolution significative. Certaines structures (comme
do-if(...) exit-enddo) étaient déjà intégrées dans g77
–Exercice : adapter ce programme pour pouvoir faire
mais pas toutes : la manipulation globale de tableaux, les
des conversions du type metres 5 ft 10 in pour obtenir
modules, l’intention, l’allocation dynamique de mémoire
1.778 m.
Une autre application est la création de formats au- n’en faisaient pas partie.
tomatiques : imaginons que l’on ait déclaré un tableau Cette capacité à manipuler des tableaux est probable-
≪ allocatable ≫ : combien d’éléments doit-on mettre ment l’apport principal de fortran90 au calcul scien-
dans le format d’écriture ? A priori, on ne peut pas le savoir tifique ; la logique des programmes peut en être modifiée :
avant l’exécution : c’est le but de l’allocation dynamique un exemple pourrait être un calcul d’énergie potentielle
de mémoire. . . On peut s’en sortir en se rappelant qu’un d’interaction entre n atomes, à partir de l’énergie de paire
format est une chaı̂ne de caractères que l’on peut modifier, de chaque couple d’atomes, donnée par une expression du
ainsi : type
 12  6 !
integer :: n σ σ
real, dimension(:), allocatable :: s V (rij ) = ε −2
rij rij
character (len=9) :: form=’(00f11.5)’
write(*,’("Donnez la dimension du tableau : ",$)’) et
n−1
X n
X
read(*,*) n
allocate(s(n)) Ep = V (rij )
... i=1 j=i+1

write(form(2:3),’(i2.2)’) n ! modification du format en fortran77 :

write(*,form) s ! ecriture
do i = 1, n-1
do j = i+1, n
2.13 Détection de fin de fichier. rij2 = (x(i)-x(j))**2 + (y(i)-y(j))**2 + &
(z(i)-z(j))**2
Il arrive que l’on lise un fichier dont la longueur est sigr6 = (sigma2/rij2)**3
inconnue : ainsi, on ne sait pas la longueur de la boucle de epot = epot + sigr6*( sigr6 - 2.0 )
36 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

enddo integer (kind=8) :: l

enddo travaille sur 8 octets et permet d’aller jusqu’à 1010 .
epot = epsilon*epot Toutefois, tout ceci dépend du processeur utilisé : ce qui
est cité ci-dessus n’est vrai que pour les processeurs les
en fortran90 : plus communément utilisés sur PC ; le programme suivant
permet de tester tout cela en cas de doute :
do i = 1, n-1
rij2(i+1:n) = (x(i)-x(i+1:n))**2 + & program inquire_kind
(y(i)-y(i+1:n))**2 + & implicit none
(z(i)-z(i+1:n))**2 integer :: p
sigr6(i+1:n) = (sigma2/rij2(i+1:n))**3 ! l’exposant est celui de la puissance de 10 accessible
epot = epot + sum(sigr6(i+1:n)*(sigr6(i+1:n) - 2.0)) write(*,’("Nombres entiers :")’)
enddo write(*,’("exposant, kind")’)
epot = epsilon*epot do p = 1,10
write(*,’(2i6)’) p, selected_int_kind(p)
où maintenant rij2 et sigr6 sont des tableaux : la boucle enddo
interne est implicitement décomposée en trois boucles plus ! la precision est le nombres de chiffres significatifs
simples. Le résultat est que l’on occupe plus de mémoire write(*,’("Nombres reels :")’)
vive (plus de tableaux) mais que la logique du calcul s’en write(*,’("precision, kind")’)
trouve décomposée en éléments plus simples. do p = 1, 20
Il y a cependant d’autres innovations, plus ≪ informa- write(*,’(2i7)’), p, selected_real_kind(p)
tiques ≫ qui seront décrites ici car elles ont un attrait enddo
certain, mais elles sont d’un intérêt moins immédiat pour end
le calcul scientifique pur et dur.
On peut aussi utiliser kind avec des caractères pour
écrire avec des caractères non-latins.
2.14.1 kind
Le type double precision est considéré comme ob- 2.14.2 Interfaces.
solète et disparaı̂tra probablement dans une version
Supposons qu’une équipe de programmeurs travaille
ultérieure de Fortran. Son intérêt est de faire des cal-
collectivement sur un même (gros) programme en se
culs avec un plus grand nombre de chiffres significatifs, ce
répartissant les tâches. Chaque programmeur n’est pas
qui est parfois utile, sinon indispensable. Il est remplacé
forcément toujours au courant du détail des arguments
par le concept plus général de kind 40 qui s’applique aux
utilisés par ses collègues dans tel ou tel sous-programme
entiers, aux réels et aux caractères. Dans la plupart des
enfoui dans des dizaines de milliers de lignes de code ; il n’a
cas (ça dépend du processeur) un kind=4 codera un nom-
pas forcément le temps ou le courage de relire tout le code
bre sur 4 octets (c’est en général ce qui se passe quand on
existant pour retrouver la liste d’arguments et leurs types
ne précise rien et cela donne 6 chiffres significatifs) et un
de la subroutine lfpz atis13102twr11800 écrite deux
kind=8 sur 8 octets, soit la double precision ( 15 chiffres
ans auparavant par quelqu’un qui a entre-temps changé
significatifs).
d’affectation !
Ainsi : Il peut être alors utile de résumer au début du pro-
real :: x gramme principal, dans une interface, tout ce qu’il faut
et savoir sur tous les sous-programmes :
real (kind=4) :: x
sont (sur la plupart des ordinateurs) équivalents. De program yepee
même :
double precision :: x interface
et
subroutine lfpz_atis13102twr11800(x,y,n)
real (kind=8) :: x
integer, intent(in) :: n ! nombre
De la même façon, on peut faire des double complex par real, dimension(n), intent(in) :: x ! annees
complex (kind=8) :: z real, dimension(n), intent(inout) :: y ! mvts
Quel intérêt tout cela peut-il avoir ? La déclaration real end subroutine lfpz_atis13102twr11800(x,y,n)
est un peu ambigüe parce que, sur un processeur à 32 bits,
le réel est bien codé sur 4 octets, alors que sur un pro- subroutine cp301_phln(a,h)
cesseur à 64 bits (qui deviennent de plus en plus fréquents) real, intent(in) :: a ! annee
il est codé sur 8 octets, ce qui en fait l’équivalent d’un real, intent(out) :: h ! heures
double precision. . . La notion de kind a pour but de end subroutine cp301_phln
clarifier les choses.
end interface
On peut faire la même chose avec des entiers :
integer :: l ! declarations du programme principal
code l sur 4 octets et permet d’utiliser des nombres entiers implicit none
jusqu’à 109 , alors que ...
40. Sorte ou espèce. Par exemple : the American bald eagle is a
kind of eagle found in Northern America. En américain ≪ conver-
Toutes les déclarations de tous les arguments de tous
sationnel ≫, It’s kind of neat (prononcer : It’s kinda neat) : c’est les sous-programmes sont ainsi répétées au début du
super chouette ; he’s kind of weird : il est assez bizarre. programme principal (ou du programme appelant), avec
Physique numérique, Philippe Depondt 37

éventuellement des commentaires : le compilateur peut ! definition du type rationnel dans un module pour
ainsi vérifer au passage la cohérence des appels de sous- ! eviter d’avoir a le refaire dans tous les
programmes et signaler d’éventuelles erreurs. ! sous-programmes
L’interface ne sert cependant pas uniquement à se rap- type rationnel
peler la syntaxe d’appel d’un sous-programme, elle permet integer :: n, d
de résoudre un certain nombre de problèmes de déclaration end type rationnel
de variables. Admettons que l’on cherche à faire une fonc- ! le type rationnel est compose de deux nombres
tion qui fasse un produit vectoriel ~a ∧ ~b. Le résultat est ! entiers : n = numerateur et d = denominateur
un vecteur à trois éléments : comment déclarer une telle end module rat
fonction ? La réponse est de faire une interface, ainsi :
program ratio ! programme principal
program prod_test use rat
implicit none implicit none

! -- interface pour declarer une fonction-vecteur -- interface operator (*)

interface ! definition de l’operateur * (multiplication)
function cross_product(a,b) result(c) ! il s’agit ici simplemement de faire le lien
! result permet de definir une variable qui contient ! entre le symbole ’*’ et la fonction ’ratmul’
! le resultat de la fonction. Ici cette variable est function ratmul(q1,q2) result(q3)
! un vecteur a trois elements use rat
real, dimension(3), intent(in) :: a, b type(rationnel), intent(in) :: q1, q2
real, dimension(3) :: c type(rationnel) :: q3
end end function ratmul
end interface end interface operator (*)

! --- interface operator (+)

real, dimension(3) :: x, y, z ! meme chose pour l’addition
function ratadd(q1,q2) result(q3)
write(*,’("Entrer X ",$)’) ; read(*,*) x use rat
write(*,’("Entrer Y ",$)’) ; read(*,*) y type(rationnel), intent(in) :: q1, q2
type(rationnel) :: q3
! appel de la fonction (ce sont des tableaux!) end function ratadd
z = cross_product(x,y) end interface operator (+)
write(*,*) "X x Y = ", z
! declaration de deux nombres rationnels p et q
! test pour verifier que le resultat est bien ! le numerateur de q s’ecrit q%n et
! perpendiculaire aux deux vecteurs initiaux ! son denominateur q%d
write(*,*) "Produit scalaire X.Z", dot_product(x,z) ! meme chose pour p
write(*,*) "Produit scalaire Y.Z", dot_product(y,z) type (rationnel) :: q, p

end write(*,’("Num, denom 1: ",$)’)

read(*,*) q%n, q%d
!----- definition de la fonction ----- write(*,’("Num, denom 2: ",$)’)
function cross_product(a,b) result(c) read(*,*) p%n, p%d
implicit none
real, dimension(3),intent(in) :: a, b ! utilisation des deux nouveaux operateurs
real, dimension(3) :: c write(*,*) "produit ", q*p
write(*,*) "somme ", q+p
c = cshift(a,1)*cshift(b,-1)-cshift(b,1)*cshift(a,-1)
end
end
function ratmul(q1,q2) result(q3)
-Exercice : étudier le fonctionnement des cshift dans ! ratmul est une fonction de type rationnel
la fonction cross product en comparant avec la définition ! mais ce type n’est pas encore defini pour
du produit vectoriel. . . ! cette fonction, d’ou la syntaxe result
use rat
implicit none
2.14.3 Objets de type dérivé. type(rationnel), intent(in) :: q1, q2
En fortran, il y a les types integer, real, etc. On type(rationnel) :: q3
peut aussi fabriquer dans un programme des types nou- q3%n = q1%n*q2%n
veaux en combinant des types existants, par exemple, q3%d = q1%d*q2%d
character et real, et définir des opérations (addition, call simplify(q3)
multiplication) s’effectuant sur ces nouveaux types. Par end function ratmul
exemple, un rationnel est composé de deux nombres en-
tiers, numérateur et dénominateur, et l’on peut définir des function ratadd(q1,q2) result(q3)
opérations sur les rationnels qui tiennent compte, en par- use rat
ticulier, de la réduction au même dénominateur : implicit none
type(rationnel), intent(in) :: q1, q2
module rat type(rationnel) :: q3
38 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

q3%n = q1%n*q2%d + q2%n*q1%d doute les scientifiques eux-mêmes qui sont frappés d’obso-
q3%d = q1%d*q2%d lescence ! En attendant, l’un des reproches essentiels que
call simplify(q3) l’on fai(sai)t au fortran est l’absence de pointeurs.
end function ratadd Un pointeur est une variable qui contient l’adresse d’une
variable : si l’on modifie un pointeur, on ne modifie pas la
subroutine simplify(q)
valeur de la variable, mais on ≪ pointe ≫ vers une autre
use rat
adresse et donc une autre variable. A priori, un pointeur
implicit none
type(rationnel) :: q est donc juste une variable entière qui contient une adresse
integer :: i, m et l’on peut faire les opérations que l’on veut sur cette
adresse, aux risques et périls de l’utilisateur. C’est ainsi
! si a la fois numerateur et denominateur sont en assembleur et en langage C qui est très proche de la
! divisibles par le meme nombre, le faire : machine. En assembleur en particulier, il n’y a pas de
! c’est pedestre, mais ca marche... tableaux, mais on peut accéder à des grandeurs stockées
m = min(abs(q%n),abs(q%d)) à la suite les unes des autres en mémoire simplement
l1 : do i = 2, m en incrémentant un pointeur, ce qui revient au même,
l2 : do ! il faut parfois recommencer si ce n’est que c’est d’un maniement sensiblement plus
if (mod(q%n,i) == 0 .and. mod(q%d,i) == 0 ) then
délicat. . .
q%n = q%n/i
Les pointeurs sont importants en informatique parce
q%d = q%d/i
else que c’est le point de départ de l’allocation dynamique
exit l2 de mémoire, puisqu’on accède ainsi librement à toute la
endif mémoire sans en réserver des morceaux à telle ou telle vari-
enddo l2 able. fortran90 gère l’allocation dynamique de mémoire
enddo l1 autrement, comme on l’a vu, et -opinion qui n’engage que
end subroutine simplify son auteur- de façon nettement plus prudente.
Autant dire que pour l’essentiel du calcul scientifique,
Ça donne par exemple :
la capacité à utiliser des tableaux efficacement est beau-
$ ratio coup plus importante. Toutefois, fortran90 introduit les
Num, denom 1: 5 2 pointeurs avec un certain nombre de garde-fous.
Num, denom 2: 4 5 Un pointeur doit être déclaré avec le type de la variable
produit 2 1 vers lequel il pointe : un pointeur donné ne peut pas avoir
somme 33 10 pour cible un entier à un moment et un réel un peu plus
tard :
5 4 20 2 5 4
ce qui est correct : × = = et + = ! declaration d’un pointeur vers un entier
2 5 10 1 2 5
5×5+2×4 33 integer, pointer :: a
= .
2×5 10 ! declaration d’un pointeur vers un tableau reel
On peut, sans difficulté majeure, ajouter à cela les deux real, dimension(:), pointer :: b
autres opérations et l’on aura créé un type nouveau et les
Il faut aussi déclarer explicitement des variables comme
opérations associées. Les types dérivés et les opérations
cible (target en anglais) :
associées constituent un pas important du fortran en
direction de la programmation orientée ≪ objet ≫ au integer, target :: n, m
détriment, sans doute, de la simplicité originelle du lan- real, dimension(150), target :: x, y
gage : la norme fortran2003 la développe d’ailleurs en- Si l’on veut que a pointe vers m et b vers x, cela donne :
core davantage.
-Exercice : définir un type temps composé d’heures, min- a => m
utes, secondes et une addition et une soustraction permet- b => x
tant de calculer en sexagécimal (par exemple : 1h32mn24s Quel intérêt ? On peut, par exemple, faire pointer un poin-
+ 2h42mn39s = 4h15mn3s). teur vers un morceau de tableau
-Exercice : définir un type triangle défini par les co-
ordonnées de ses trois sommets et une opération * d’ho- b => x(100:150)
mothétie permettant de le dilater d’un facteur réel sans ce qui permet d’optimiser des transferts de données d’un
déplacer son centre de gravité. morceau de tableau à un autre : dans certains cas on
économise ainsi de l’espace mémoire.
2.14.4 Pointeurs.
≪ Le fortran est un langage dépassé, vieillot, ob- 2.14.5 Récursivité.
solète. . . ≫ : ce sont des propos que l’on entend depuis fortran90 l’autorise. . . c’est parfois commode,
plus de vingt ans 41 , or le fortran continue à être large- rarement efficace, du moins pour le calcul scientifique pur
ment employé en calcul scientifique ; ce sont donc sans et dur. L’exemple que l’on donne toujours est le calcul de
41. Dans les années 1980, il advint un jour que le laboratoire où
factorielles : la définition de n! est,
je travaillais dut acquérir une station de travail ; les représentants
d’un des fournisseurs pressentis vinrent vanter les mérites de leurs n! = n(n − 1)!
productions et demandèrent quel langage on utilisait afin d’inclure
le compilateur dans leur devis. Quand la réponse fut : ≪ fortran ≫, Cela se programme sans difficulté à condition de spécifier
nous eûmes droit à des regards pour le moins. . . incrédules ! que la function est récursive :
Physique numérique, Philippe Depondt 39

program factorielle Ces remarques achèvent la partie langage de ce cours.

implicit none Dans la suite, les exemples seront donnés en fortran,
integer :: n, fact mais les algorithmes étudiés ne dépendent évidemment
write(*,’("Entrer un entier : ",$)’) ; read(*,*) n pas du langage de programmation choisi.
write(*,*)"Factorielle", n," vaut ",fact(n)
end

recursive function fact(n) result(f)

implicit none
integer, intent(in) :: n
integer :: f
if ( n > 1 ) then
f = n*fact(n-1) ! ici la fonction s’appelle
! elle-meme, c’est recursif
else
f = 1
endif
end function fact
Cinq minutes de réflexion permettent cependant de
reécrire la fonction :
integer function fact(n)
implicit none
integer, intent(in) :: n
integer :: f = 1
if ( n > 1 ) then
do i = 2, n
f = f*i ! ici, ca n’a rien de recursif
enddo
endif
fact = f
end function fact
La deuxième version est plus efficace parce que la première
devra stocker tous les résultats intermédiaires en mémoire
de façon parfaitement inutile, ce que la deuxième ne fait
évidemment pas.
La récursivité est une question importante pour les
informaticiens dans la mesure où elle leur facilite con-
sidérablement la tâche dans, par exemple, des problèmes
de logique tournant autour de la décidabilité (Entschei-
dungsproblem quand on veut montrer que l’on a de
l’éducation. . .). Pour un physicien qui se borne en général
à utiliser des algorithmes standards, cela reste assez
marginal.

Après cette première partie, on constate donc que le

langage fortran90 est très riche et que l’on peut faire
avec ce langage des choses plutôt élaborées. Il n’est bien
sûr pas utile d’apprendre tous les détails du langage en
quelques semaines, mais il est indispensable d’en avoir
une pratique suffisante pour ne pas être gêné par des
détails de programmation pendant les séances de travaux
pratiques, au cours desquelles, très rapidement, on se
préoccupera plus de physique que de langage ! Il est
recommandé d’être capable, assez rapidement, d’écrire
sans trop hésiter des programmes comportant conditions,
boucles, tableaux, sous-programmes et entrées-sorties : le
reste viendra avec la pratique, mais,
les bases doivent être impérativement
apprises et maı̂trisées, car sans cela, on
s’expose à patauger sans grand profit
dans un bourbier de détails informa-
tiques sans intérêt !
40 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 3

Un prototype de TP

3.1 Introduction.
I M r
La physique numérique requiert sans doute quelques
R
connaissances dont le présent cours a pour but de fournir d
l’essentiel. Il s’agit toutefois d’une activité essentiellement i r−i
pratique : il faut écrire des programmes qui, non seule- O H S F
ment ≪ marchent ≫, mais aussi répondent aux questions
posées de sorte que la physique du problème soit traitée
de façon satisfaisante ; il faut pour cela un minimum d’-
expérience pour, bien sûr, maı̂triser le langage, mais en
outre avoir une familiarité suffisante avec l’environnement Figure 3.1 – Lentille demi-boule
et les méthodes afin que ceux-ci deviennent l’aide puis-
sante qu’ils doivent être et non plus la gêne. . . qu’ils con-
stituent sans conteste au début ! C’est la raison pour laque- Prenons une lentille demi-boule (figure 3.1) de rayon R,
lle cet enseignement comporte une part importante de et nous voulons calculer la distance OF en fonction de d,
travaux pratiques. la distance du rayon incident IM à l’axe optique, ce rayon
Chacune de ces séances de TP est consacrée à un est considéré comme parallèle au dit axe optique. Un peu
problème de physique qui illustre l’usage que l’on peut de géométrie élémentaire, additionnée de la loi de Snell-
faire de telle ou telle méthode. Elle est précédée d’une Descartes, nous dit que :
séance de travaux dirigés au cours de laquelle on présente
d
le problème, éventuellement on montre les limites du cal- sin i =
R
cul analytique et on décrit les méthodes numériques qui
OH = R cos i
seront utilisées pour le traiter. Si le problème présente des
difficultés particulières de programmation, celles-ci seront n sin i = sin r
également abordées. d
tan(r − i) =
Il est attendu des étudiants qu’ils arrivent en séance de HF
TP en ayant 1o pris connaissance du problème et 2o avec et ainsi la focale f s’écrit :
une bonne idée de comment le résoudre et qu’ils en par-
tent en rendant un compte-rendu qui compte pour la d
f = OF = R cos i +
note de contrôle continu. tan(r − i)
La question est évidemment : ≪ que doit-il y avoir dans
On peut vérifier que dans les conditions de Gauss, on
un compte-rendu de TP ? ≫ Comme il s’agit d’un exer-
retrouve la formule habituelle :
cice un peu particulier, on traite ci-dessous, à titre d’ex-
emple, la question de de la lentille demi-boule ≪ à la cos i ≈ 1
manière ≫ d’un TP. . .
sin i ≈ i
sin r ≈ r
3.2 La lentille demi-boule tan(r − i) ≈ r−i

En optique géométrique, on utilise toujours des lentilles soit :

R
minces parce qu’elles permettent de travailler dans les f ≈R+
conditions de Gauss (petits angles) ce qui simplifie con- n−1
sidérablement la vie : on a des formules simple pour cal- Or, habituelement, on a
culer la focale, etc. Que se passe-t-il avec une lentille
R
épaisse ? Un programme très simple permet de répondre, flentille mince =
avec un effort minimal, à la question. n−1
C’est simplement que, dans le cas d’une lentille mince, les
3.2.1 Préliminaires analytiques points O et S sont confondus. On constate que la distance
focale, dans ces conditions, ne dépend pas de d, ce qui est
Cette partie correspond en gros à ce qu’on ferait en TD. bien le signe d’un système stigmatique.

41
42 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

3.2.2 Écriture d’un programme 3

2.8
En gros, il s’agit de recopier la formule de la focale :
f = rayon*cos(i) + d/tan(r-i) 2.6
avec la précaution que comme le langage fortran ne dis-
tingue pas entre les lettres majuscules et minuscules, il 2.4

faut deux variables au nom distinct r pour l’angle et rayon 2.2

pour R. Reste à calculer les variables qui ne le sont pas

f
encore, faire une boucle pour faire varier d de zéro à sa 2

valeur maximum, déclarer toutes les variables et s’occuper

1.8
des entrées-sorties. Ça peut donner quelque chose comme :
1.6
program lentille
implicit none 1.4

real, parameter :: rayon = 1.0, n = 1.5 ! indice du verre 1.2

real :: d, i, r, f, d_max 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7
d
integer, parameter :: l_max= 500
integer :: l
d_max = rayon/n ! au-dela, c’est la reflexion totale Figure 3.2 – Focale d’une lentille demi-boule pour R = 1
open(10,file=’lentille.res’) et n = 1.5
do l = 1, l_max
d = l*d_max/l_max
dus dans les cas où l’on sait à quoi s’attendre ! C’est un
i = asin(d/rayon) ! arcsinus
r = asin(n*d/rayon)
excellent, sinon le seul, détecteur d’erreurs de logique. . .
f = rayon*cos(i) + d/tan(r-i) On constate ensuite que la distance focale, pour d plus
write(10,*) d, f grand que 0.1, décroı̂t, ce n’est plus une constante. Ainsi,
enddo une lentille demi-boule n’est pas un dispositif stigmatique,
close(10) à un point de l’image, ne correspond pas un point de l’ob-
end program lentille jet. Ce n’est donc pas un dispositif très utilisable dans
l’optique conventionnelle, c’est ce qu’on appelle ≪ l’aber-
Pour écrire un tel programme, il n’est pas utile de ration géométrique ≫ et c’est ce qui justifie généralement
vouloir tenter de commencer par la première ligne et ter- l’utilisation de lentilles minces qui fonctionnent toujours
miner par la dernière. . . Il vaut bien mieux commencer dans l’approximation de Gauss (mais ça reste une approx-
par la ligne de code ≪ stratégique ≫ qui donne f en fonc- imation même pour les lentilles minces).
tion de d, puis compléter au fur et à mesure des besoins,
par les déclarations, chaque fois qu’on introduit des nou-
velles variables, les lignes qui définissent les variables non
3.2.4 Tracé des rayons
encore calculées, la boucle, ses bornes, et enfin les entrées- Si on donne une liste de points au programme gnuplot,
sorties. Ne pas hésiter à commenter un programme : l’ex- ces points étant définis par leurs coordonnées (x, y), il trac-
emple ci-dessus reste très sobre de ce point de vue ; dans un era ces points comme autant de croix. Si, lors du tracé, on
programme plus complexe, chaque déclaration est accom- spécifie que l’on veut des lignes (with lines), gnuplot
pagnée d’un commentaire qui explique ce que représente tracera des lignes entre les points : on peut utiliser cela
la variable, on peut aussi prévoir un commentaire général pour tracer les rayons.
au début du programme qui explique ce que calcule ce pro- Pour une valeur de d un rayon est défini par trois points
gramme, par quelle méthode, la date d’écriture, un numéro I, M et F : il suffit alors d’écrire leurs coordonnées dans
de version, éventuellement un historique des différentes un fichier, puis de recommencer pour une autre valeur de
versions ou des modifications apportées, etc. Dans le cas d, etc. On a, par exemple :
d’un TP, des commentaires bien placés peuvent aider votre      
enseignant, qui lit votre compte-rendu, à comprendre ce −R R cos i f
I , M , F
que vous avez tenté de faire. . . d d 0
En général, une première compilation produit une liste
impressionnante d’erreurs : NE PAS se laisser impres- Il suffit d’apporter quelques petites modifications au
sionner ! Remontez jusqu’à la première erreur de la liste, programme initial :
corrigez-là (on s’habitue assez vite aux diagnostics qui sont program lentille
assez explicites), sauvegardez votre programme et recom- implicit none
pilez : après quelques itérations, les choses devraient aller real, parameter :: rayon = 1.0, n = 1.5 ! indice du verre
nettement mieux ! real :: d, i, r, f, d_max
integer, parameter :: l_max= 10 ! nombre de rayons a tracer
integer :: l
3.2.3 Premiers résultats d_max = rayon/n ! au-dela, c’est la reflexion totale
open(10,file=’lentille.res’)
La figure 3.2 donne le résultat du calcul.
open(20,file=’lentille.ray’)
Commentaire : on constate que pour d < 0.1R, la dis- do l = 1, l_max
ance focale est une constante et la valeur f = 3 est bien d = l*d_max/l_max
celle qu’on attendait. Ces remarques peuvent paraı̂tre triv- i = asin(d/rayon) ! arcsinus
iales : elles le sont en effet, mais il est très important de r = asin(n*d/rayon)
vérifier qu’un programme donne bien les résultats atten- f = rayon*cos(i) + d/tan(r-i)
Physique numérique, Philippe Depondt 43

1 1

0.5 0.5

0 0

-0.5 -0.5

-1 -1
-1 -0.5 0 0.5 1 1.5 2 2.5 3 -1 -0.5 0 0.5 1 1.5 2 2.5 3

Figure 3.3 – Trajet des rayons Figure 3.4 – Trajet des rayons, avec réflexion totale.

write(10,*) d, f open(10,file=’lentille.res’)
write(20,*) -rayon, d open(20,file=’lentille.ray’)
write(20,*) rayon*cos(i), d do l = 1, l_max-1
write(20,*) f, 0. d = l*rayon/l_max
write(20,*) ! ca, c’est juste pour i = asin(d/rayon) ! arcsinus
! sauter une ligne dans le fichier resultat if ( d < d_max ) then
enddo r = asin(n*d/rayon)
close(10) ; close(20) f = rayon*cos(i) + d/tan(r-i)
end program lentille write(10,*) d, f
write(20,*) -rayon, d
Le résultat est donné sur la figure 3.3. Pour obtenir write(20,*) rayon*cos(i), d
l’arc de cercle, on a simplement ajouté au programme write(20,*) f, 0.
une autre boucle pour tracer les points de coordonnées else
(R cos i, R sin i), i ∈ [−π/2, π/2]. Pour obtenir un rapport write(20,*) -rayon, d
write(20,*) rayon*cos(i), d
d’aspect convenable entre les axes x et y (ce sont des
alpha = pi -2*i
distances, a priori, dans la même unité) on a spécifié à
beta = i
gnuplot : set size ratio -1 do
Avec cette figure, on visualise directement l’aberration beta = beta - alpha
géométrique : les rayons proches de l’axe optique conver- if ( beta < -pi/2 ) exit
gent bien tous vers la focale ≪ officielle ≫, alors que les write(20,*) rayon*cos(beta), rayon*sin(beta)
autres se rapprochent davantage de la lentille. enddo
endif
write(20,*) ! ca, c’est juste pour
3.2.5 Au-delà de la réflexion totale ! sauter une ligne dans le fichier resultat
Si on va au-delà de l’angle de réflexion totale, on s’at- enddo
close(10) ; close(20)
tend à ce que les rayons restent piégés dans la lentille.
open(30,file=’lentille.dioptre’)
Pour en tenir compte, la boucle sur d ne doit pas s’arrêter
do l = -20,20
à dmax = R/n mais aller jusqu’à R. Il faudra alors mettre i = acos(-1.0)*l/40.
une condition : si d < R/n, on fait comme avant, sinon, write(30,*) rayon*cos(i), rayon*sin(i)
on fait la réflexion totale. Dans ce deuxième cas, comme enddo
on ne sait pas d’avance combien il y aura de réflexions, il close(30)
faut mettre une boucle sans indice avec un critère d’arrêt end program lentille
et un exit.
Cela peut donner le programme suivant (on laisse le soin Et l’on obtient aisément la figure 3.4.
au lecteur de retrouver les formules utilisées. . .) :
program lentille
implicit none
real, parameter :: rayon = 1.0, n = 1.5 ! indice du verre
real :: d, i, r, f, d_max
integer, parameter :: l_max= 20 ! nombre de rayons a tracer
integer :: l
real :: alpha ! angle entre deux reflexions totales
real :: beta
real, parameter :: pi = acos(-1.0) ! nombre pi

d_max = rayon/n ! au-dela, c’est la reflexion totale

44 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 4

Méthodes numériques.

Ce chapitre développe les principales méthodes On obtient après quelques lignes de calcul :
numériques utilisées par les physiciens : afin d’éviter
d’en faire un manuel de mathématiques appliquées, que qq ′ xq cos θ + (yq − ℓ) sin θ
sin θ +
d’autres seraient sans doute mieux à même de réaliser, 4πε0 mg [(ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 ] 23
chaque méthode est illustrée par un exemple de physique
puisé dans la mesure du possible dans le bagage d’un =0 (4.1)
étudiant de licence de physique, quitte à anticiper ce qui n’est pas évident à résoudre analytiquement . 1
légèrement sur certains cours (en physique quantique ou Il s’agit d’un cas particulier du problème de la recherche
en thermodynamique statistique en particulier). du ou des zéro(s) d’une fonction, c’est-à-dire trouver le ou
les x tel(s) que
f (x) = 0
4.1 Recherche des zéros d’une
Il existe deux méthodes principales pour résoudre
fonction. numériquement ce genre de problème.
Partons d’un exemple complétement académique mais
très simple : un pendule simple de masse m porte à son 4.1.1 Méthode de la dichotomie.
extrémité une charge q. On place à proximité une autre
Comme son nom l’indique, il s’agit d’une recherche dans
charge q ′ (figure 4.1). Trouver l’angle d’équilibre θ du pen-
un intervalle que l’on découpe en sous-intervalles (fig. 4.2).
dule en fonction de la valeur de q ′ .

θ
f(a)

ε
q’

q
f(b)
Figure 4.1 – Le pendule chargé
a x b
L’énergie potentielle de gravitation du pendule peut Figure 4.2 – Recherche de zéro par dichotomie. Les zones
s’écrire : grisées sont éliminées par la recherche. Le rectangle allongé
Vg = mgz = −mgℓ cos θ horizontalement délimite la précision ε requise.
où ℓ est la longueur du pendule et θ l’angle qu’il fait avec
la verticale ; de même, l’énergie potentielle électrostatique Admettons que sur l’intervalle [a, b] la fonction f ait un
des charges s’écrit : zéro et un seul : elle change de signe sur l’intervalle et donc
le produit f (a)f (b) est négatif. Coupons alors l’intervalle
1 qq ′ a+b
Ve = p [a, b] en deux, ce qui nous donne le point x = . Si
4πε0 (ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 2
le produit f (a)f (x) est négatif, c’est que le zéro recherché
se trouve dans l’intervalle [a, x], sinon il se trouve dans
où xq et yq sont les coordonnées de la charge q ′ . L’équilibre l’intervalle [x, b]. Il reste à rediviser en deux l’intervalle
est, comme d’habitude, donné par :
1. On pourrait tenter de poser par exemple x = sin θ et y = cos θ,
d(Vg + Ve ) avec x2 + y 2 = 1. On tomberait alors sur un polynôme de degré 8
=0 en x et y. . .
dθ

45
46 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où se trouve le zéro et à refaire la même recherche. On

répète encore la même opération plusieurs fois jusqu’à ce xq = .1 ; yq = 0.
que la précision requise soit atteinte. Comme on répète la a = -1.57 ; b = 1.57 ; eps = 0.00001
même procédure plusieurs fois de suite, on appelle cela un
processus itératif. open(1,file=’zero.out’) ! fichier ou l’on mettra
! les resultats
Deux critères différents sont possibles pour choisir
c = 0.
d’arrêter ou non la recherche : do ! boucle pour faire varier c
– soit l’on désire une certaine précision sur la valeur de x = dicho(pendule, a, b, eps)
x et, donc, on arrête la recherche quand la longueur write(1,*) c, x
de l’intervalle devient inférieure à une valeur ε choisie c = c + 0.01
à l’avance, if ( c > 2.0 ) exit
– soit l’on veut que f (x) soit proche de zéro avec une enddo
certaine précision comme sur la figure 4.2, c’est-à-dire
|f (x)| < ε. close(1)
Une fonction informatique qui fasse cela pourrait s’écrire : end
!
real function dicho(f, a, b, epsilon) !---------------------------
! recherche de zero par dichotomie real function pendule(theta)
! f = fonction reelle dont on cherche le zero use pendu
! a et b = bornes de l’intervalle de recherche implicit none
! epsilon = precision recherchee sur la valeur de f real :: theta
! ! l = 1
! les variables y, y1, et y2 servent a conserver ! c = q*qprime/(4*pi*eps0*m*g)
! les valeurs prises par f afin d’eviter les
! calculs inutiles si f est longue a calculer pendule = sin(theta) & ! la formule occupe 3 lignes
+ c*( xq*cos(theta)-(1.-yq)*sin(theta))/ &
implicit none ((sin(theta)-xq)**2+((1.-cos(theta))-yq)**2)**1.5
real :: a, b, f, epsilon, y, y1, y2, x, x1, x2 end
La fin est bien sûr constituée de la fonction dicho. Le
x1 = a ; x2 = b ! initialisation de l’algorithme
y1 = f(a) ; y2 = f(b) résultat du calcul est donné figure 4.3.
0
! verification de l’intervalle
if( y1*y2 > 0. ) then −0.2

write(*,*) ’Intervalle mal choisi’ −0.4

stop
endif −0.6
freq_eq

−0.8
do ! *** debut de la boucle ***
x = 0.5*(x1+x2) ; y = f(x) ! dichotomie −1
if ( abs(y) < epsilon ) exit ! critere d’arret
−1.2
! de quel cote le zero se trouve-t-il ?
if ( y1*y < 0 ) then −1.4
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x2 = x ; y2 = y ! a gauche [x1,x] C
else
x1 = x ; y1 = y ! a droite [x,x2] Figure 4.3 – Solution du problème du pendule en fonction
endif ′
de c = 4πεqq0 mg pour ℓ = 1.
enddo ! *** fin de la boucle ***

dicho = x On constate, sans véritable surprise, que plus c (ou la

end charge) augmente, plus le pendule s’écarte de la verti-
cale. . .
L’équation (4.1) devient aisée à résoudre numéri- La méthode de la dichotomie est assez pédestre, elle
quement à l’aide d’un programme qui aurait l’allure suiv- est sûre, sans surprise. Elle nécessite une connaissance
ante : préalable de la fonction puisqu’elle suppose qu’il y ait un
et un seul zéro dans l’intervalle de recherche : il faut donc
module pendu pouvoir choisir celui-ci judicieusement.
! mise en commun de variables pour
! << sauter >> par-dessus dicho
! valeur et position de la charge 4.1.2 Méthode de Newton.
real :: c, xq, yq
La méthode de Newton est à la fois plus efficace et plus
end
dangereuse. Il s’agit, à partir d’un point de départ x0 judi-
program zero cieusement choisi, d’approcher la fonction par sa tangente
use pendu et de chercher l’intersection de celle-ci avec l’axe des x.
implicit none Comme la fonction n’est pas a priori linéaire le résultat
real :: a, b, eps, dicho, x est faux, mais il constitue le point de départ d’une nou-
external pendule velle recherche (figure 4.4).
Physique numérique, Philippe Depondt 47

et un peu de trigonométrie élémentaire donne

a+x a−x
i1 = arctan , i2 = arctan
y y

y1 ainsi nous avons a rechercher la racine de la fonction

   
a+x a−x
f = n1 sin arctan − n2 sin arctan
y2 y y
x0
où x est l’inconnue. Si nous voulons utiliser la méthode de
x1 x2
Newton, nous avons besoin de la dérivée de f par rapport
y0 à x :
df n1 1 n2 1
= cos  2 + cos  2
dx y a+x y a−x
1+ y 1+ y
Figure 4.4 – La méthode de Newton.
Le programme suivant fait exactement cela :
Si l’on part d’un point d’abscisse x0 , on doit pouvoir module params ! definition des parametres du probleme
calculer f (x0 ) et la pente de la tangente f ′ (x0 ). L’inter- implicit none
section de la tangente avec l’axe des x est donnée par real, parameter :: n1 =1.0, n2 = 1.5, a = 1., y = 1.
end module params
f (x0 )
x1 = x0 −
f ′ (x0 ) program decartes
use params
Il suffit de répéter l’opération pour x1 , x2 ,. . . implicit none
f (xn ) real, parameter :: eps = 1.e-5 ! precision requise
xn+1 = xn − real :: newton
f ′ (xn ) external :: trajet
jusqu’à ce que le critère de convergence que l’on aura choisi real :: x = 0. ! condition initiale
soit vérifié. ! ce programme ne comporte qu’une instruction
write(*,*) newton(x,trajet,eps), &
Imaginons, par exemple, que l’on veuille chercher la
n1*sin(atan((a+x)/y)) - n2*sin(atan((a-x)/y))
point d’intersection d’un rayon lumineux avec un diop-
end
tre en utilisant la loi de Descartes(figure4.5) : le rayon
−a subroutine trajet(x, f, df ) ! calcul de la fonction
part d’un point de coordonnées dans un mi-
y use params ! et de sa derivee
lieu d’indice
  n1 pour arriver en un point de coordonnées implicit none
a real, intent(in) :: x
dans un milieu d’indice n2 , en passant par le
−y   real, intent(out) :: f, df
x real :: r1, r2
dioptre au point de coordonnées . L’inconnue du r1 = (a + x)/y ; r2 = (a - x)/y
0
problème est x. f = n1*sin(atan(r1)) - n2*sin(atan(r2))
df = n1*cos(1./(1.+r1**2))/y + &
n2*cos(1./(1.+r2**2))/y
end

n1 real function newton(x,f,eps) ! methode de Newton

y
implicit none
i1 integer :: i, imax = 100 ! nombre max d’iterations
real :: x, eps, xp, y, d

do i = 1, imax
call f(x, y, d)
a a
xp = x - y/d
if (abs(xp-x) < eps ) exit
i2
x y x = xp
enddo
n2
newton = xp
end

Cela donne : 0.36264408 -0.000014537249. On laissera

Figure 4.5 – Loi de Descartes : notations pour utiliser la
le soin au lecteur de vérifier que c’est correct. . .
méthode de Newton
La méthode de Newton a plusieurs avantages par rap-
La loi de Descartes s’écrit évidemment port à la méthode de la dichotomie. Elle est en général
beaucoup plus rapide, ce qui dans certains cas peut
n1 sin i1 = n2 sin i2 s’avérer décisif. Elle a par ailleurs le très gros avantage
48 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

de pouvoir se généraliser aisément à plusieurs dimensions 0.8 tanh(x)−0.3*x

tanh(x)/x−0.3
comme on le verra dans la suite. Elle a l’inconvénient 0.6
qu’il faut pouvoir calculer, ou au moins estimer la dérivée
de la fonction, ce qui est parfois un peu laborieux (voir 0.4
l’équation (4.1) par exemple).
Elle recèle toutefois quelques pièges parfois redoutables. 0.2
Si par exemple, l’un des points xn est tel que f ′ (xn ) ∼ 0,
0
le point xn+1 risque de se trouver projeté fort loin du
2
point de départ , un résultat contrariant alors qu’il s’agit −0.2
d’une recherche en principe locale puisque basée sur une
approximation linéaire. Un deuxième piège est que si la −0.4
fonction étudiée possède plusieurs zéros, rien ne permet
de choisir à coup sûr celui que l’on veut puisqu’il n’y a −0.6 −4 −2 0 2 4
pas d’intervalle de recherche pré-défini : on peut certes
forcer le résultat à rester dans un intervalle donné. Parfois, Figure 4.6 – Les courbes de tanh(x) − 0.3x et de
enfin, l’algorithme ne converge pas, même si une solution tanh(x)
−0.3 montrant que la deuxième permet d’éliminer
existe, en cas de changement de courbure malencontreux x
par exemple : un choix plus judicieux du point de départ la racine triviale pour x = 0 alors que les deux autres
peut régler le problème. racines ne sont pas affectées.

4.1.3 Comment s’y prendre ? 1. l’algorithme lui-même peut-être plus ou moins précis
Les paragraphes précécents décrivent deux méthodes 2. les nombres avec lesquels travaille l’ordinateur sont
différentes pour résoudre le même type de problème, cha- eux-mêmes définis avec une certaine précision.
cune avec ses qualités et ses défauts. En consultant des
Par exemple, la méthode de la dichotomie, détermine un
ouvrages spécialisés, on s’apercevra rapidement qu’il en
zéro en l’encadrant par un intervalle d’étendue b − a, puis
existe d’autres. Comment procéder, alors ? b−a b−a
La première étape est de tenter de dégrossir qualita- , . . ., . Comme le nombre d’itérations est fini,
2 2n
tivement le problème par des résolutions graphiques par cela donne la précision du calcul intrinsèque à la méthode.
exemple, soit à l’aide de programmes de tracé de courbes Toutefois, même un algorithme parfait, s’il existait, ne
comme gnuplot, soit avec une calculette graphique, soit. . . pourrait pas donner des résultats infiniment précis à cause
à la main, ce qui est parfois le plus efficace car programmes du caractère fini de l’ordinateur lui-même qui ne peut pas
et calculettes travaillent toujours dans un intervalle défini représenter un nombre de façon parfaite.
a priori et ne disent rien sur ce qui se passe à l’extérieur
de cet intervalle, en particulier les asymptotes.
La deuxième étape est souvent de tenter de reformuler 4.2.1 Les nombres entiers.
le problème de façon qu’il n’y ait qu’un seul zéro dans le Il a été mentionné que les nombres avaient une
domaine ≪ utile ≫. Par exemple, rechercher le zéro de représentation binaire, c’est-à-dire constituée de 0 et de
tanh x − ax = 0 1. Ainsi pour les nombres entiers, on obtient la correspon-
dance habituelle entre représentation décimale (1ère ligne)
pour a < 1 donne trois solutions dont une solution triviale et binaire (2ème ligne) :
pour x = 0 (figure 4.6) ; or l’ordinateur ne ≪ sait ≫ pas 0 1 2 3 4 5 6 7 8 ...
qu’elle est sans intérêt. Il peut être habile alors de chercher 0 1 10 11 100 101 110 111 1000 ...
plutôt les solutions de Une case contenant un 0 ou un 1 s’appelle un bit.
Dans l’immense majorité des ordinateurs, les bits sont re-
tanh(x) groupés par groupes de huit, les octets, ou bytes en anglais.
−a=0
x Un octet constitue généralement un emplacement corre-
qui élimine la solution triviale si a 6= 1, puisque spondant à une adresse dans la mémoire vive de l’or-
dinateur. Le tableau ci-dessus devrait donc se reécrire :
tanh(x) 0 1 2 3 4
lim =1 00000000 00000001 00000010 00000011 00000100
x→0 x
5 6 7 8 ...
C’est alors qu’on peut choisir une méthode, Newton si 00000101 00000110 00000111 00001000 ...
le problème s’avère assez ≪ civilisé ≫ dichotomie sinon. Avec un octet on peut donc représenter les nombres
entiers allant de 0 à 28 − 1 = 255 : c’est un peu limité, car
on aimerait pouvoir utiliser, d’une part, des nombres plus
4.2 Représentation des nombres grands et, de l’autre, des nombres négatifs.
dans un ordinateur. Pour pouvoir représenter les nombres négatifs, on doit
changer la convention et l’on prend le complément à deux,
Dans ce qui précède, on a introduit, sans trop insister, qui consiste à remplacer les 1 par des 0, et inversement,
la notion de précision du résultat. Cette précision n’est puis ajouter 1 au résultat ; soit, toujours sur un octet :
jamais absolue pour plusieurs raisons. 00000001 = 1 et 11111111 = −1. Ainsi de 00000000 = 0
2. Shot off to outer space comme disent joliment nos collègues à 01111111 = 127 on code des nombres positifs et pour
américains. les nombres négatifs, 11111111 = −1, 11111110 = −2,
Physique numérique, Philippe Depondt 49

. . ., jusqu’à 10000000 = −12 ∗ 8. On peut vérifier qu’avec Le résultat obtenu est 0. et non 1. ! La raison en est
cette convention l’addition suivante est correcte : que l’on ajoute 1000 + 1 10−9 ce qui, compte tenu de la
−4 11111100 précision machine, vaut 1000 : peu importe que l’on répète
+2 00000010 l’opération un milliard de fois ! Finalement 1000 − 1000 =
= −2 11111110 0. . . En déclarant s en double precision on obtient :
Afin d’avoir une plage de nombres accessibles plus 0.999989425 4
grande, les octets sont généralement regroupés par en- Il faut donc être assez méfiant lorsqu’on traite des
sembles de quatre (appelés mots), soit 32 bits 3 . Ainsi les nombres qui prennent des valeurs très différentes. Il est
nombres entiers peuvent aller de −231 = −2 147 483 648 à aussi prudent de se rappeler que lorsqu’on fait des calculs
231 − 1 = 2 147 483 647, ce qui est largement suffisant pour itératifs, ce qui est très souvent le cas, les erreurs peuvent
la plupart des applications, mais, évidemment, pas infini. s’ajouter les unes aux autres pour ne plus être négligeables
du tout !
Un deuxième cas de figure classique est le suivant :
4.2.2 Les nombres réels.
if( a == 0. ) then
Parler de nombres réels est un abus de langage puisque √ où a est un réel. Le résultat d’une telle instruction est
l’on ne peut traiter que les nombres rationnels. Ainsi, 2 aléatoire à cause des erreurs d’arrondi ! En effet, si a est le
sera approximé par, par exemple, 1,414213562. De plus, résultat de calculs longs et compliqués, va-t-il tomber pile
on est obligé de se restreindre encore davantage aux nom- sur zéro ou sur 0.1234567E-35 ? Il vaut bien mieux définir
bres rationnels à un nombre fini de chiffres : 1/3 devient a priori la précision souhaitée et donner l’instruction :
par exemple 0,3333333333. Un tel nombre rationnel, si if( abs(a) < epsilon ) then
l’on supprime la virgule, est un nombre entier : il suf- si la valeur absolue de a est plus petite que ε, alors. . .
fit de préciser l’emplacement de la virgule, par une puis-
sance de 10, par exemple. Ainsi, 1,414213562 peut s’écrire Ainsi, une règle d’or à ne jamais oublier lorsqu’on
1414213562 10−9 . Une autre façon de s’y prendre serait : fait des calculs numériques est de vérifier sur
0, 1414213562 101 . L’avantage de la deuxième est que l’- des cas dont on connait la solution que les pro-
expression des chiffres composant le nombre est comprise grammes que l’on a écrits donnent bien la solu-
entre 0 et 1, chaque chiffre correspondant non plus à une tion attendue. . . tout en sachant qu’il ne s’agit en
puissance positive de 10 mais à une puissance négative. aucun cas d’une garantie !
Il faut donc trois choses : le signe, la position de la vir-
gule (ou l’exposant), et les chiffres (la mantisse). Le raison-
nement mené jusqu’à présent avec une notation décimale
4.3 Suites et séries.
peut-être tout aussi bien fait en binaire.
4.3.1 Généralités et premières difficultés.
Ainsi un nombre réel s’écrit, en général sur quatre
octets, soit 32 bits : 1 bit pour le signe, 8 bits pour l’- Une suite est définie par une relation de récurrence du
exposant qui donne une puissance de 2 puisqu’il s’agit de type :
nombres binaires, 23 bits pour la mantisse ; or le premier un = f (un−1 , un−2 , . . . , un−p )
bit de la mantisse est toujours 1 (sinon, il faudrait dimin-
où un est une fonction de l’élément de la suite précédent
uer l’exposant de 1), donc on l’omet ce qui permet de
ou de plusieurs éléments précédents. Par exemple, la fac-
gagner un bit significatif.
torielle :
Dans ces conditions, les nombres réels peuvent s’étendre n! = n(n − 1)! avec 1! = 1
de ±1, 175494 10−38 à ±3, 402823 1038 avec sept chiffres
significatifs. Si cela ne suffit pas, on peut utiliser la double Une série s’écrit comme :
precision sur 8 octets qui donne 15 chiffres significatifs Xn
de 2, 225074 10−308 à 1, 797693 10308 . Certaines machines sn = ui ou bien sn = sn−1 + un
acceptent aussi les real*16 sur 16 octets. . . i=1

Il n’est pas utile de faire un tableau contenant tous les

4.2.3 Conséquence. termes de la suite ou de la série, car on n’a en général
besoin que du dernier terme : c’est le reproche que l’on
La conséquence de tout ceci est que les calculs se font faisait à la récursivité. Dans le cas de la factorielle, il suffit
avec une certaine précision intrinsèque (qui est a priori d’écrire quelque chose qui ressemble à
bonne : sept chiffres significatifs. . .). Imaginons toutefois
le programme, certes stupide, suivant : f = 1
do i = 2, n ; f = f*i ; enddo
implicit none
integer :: i en faisant croı̂tre i dans une boucle. Pour une série, cela
real :: s deviendrait :
s = 1000.
s = ... ! expression du premier terme
do i = 1, 1000000000
do i = 2, n
s = s + 1e-9
s = s + .... ! expression du terme general
enddo
enddo
write(*,*) s-1000.
end 4. Le résultat précis dépend du type de la machine utilisée, du
compilateur : ici, il s’agit d’une machine Linux avec g77. Parfois il
3. Certaines machines, comme les Cray ou certaines stations de peut être judicieux d’essayer le même programme sur deux machines
travail, utilisent des mots de huit octets, soit 64 bits. différentes avec deux compilateurs différents.
50 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

4.3.1.1 Précision. existe une solution très simple au problème :

Il faut être prudent lors du calcul d’une suite car la Pn (x) = (. . . ((an x + an−1 )x + an−2 )x + . . .)x + a0
remarque du paragraphe 4.2.3 s’applique tout à fait et
l’on a parfois des surprises. Par exemple, la série : et cela se programme sans difficulté à l’aide d’une boucle
décroissante :
x2n−1
sn (x) = sn−1 (x) + (−1)n−1 , avec s1 (x) = x real function polyn(x,a,n) ! schema de Horner
(2n − 1)! integer :: i, n
est simplement le développement de la fonction sinus real, dimension(0:n) :: a
limité à l’ordre 2n − 1. Le programme suivant est l’ap- real :: x, pn
plication directe de cette formule : pn = a(n)
do i = n-1, 0, -1
implicit none pn = pn*x + a(i)
real :: x, s enddo
integer :: n, i, p, f, l polyn = pn
n = 17 ! indice du dernier terme end
x = acos(-1.0)/2 ! calcul de pi/2
f = 1 ; s = x ; l = 1 ! initialisations On aurait tort de se priver !
do i = 2, n
p = 2*i-1 ! exposant 4.3.2 Calcul des intégrales.
f = f*(p-1)*p ! factorielle
l = -l ! changement de signe Toutes les intégrales ne sont pas calculables analy-
s = s + l*x**p/f tiquement malgré les tables et les programmes de calcul
enddo formel, et c’est parfois bien utile de pouvoir les évaluer
write(*,*) sin(x), s, s-sin(x) ! comparaison numériquement.
end Par exemple, admettons que l’on ait un fil chargé. Le fil
À l’ordre n = 17, ce qui correspond en fait à un est décrit par trois coordonées en fonction d’une abscisse
développement limité à l’ordre 33 en x, on obtient pour curviligne s : (x(s), y(s), z(s)) et sa charge par une densité
x = π2 , le résultat s=0.9964 au lieu de un, un résultat linéique σ(s). Le potentiel électrostatique en un point de
un peu décevant pour un ordre aussi élevé. Pire, si l’on coordonnées (x0 , y0 , z0 ) s’écrit :
tente d’aller plus loin, n = 18, on obtient -INF. . . C’est
simplement que l’on est en train d’additionner des termes V (x0 , y0 , z0 ) =
Z s1
de signes opposés et que la différence des valeurs absolues 1 σ(s) ds
est petite, donc ils se compensent en grande partie deux à p
4πε0 s0 (x(s) − x0 )2 + (y(s) − y0 )2 + (z(s) − z0 )2
deux ; le résultat est entaché d’une erreur relative impor-
tante. Si l’on essaye d’aller trop loin pour réduire l’erreur,
les factorielles se mettent à produire des nombres gigan-
tesques ! Il se trouve que pour ce genre de calcul, ce n’est
pas la bonne méthode : il vaut mieux utiliser les polynômes
dits ≪ de Tchebytchev ≫ 5 .
On peut en tirer deux conclusions. La première est que
sommer des termes sans prendre de précautions est parfois
dangereux. La deuxième est que, lorsqu’on peut le faire, il
est bon de classer les termes que l’on doit sommer par or-
dre croissant de telle façon à éviter autant que possible les
additions de termes d’ordre de grandeurs très différents.
Figure 4.7 – Un fil chargé.
4.3.1.2 Polynômes : le schéma de Horner.
Si l’allure du fil ressemble à celui de la figure 4.7, une
Le calcul d’un polynôme est un bon exemple de ce qui intégration numérique sur ordinateur peut être une solu-
a été dit ci-dessus. Soit : tion de bon goût !
n
X
Pn (x) = aℓ x ℓ 4.3.2.1 Méthode des rectangles.
ℓ=0
C’est la plus simple : il s’agit de remplacer une intégrale
Ne pas tenter de faire la somme ci-dessus directe-
par une somme finie (voir la figure 4.8) :
ment ! En effet les puissances successives de x produiront
sans aucun doute des termes dont les ordres grandeurs Z b n−1
X b−a
seront extrêmement variables, avec des conséquences f (x) dx ∼ f (a + iδx )δx avec δx =
a n
désastreuses 6 . Ce serait d’autant plus impardonnable qu’il i=0

5. Voir par exemple dans les Numerical Recipes, référence [3] dans on remplace le calcul de la surface par une approximation
la bibliographie. constituée d’une somme de surfaces de rectangles.
6. Numerical Recipes (voir bibliographie, référence [3]), qui n’y Une autre approximation tout aussi légitime serait :
va pas avec le dos de la cuillère, va jusqu’à menacer : ≪ Come the
(computer) revolution, all persons found guilty of such criminal be- Z b Xn
haviour will be summarily executed ≫ ! L’humour est sans doute f (x) dx ∼ f (a + iδx )δx
douteux, mais le message est clair. a i=1
Physique numérique, Philippe Depondt 51

extrêmes sont divisés par deux : en fait, il s’agit d’une

méthode des rectangles centrée dans laquelle les points
extrêmes ≪ pèsent ≫ moitié moins (figure 4.10).

Methode des rectangles a gauche Methode des rectangles a droite

Figure 4.8 – Les deux variantes de la méthode des rect-

angles.

La seule différence est dans les bornes de la somme qui

maintenant démarre en i = 1 au lieu de zéro. Cela revient Figure 4.10 – Schéma équivalent à la méthode des
à évaluer la valeur de la fonction à droite de l’intervalle au trapèzes.
lieu de l’évaluer à gauche. C’est pour cela que ces méthodes
sont appelées méthodes des rectangles à gauche pour l’une, Le résultat en est un gain d’un ordre de grandeur sur
à droite pour l’autre. En principe, plus n est grand, plus les l’incertitude du résultat.
deux résultats doivent être proches : gare aux problèmes
d’arrondis numériques toutefois si n est trop grand ! 4.3.2.3 Recherche du pas d’intégration.
La grosse différence entre une intégration numérique et
4.3.2.2 Méthode des trapèzes. l’expression mathématique est que le pas d’intégration δx
Une méthode moins primitive et à peine plus compliquée ne tend pas vers zéro, dans un calcul numérique, il prend
est la méthode des trapèzes (figure 4.9). une valeur finie non nulle : c’est une approximation, il
reste à choisir cette valeur de la façon la moins arbitraire
possible.
Une première méthode serait de choisir δx arbitraire-
ment, faire le calcul d’intégrale, puis choisir une autre
valeur et refaire le calcul. Si les deux résultats diffèrent
d’une quantité moindre que la précision souhaitée, c’est
que le calcul est ≪ indépendant ≫ de δx .
Il n’est pas interdit d’essayer de systématiser un peu ce
genre de recherche. Commençons par choisir δx = b − a,
alors une première estimation de l’intégrale par la méthode
des trapèzes serait :
f (a) + f (b)
S0 = (b − a)
2
Pour une deuxième estimation, on peut alors diviser δx
par deux, on obtient alors :
   
Figure 4.9 – La méthode des trapèzes. (b − a) f (a) a+b f (b)
S1 = +f +
2 2 2 2
La surface du i-ième trapèze s’écrit : S0
= + R1
1 2
si = (f (a + (i − 1)δx ) + f (a + iδx )) δx avec, en posant h = b − a :
2
 
et donc : h a+b
R1 = f
Z b Xn 2 2
1
f (x) dx ∼ (f (a + (i − 1)δx ) + f (a + iδx )) δx ce qui évite d’avoir à recalculer les deux points extrêmes.
a i=1
2
On redivise le pas par deux, puis de nouveau encore,
soit en regroupant les termes identiques : etc. Un calcul simple donne alors le terme général de la
Z b ! récurrence :
n−1
X
1 1 Sn−1
f (x) dx ∼ δx f (a) + f (a + iδx ) + f (b) Sn = + Rn
a 2 i=1
2 2
2n−1  
on retrouve une formule très similaire à celle de la méthode h X h
Rn = f a + (2i − 1)
des rectangles, mais elle est symétrisée et les termes 2n i=1 2n
52 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

On arrête le calcul lorsque l’écart entre deux résultats suc- la distance à l’axe :
cessifs est inférieur à la précision requise :  
r2
n = n0 1− 2
|Sn − Sn−1 | < ε 2ρ

C’est cependant une méthode qui n’est totalement dénuée où n0 et ρ sont des constantes. Il s’agit d’une fibre à gradi-
de danger : soit par exemple la fonction suivante (figure ent d’indice qui permet de piéger, pour ainsi dire, le rayon
4.11), lumineux au centre de la fibre. Si l’on se place dans le plan
xOy, r2 se ramène à y 2 et chercher le trajet du rayon lu-
mineux revient à chercher la fonction y(x). Une incursion
1
dans le cours d’optique fournit l’équation de propagation
0.8
d’un rayon lumineux :
 
d~r
0.6 d n
ds ~ n
= grad (4.2)
0.4
ds
où s est l’abscisse curviligne sur le rayon du point ~r. Ceci
0.2 se résoud analytiquement assez aisément à condition de se
placer dans l’approximation où le rayon ne s’éloigne pas
0
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2 trop de l’axe de la fibre, de façon que sa pente par rapport
à l’axe reste faible, de sorte que l’on puisse identifier ds à
Figure 4.11 – Si l’on ne prend pas de précautions, dx. On obtient :
l’intégrale de cette fonction sera nulle !    
d~r ∂n
d n = 0
dx  ∂x 
 =
si x < 0, 5 ou si x > 1, 5 f (x) = 0 dx ∂n n0 y 
= − 2
sinon f (x) = 1 ∂y ρ
que l’on souhaite intégrer de a = −2 à b = 2. La première soit, après quelques manipulations simples,
étape donne zéro, et . . . la deuxième aussi. L’écart est nul
et donc inférieur à ε : le programme s’arrêtera. La même d2 y n0 y
n =− 2
mésaventure arrive si l’on cherche dx2 ρ
Z π
Il reste à approximer n par n0 , puisqu’on ne s’éloigne pas
sin(x)dx de l’axe de la fibre, et à chercher des solutions du type :
−π

on trouve le résultat correct (soit 0), mais complètement 2π

y(x) = a sin x
par hasard ! Il vaut mieux restreindre le calcul de 0 à π. λ
Comme souvent dans ce genre d’activités, un minimum de pour obtenir :
circonspection s’impose. λ = 2πρ
Un sous-programme pourrait donner quelque chose qui
ressemble à : On obtient alors une trajectoire sinusoı̈dale de période
2πρ indépendante de l’amplitude des oscillations : c’est
double precision function trapeze(f, a, b, eps)
intéressant pratiquement, car ainsi le rayon, même si, ini-
implicit none
double precision :: f, a, b, eps, s, h, r, sp, hm
tialement, il n’est pas parfaitement dans l’axe, se bornera
integer :: n, m, i à osciller autour de celui-ci au cours de sa propagation.
Tout ceci reste cependant un peu formel et entaché d’ap-
h = b-a ; m = 1 proximations.
s = h*(f(a)+f(b))*0.5d0 Un cours d’optique normalement constitué affirme
do n = 1, 20 ! 20 iterations max généralement -voire même démontre- que l’équation 4.2
m = 2*m ! 2**n est une conséquence du principe de Fermat qui veut que
hm = h/m ; r =0. le chemin optique ne dépende pas d’un petit changement
do i = 1, m/2 ! de 1 a 2**(n-1) de trajectoire, soit :
r = r + f(a+(2*i-1)*hm)
enddo Z l
sp = s/2 + r*hm L= n ds est un extremum
0
! ---> le test force au moins quatre iterations
if( abs(s-sp) < eps .and. n > 3 ) exit L
s = sp Pour le vérifier, calculons dans le cas de la trajectoire
λ
enddo sinusoı̈dale ci-dessus :
trapeze = sp Z  
end L n0 λ y2
= 1 − 2 ds
λ λ 0 2ρ
4.3.2.4 Un exemple : le principe de Fermat or s  2
Imaginons un rayon lumineux qui circule dans une fibre 2 2 2 dy
ds = dx + dy ⇒ ds = dx 1+
optique cylindrique, parallèle à x, dont l’indice dépend de dx
Physique numérique, Philippe Depondt 53

soit l’intégrale suivante à calculer : On a essentiellement deux solutions :

L 1. la fonction f (x) doit tendre vers zéro lorsque x →
=
λ ±∞, sinon le résultat est infini, alors on peut faire
! s  2 l’approximation :
Z
n0 λ
a2 sin2 2πx
λ 2πx 2π
1− dx1 + a2 cos2 Z ∞ Z b
0 λ 2ρ2 λ λ
f (x)dx ∼ f (x)dx
(4.3) −∞ a
Choisissons de nous intéresser au cas où a est petit par
avec a et b suffisamment grands en valeur absolue
rapport à λ : on peut alors développer la racine carrée :
pour que l’erreur soit négligeable. Par exemple,
L
∼ Z ∞ Z 5σ
λ x2 x2

Z !  2 ! e− σ2 dx ∼ e− σ2 dx
n0 λ
a2 sin2 2πx a2 2π 2πx −∞ −5σ
1− λ
1+ cos2 dx
λ 0 2ρ2 2 λ λ n’est pas une mauvaise approximation.
4 2. une méthode plus élégante est de découper l’intégrale
On
R 2π peut ensuiteR éliminer le terme en a et sachant que
2 2π
0
sin x dx = 0 cos2 x dx = π, on finit par avoir : Z ∞ Z a Z b Z ∞
  f (x)dx = f (x)dx + f (x)dx + f (x)dx
L a2 a2 π 2
∼ n0 1 − 2 + 2 −∞ −∞ a b
λ 4ρ λ
et de faire des approximations pour les extrémités,
La condition pour que L ne dépende pas de a est que :
sur la base d’un développement limité par exemple.
λ = 2πρ Une illustration physique simple pourrait être une dis-
ce qu’on avait déjà trouvé auparavent : l’intérêt du sec- tribution linéique de charges sur une pelote de ficelle
ond calcul étant de montrer que le chemin optique ne de forme compliquée mais dont les extrémités vont à
dépendant pas de a, une source de lumière cohérente l’infini. Le potentiel créé à l’origine pourrait s’écrire :
placée à l’entrée de la fibre sur son axe, et produisant Z ∞
1 σ(s)
un faisceau non totalement parallèle, donnera, en sortie V = p ds
4πε0 −∞ x2 (s) + y 2 (s) + z 2 (s)
de la fibre, un faisceau qui n’aura pas perdu sa cohérence,
malgré la divergence. où, σ, x, y et z sont des fonctions connues de l’ab-
0 scisse curviligne s. Admettons qu’une approxima-
−0.01 tion serait que lorsque s > b alors σ ∼ sς et que
p
−0.02 x2 (s) + y 2 (s) + z 2 (s) ∼ s. On obtient alors,
−0.03 Z ∞ Z ∞
σ(s) ς ς
L/lambda − n0

−0.04
p ds ∼ 2
ds =
−0.05 b
2 2
x (s) + y (s) + z (s)2
b s b
−0.06
−0.07 La même approximation pour s < a donnerait en fin
−0.08 de compte :
−0.09 " Z b #
1 ς σ(s) ς
−0.1
0 0.2 0.4 0.6 0.8 1 V = − + p ds +
a 4πε0 a a x2 (s) + y 2 (s) + z 2 (s) b

Figure 4.12 – L’intégrale L où la partie centrale serait calculée par la méthode
λ − n0 en fonction de a calculée
numériquement par la méthode des trapèzes. des trapèzes.
On peut également utiliser des méthodes similaires autour
On est toutefois en droit de se demander quelle est de points singuliers à condition de les avoir identifiés au
la validité des approximations que l’on a faites : pour préalable.
cela, il suffit d’intégrer numériquement l’équation (4.3)
(Exercice : le faire ! 7 ) en faisant varier a pour λ = 2πρ :
cela donne la figure 4.12 ; on constate que tant que a < 4.4 Échantillonnages, interpola-
0.5ρ, l’erreur reste inférieure à 0.01, (pour L ∼ 1.5) ce
qu’on n’aurait probablement pas deviné sinon.
tion.
On a vu, pour le problème de l’intégration, l’impor-
4.3.2.5 Intégrales indéfinies. tance du pas d’intégration : c’est déjà une première
Dans toutes les discussions ci-dessus, seules les forme d’échantillonnage puisqu’une fonction définie sur un
intégrales définies ont été abordées. On ne peut pas cal- morceau de l’axe réel se trouve réduite à un ensemble dis-
culer par ces méthodes des intégrales du type : cret de points.
Z ∞ De même, lorsqu’on demande à un logiciel comme
f (x)dx gnuplot (ou à une calculette graphique, d’ailleurs) de
−∞ tracer le graphe d’une fonction, sin x par exemple, il cal-
7. prendre par exemple ρ = 1 et n0 = 1.5. On calculera en double cule les valeurs de la fonction en un certain nombre de
precision. points, reliés ensuite par des lignes droites ; en général, les
54 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

1
4.4.2 Approximation parabolique.
0.8
0.6
0.4
0.2
0
−0.2
−0.4
−0.6
−0.8
−1
−10 −5 0 5 10

Figure 4.13 – Le graphe de la fonction sin(100x) tracé

sans précaution particulière.

≪ options par défaut ≫ permettent d’éviter de préciser

comment on veut que ce choix de points soit fait, ce Figure 4.14 – Approximation linéaire et approximation
qui donne une fausse impression d’évidence au choix de parabolique autour du point situé en x=0.5.
l’échantillonnage.
Il arrive toutefois, comme on peut le constater sur la Pour tenir compte de la courbure, on peut remplacer
figure 4.13, que le résultat ne soit pas à la hauteur des l’approximation linéaire par une parabole qui, cette fois
espérances ! Dans cet exemple, en effet, on a tenté de doit passer par trois points. Ainsi :
2π
tracer une fonction périodique de période 100 à l’aide d’un
échantillonnage de 100 points sur un intervalle de longueur pℓ (x) = aℓ x2 + bℓ x + cℓ
20, soit un pas d’échantillonnage de 0, 2 plus grand que la
période de la fonction. . . échec assuré, encore fallait-il le de façon que :
prévoir 8 .
pℓ (xℓ−1 ) = f (xℓ−1 )
Ainsi, une fonction 9 y = f (x) pour un ordinateur est
toujours représentée en fin de compte par un nombre pℓ (xℓ ) = f (xℓ )
fini de points, c’est-à-dire par un nombre fini de cou- pℓ (xℓ+1 ) = f (xℓ+1 )
ples (xi , yi ). Dans le cas du sinus, bien sûr, on peut tou-
jours calculer des points supplémentaires si l’aspect de la On obtient aisément :
courbe n’est pas convenable. Cependant, ce n’est pas tou- (x − xℓ )(x − xℓ+1 )
jours possible, soit parce que le temps de calcul à investir pℓ (x) = f (xℓ−1 )
(xℓ−1 − xℓ )(xℓ−1 − xℓ+1 )
serait trop long, soit parce qu’il s’agit de données obtenues
autrement, expérimentalement par exemple, et qu’il n’est (x − xℓ+1 )(x − xℓ−1 )
+ f (xℓ )
pas question de refaire l’expérience avec, mettons, cent fois (xℓ − xℓ+1 )(xℓ − xℓ−1 )
plus de points. . . or il peut arriver que l’on ait besoin de (x − xℓ−1 )(x − xℓ )
+ f (xℓ+1 )
connaı̂tre la valeur de la fonction entre deux points. (xℓ+1 − xℓ−1 )(xℓ+1 − xℓ )
On peut, bien souvent, s’en sortir quand même à l’aide
d’approximations moyennant quelques hypothèses. ceci est valable dans l’intervalle [xℓ − h2 , xℓ + h2 ] où, bien
sûr, h est l’intervalle entre deux points successifs.
4.4.1 Interpolation linéaire. A priori cette approximation est meilleure que la
précédente, permettant une bonne description de la fonc-
C’est la plus simple : si x est compris entre xℓ et xℓ+1 , tion avec un nombre de points plus faible ; il y cependant
on écrit la fonction approchée pℓ (x), une hypothèse importante derrière cela, c’est que la fonc-
tion ne se livre pas à des excentricités entre deux points
f (xℓ+1 ) − f (xℓ )
pℓ (x) = f (xℓ ) + (x − xℓ ) (4.4) successifs, par exemple, qu’il n’y ait pas de point singulier
xℓ+1 − xℓ ou de variations énormes entre deux points connus.
ce qui revient à considérer la fonction comme localement
linéaire. L’erreur est évidemment d’autant plus grande que 4.4.3 Polynômes de Lagrange.
la courbure de la fonction est grande.
Il est aisé quoique rapidement fastidieux de généraliser
8. le logiciel gnuplot permet de définir le nombre de points que la méthode ci-dessus à un polynôme de degré n quel-
l’on veut sur un intervalle : par exemple set samples 1000 indique conque. On obtient un polynôme passant par les n + 1
que dorénavent l’intervalle sera décrit pas 1000 points (au lieu de 100,
la valeur par défaut). Cependant, tenter de résoudre le problème de points (x0 , f (x0 )), . . ., (xℓ , f (xℓ )) . . ., (xn , f (xn )) :
cette façon serait dans ce cas décevant parce qu’on obtiendra selon
toute vraisemblance un écran tout noir. . . Il est vrai que vouloir pn (x) =
tracer une courbe de période 2π/100 ≃ 0,0628 sur un intervalle
[−10, 10], c’est chercher la difficulté. n
X (x − x0 ) . . . (x − xℓ−1 )(x − xℓ+1 ) . . . (x − xn )
9. Au sens mathématique, bien sûr, il ne s’agit pas de la function f (xℓ )
fortran. (xℓ − x0 ) . . . (xℓ − xℓ−1 )(xℓ − xℓ+1 ) . . . (xℓ − xn )
ℓ=0
Physique numérique, Philippe Depondt 55

dans les produits du numérateur et du dénominateur de la peuvent donner des valeurs numériques importantes pour,
fraction ci-dessus, manquent évidemment les termes x−xℓ mettons, la dérivée première, et ces valeurs risquent de
et . . . xℓ − xℓ ! changer brutalement d’un point à un autre. En pratique,
Le choix du degré le plus approprié pour le polynôme on se limite donc à des dérivées d’ordre faible, un voire
n’est pas facile. Une bonne règle est de ne pas essayer de deux, sur des données de très bonne qualité intrinsèque.
trop bien faire ! En effet le choix d’un degré trop élevé, bien On verra dans le chapitre 4.8 d’autres méthodes plus sûres
loin d’améliorer l’interpolation, risque de produire des os- en présence de bruit.
cillations complétement erratiques de l’interpolation entre
les points connus. Il est bien rare qu’un degré supérieur
à 3 se justifie vraiment, c’est en général le signe que l’on 4.5 Algèbre linéaire.
commence à manquer de données de références : peut-être
est-il temps alors d’envisager de faire quelques points de 4.5.1 Un exemple : la diffusion de la
mesure expérimentaux supplémentaires. . . L’informatique, chaleur à une dimension.
contrairement à la magie, ne peut pas tout faire, en par-
La loi de Fourier de diffusion de la chaleur dit simple-
ticulier inventer des données numériques manquantes !
ment que le flux de chaleur en un point est proportionnel
au gradient de température :
4.4.4 Dérivées.
~ r) = −κ(~r) grad
φ(~ ~ T (~r)
Les mêmes méthodes permettent en principe une
évaluation des dérivées successives d’une fonction puisqu’à où κ(~r) est la conductivité thermique qui dépend de la
partir de l’expression d’un polynôme de Lagrange de degré nature du milieu. Si celui-ci est homogène, κ est une con-
n on peut facilement obtenir des expressions pour les stante, sinon κ dépend de la position ~r.
dérivées jusqu’à la dérivée n-ième. Si l’on produit de la chaleur en un point ~r donné (par
Par exemple, une expression de la dérivée première peut effet Joule ou par un apport quelconque, ou encore au
être obtenue à partir de l’approximation linéaire, éq. (4.4) : contraire par une perte dans l’atmosphère), cette chaleur
doit diffuser et cette chaleur diffusée par unité de temps
f (xℓ+1 ) − f (xℓ ) doit être égale à la quantité Q̇(~r) de chaleur produite par
p′ℓ =
xℓ+1 − xℓ unité de temps, ce qui donne :
En fait, il s’agirait plutôt d’un calcul de la dérivée en ~ r) = Q̇(~r)
xℓ+1 +xℓ div φ(~
2 , au milieu de l’intervalle, et non en xℓ . Si l’on
préfère une expression plus symétrique qui donne une En combinant ces deux équations, on obtient facilement :
autre estimation plus précisément en xℓ :
~ κ(~r) · grad
grad ~ T (~r) + κ(~r) ∆T (~r) = −Q̇(~r) (4.5)
f (xℓ+1 ) − f (xℓ−1 )
p′ℓ =
xℓ+1 − xℓ−1 Cette équation, alliée à d’éventuelles conditions aux lim-
ites, permet, en principe, de calculer la distribution de
On montre d’ailleurs aisément que cette dernière expres- température en régime stationnaire dans un objet, con-
sion vient de la dérivation de l’approximation parabolique. naissant Q̇(~r) et κ(~r). Autant dire que ce n’est pas tou-
jours facile : que faudrait-il faire pour une résolution
numérique ?
Pour simplifier, on se restreindra ici à une dimension,
mais le problème n’est pas très différent à trois dimensions,
du moins dans des géométries simples. L’équation (4.5) se
réduit alors à :

dκ dT d2 T
+ κ 2 = −Q̇(x)
dx dx dx
Le première étape est de discrétiser le problème : on
pose,

x = i δx
où i est un entier et δx un pas d’intégration, similaire à ce
qui a déjà été vu dans le chapitre 4.3.2. On note alors :

Figure 4.15 – Derivée d’un sinus affecté d’un léger bruit. T (x) = T (i δx ) = Ti
La dérivée, elle, est affectée d’un fort bruit, même si l’al- dT
lure générale est convenable. La dérivée peut être approchée par :
dx
Il faut cependant être assez prudent. Outre la remar- dT Ti+1 − Ti
∼
que ci-dessus concernant la limite pratique sur le degré dx δx
du polynôme utilisé, il faut être conscient qu’un calcul de
ou bien
dérivée va tendre à amplifier le bruit (figure 4.15). En ef- dT Ti − Ti−1
fet, des fluctuations locales, de point à point, de la fonction ∼
dx δx
 56 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

ou encore : Dans le cas présent, un système d’équations linéaires se

dT Ti+1 − Ti−1 présente de la façon suivante :
∼
dx 2δx 
On préfèrera la troisième forme plus symétrique. La  a11 x1 + a12 x2 + a13 x3 + · · · + a1n xn = b1



 a21 x1 + a22 x2 + a23 x3 + · · · + a2n xn = b2
dérivée seconde, la dérivée de la dérivée, s’écrit : 

a31 x1 + a32 x2 + a33 x3 + · · · + a3n xn = b3

 a41 x1 + a42 x2 + a43 x3 + · · · + a4n xn = b4
Ti+1 − Ti Ti − Ti−1 

2 − 
 ···
d T δx δx Ti+1 − 2Ti + Ti−1 
∼ = a n1 x 1 + a n2 x 2 + a n3 x3 + · · · + ann xn = bn
dx2 δx δx2
où l’on cherche les xi . Le problème peut se reformuler en
Cela donne donc, avec des notations évidentes : termes matriciels :
  A·x=b
dκ Ti+1 − Ti−1 Ti+1 − 2Ti + Ti−1
+ κi = − Q̇ i (4.6)
dx i 2δx δx2 avec  
a11 a12 a13 · · · a1n
 a21 a22 a23 · · · a2n 
Si L est la longueur du barreau, alors n = δLx est le nombre  
 a31 a32 a33 · · · a3n 
de segments sur le barreau : c’est a priori un nombre qui A=  

peut être grand, quelques centaines, milliers, voire plus ;  a41 a42 a43 · · · a4n 
 ··· 
or, l’équation (4.6) se reécrit aisément :
an1 an2 an3 · · · ann
   
1 dκ κi κi et
+ 2 Ti+1 − 2 2 Ti +    
2δx dx i δx δx x1 b1
 x2   b2 
       
   b3 
1 dκ κi x =  x3  b =  
− + Ti−1 = −Q̇i  x4   b4 
2δx dx i δx2    
 ···   ··· 
ou bien xn bn

ai,i+1 Ti+1 + ai,i Ti + ai,i−1 Ti−1 = bi ∀i
où les ai,j sont connus et où l’on cherche à calculer les
Ti . On vient de reformuler le problème comme un système
linéaire de n équations à n inconnues (les Ti ) : si on peut
trouver des méthodes pour résoudre de très gros systèmes
d’équations linéaires, alors le problème ci-dessus peut être
considéré comme résolu.
4.5.2 Systèmes d’équations linéaires.
Au delà de n = 2 ou 3, il ne faut surtout pas tenter de
résoudre le système linéaire en procédant par élimination
comme on le fait d’habitude pour une résolution à la main :
les problèmes de stabilité numérique deviennent très vite
cruciaux. Il vaut bien mieux utiliser des sous-programmes
de bibliothèque : ce sont des programmes déjà écrits, sou-
vent depuis longtemps, éprouvés, dont les qualités et les
défauts sont connus, compilés et rassemblés dans des bib-
liothèques. Il suffit d’appeller le sous-programme choisi par
un call dans le programme que l’on a écrit comme n’im-
porte quel autre sous-programme, en suivant toutefois les
indications fournies dans la documentation 10 puis d’in-
voquer la bibliothèque lors de la compilation : c’est en
général une option de compilation 11 : le compilateur ira
puiser dans la bibliothèque ce dont il a besoin. . .
Il n’y a donc aucune raison de réinventer la roue ! C’est
en fait une démarche très courante en calcul scientifique :
on se pose un problème de physique, puis on se demande
comment le traduire de façon à le traiter avec un pro-
gramme de bibliothèque déjà existant.
10. Souvent en ligne.
11. généralement, l’option -l (pour library=bibliothèque), par ex-
emple avec la bibliothèque linpack : g95 machin.f90 -llinpack -o
machin.
Pour ce qui est de la matrice A, il faut savoir que
fortran stocke les matrices multicolonnes colonne par
colonne : une colonne, puis une autre, puis une autre.
En mémoire, se succèdent ainsi : a11 , a21 , a31 , · · · an1
(première colonne), a12 , a22 ,. . .(deuxième colonne),. . . etc.,
c’est-à-dire que le premier indice ≪ va le plus vite ≫ (en
C, c’est l’inverse). Si l’on veut écrire des programmes effi-
caces, il faut tenter de privilégier les appels à des éléments
successifs en mémoire 12 , et donc dans les boucles im-
briquées, mettre autant que possible, le premier indice
dans la boucle la plus interne. Par exemple :
do j = 1, n ! boucles dans le bon ordre
a(1:n,j) = ...
enddo
et non l’inverse :
do i = 1, n ! boucles dans le mauvais ordre
a(i,1:n) = ...
enddo
Pour résoudre le système d’équations, on pourrait imag-
iner qu’il suffise de calculer l’inverse de la matrice A et
faire le produit :
x = A−1 · b
mais il se trouve que les algorithmes de résolution directe
du système d’équations sont plus efficaces.
4.5.2.1 La méthode LU
C’est le véritable cheval de bataille de tous ces
problèmes (voir réf. [3] pour une discussion plus appro-
fondies des qualités et défauts des différentes méthodes,
par exemple Gauss-Jordan).
12. Parce que le compilateur gère mieux les transferts entre
mémoire et processeur de paquets de nombres connexes que des nom-
bres pris dans n’importe quel ordre.
Physique numérique, Philippe Depondt 57

Imaginons que l’on ait décomposé la matrice A en un Pour i ≤ j, on obtient aisément :

produit de deux matrices :
i−1
X
A=L·U uij = aij − lik ukj (4.8)
k=1
où L est une matrice triangulaire inférieure (L = lower )
qui n’a des éléments que sur et sous la diagonale : Enfin, pour i > j :
  j−1
!
l11 0 0 0 1 X
 l21 l22 0 0  lij = aij − lik ukj (4.9)
L=  ujj
 l31 l32 l33 0  k=1

l41 l42 l43 l44 Tous les termes dans les sommes des équations (4.8) et
(4.9) sont déjà calculés à condition d’appliquer les deux
dans le cas où n = 4, et U est une matrice triangulaire
équations par i croissants pour un j donné, puis changer
supérieure (U = upper ) qui n’a des éléments que sur et au
de j. Il ne s’agit finalement que d’un réordonancement très
dessus de la diagonale :
simple du problème.
 
u11 u12 u13 u14 En général, les programmes qui appliquent cet algo-
 0 u22 u23 u24  rithmes détruisent le contenu de la matrice A en rangeant
U=  0

0 u33 u34  les éléments de L dans la partie inférieure de A, et les
0 0 0 u44 éléments de U dans la partie supérieure, sachant que les lii
ne sont pas conservés, puisqu’ils valent 1. En outre, afin de
Le système initial se reécrit : limiter les dégâts lors des divisions par ujj dans l’équation
(4.9), un certain réarrangement des lignes et colonnes
L · (U · x) = b
du système d’équations doit être fait pour commencer
il reste à chercher y tel que : par les éléments pour lesquels ujj est grand (une divi-
sion par un nombre très petit donne parfois des résultats
L·y =b imprévisibles). Les programmes de bibliothèque font cela
et souvent fournissent en prime des diagnostics lorsque A
puis x tel que : est singulière, ou trop proche d’une matrice singulière.
U·x=y
L’avantage de procéder ainsi est que maintenant le système 4.5.2.2 Amélioration itérative de la précision.
est trivial à cause de la forme triangulaire des deux ma-
Il faut néanmoins faire un peu attention à la précision du
trices : 1 1
résultat obtenu, car les termes du type et dans les
b1 lii uii
y1 = équations (4.7) et (4.9) peuvent donner lieu à des surprises
l11
1 si les diviseurs sont petits. Il y a plusieurs façons de s’en
y2 = [b2 − l21 y1 ] sortir. La première consiste à utiliser un sous-programme
l22
1 de bibliothèque capable de détecter ce genre de problème :
y3 = [b3 − (l31 y1 + l32 y2 )] pratiquement toutes les bibliothèques en proposent. Un
l33
autre test possible est de comparer les résultats obtenus
··· (4.7) en simple et en double précision.
puis, en procédant de même à l’envers : Une cure possible est de partir d’une solution approchée
x′ , et donc fausse, obtenue par, mettons, la méthode LU
yn et de chercher à l’améliorer.
xn =
unn Soit :
··· A · x′ = b + δb
Reste à faire la décomposition proprement dite. où δb est l’erreur qu’il faut réduire ; or :
Il s’agit d’un algorithme typique de ceux dont sont
friands les amateurs. Nous le détaillons ici pour le plaisir x′ = x + δx, et A · x = b
13
de ce genre de tourisme ! Cela s’appelle l’algorithme de
Crout. donc :
Le problème est de trouver lij et uij tels que : A · δx = δb = A · x′ − b

min(i,j)
qui est un système que l’on peut résoudre pour obtenir δx.
X On peut alors corriger x′ et recommencer jusqu’à obtenir
lik ukj = aij
la précision voulue, à condition évidemment que l’algo-
k=1
rithme converge. . .
n(n + 1) Il faut savoir cependant que les bibliothèques pro-
Il y a n2 équations, or L comporte éléments a
2 posent généralement un très grand nombre de sous-
priori non nuls, ainsi que U, soit n2 + n inconnues, et donc programmes prévus pour des cas très divers : il est
n de trop. On fixe alors : donc conseillé de choisir le programme adapté. Toutefois,
pour la plupart des problèmes ≪ standards ≫ du physi-
lii = 1, ∀i
cien, la méthode LU est très satisfaisante, mais pour les
13. Et surtout pas pour l’apprendre par cœur. . . problèmes exigeant d’énormes matrices creuses tels que les
 58 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

méthodes d’éléments finis (pour la résolution de problèmes Les équations (4.8) et (4.9) se réduisent à :
de mécanique des fluides par exemple), des méthodes
spécialement prévues à cet effet doivent être utilisées. i=j−1 uj−1j = ej
i=j ujj = dj − ljj−1 uj−1j
4.5.2.3 Matrice inverse. fj
i=j+1 lj+1j =
Une fois la décomposition achevée, il est facile de rem- ujj
placer b par :   Les équations ci-dessus ne constituent pas en elles-
1 même l’intérêt principal de ce paragraphe : le but est
 0 
  ici d’attirer l’attention sur le fait que pour un type de
 0 
  matrice, la méthode de résolution que l’on choisira n’est
 .. 
 .  pas toujours la même que pour un autre type de ma-
0 trice. Les bibliothèques sont parfois fort riches et il est de
bon ton de chercher un peu dans la documentation quel
ce qui donne la première colonne de A−1 dans x, puis on peut être le sous-programme le plus adapté au cas parti-
procède colonne par colonne en posant : culier envisagé. Il existe des solutions pour des matrices
  ≪ bande-diagonales ≫ ou des solutions itératives par ap-
0
proximations successives pour des problèmes difficiles, des
 .. 
 .  décompositions en valeurs singulières quand le problème
 
b=  1 
 se pose. . ., les ressources sont abondantes, parfois un peu
 .  trop, même !
 .. 
0
4.5.3 Une généralisation de la méthode de
en plaçant le nombre 1 sur la i -ème ligne de b pour obtenir Newton à plusieurs dimensions.
la i -ème colonne de A−1 .
Au chapitre 4.1.2, on a mentionné le fait que la méthode
de Newton de recherche de zéro pouvait se généraliser à
4.5.2.4 Déterminant d’une matrice. plusieurs dimensions. Cela peut être utile, si par exemple,
C’est encore plus simple : au lieu d’un seul pendule comme dans l’exemple, on en
avait plusieurs couplés entre eux et non plus astreints à se
n
Y déplacer dans un plan : on aurait alors deux angles polaires
det A = ujj par pendule à trouver et donc un système de 2N variables
j=1
à rechercher.
C’est le moment de s’y attaquer. Soit donc n fonctions
4.5.2.5 Matrice tridiagonale. de n variables
Si l’on étudie l’équation (4.6), on s’aperçoit vite que
fj (x1 , . . . , xi , . . . , xn ), ∀j ∈ [1, n]
seuls les termes en i − 1, i et i + 1 sont non nuls. La
matrice A ne comporte alors que des termes diagonaux, dont on suppose qu’elles possèdent un zéro et qu’elles sont
sous-diagonaux et sur-diagonaux : elle est donc tridiago- raisonnablement ≪ civilisées ≫ 14 : ces fonctions ne sont
nale : toutefois évidemment pas linéaires.
  On démarre la recherche comme avant à partir d’un
a11 a12 0 0 0 ··· 0
 a21 a22 a23 0 0 ··· 0  point de départ :
 0 a32 a33 a34 0 0 
 ··· 
 ··· ··· · · · · · · · · · · · · · · ·  (0) (0)
x1 , . . . , xi , . . . , x(0)
A=   n
 ··· 0 aii−1 aii aii+1 0 ···  
 ··· ··· ··· ··· ··· ··· · · ·  on linéarise alors les fonctions localement :
 
0 0 ··· 0 an−1n−2 an−1n−1 an−1n
0 0 ··· 0 0 ann−1 ann fj (x1 , . . . , xi , . . . , xn )
Dans ce cas, il n’est nul besoin de stocker toute la matrice =
A avec ses n2 éléments puisque, pour la plupart, ils sont (0) (0)
nuls. On écrit plutôt fj (x1 , . . . , xi , . . . , x(0)
n )+

  ∂fj ∂fj ∂fj

d1 f1 0 0 0 ··· 0 dx1 + . . . + dxi + . . . + dxn
0 0 0
∂x1 ∂xi ∂xn
 e2 d2 f2 ··· 
 0 e3 d3 f3 0 0  (0)
 ···  où dxi = xi − xi . On cherche le point {xi } tel que
 ··· ··· ··· ··· ··· ··· ··· 
A=



fj (x1 , . . . , xi , . . . , xn ) = 0, ∀j, donc les équations ci-
 ··· 0 ei di fi 0 ···  dessus se reécrivent :
 ··· ··· ··· ··· ··· ··· ··· 
 
0 0 ··· 0 en−1 dn−1 fn−1 ∂fj ∂fj ∂fj
0 0 ··· 0 0 en dn dx1 + . . . + dxi + . . . + dxn
∂x1 ∂xi ∂xn
qui ne nécessite que trois tableaux de n éléments, d pour =
la diagonale, e pour la sous-diagonale et f pour la sur- 14. Le terme civilisé pour une fonction signifie en gros que l’algo-
diagonale. Noter que e1 et fn ne sont pas définis. rithme que l’on va utiliser marche. . .
Physique numérique, Philippe Depondt 59

(0) (0)
−fj (x1 , . . . , xi , . . . , x(0)
n ) ce qui se résout aisément en écrivant que le déterminant
du système est nul, etc. 15
C’est un système d’équations linéaires dont les inconnues
Cependant, on peut reécrire le problème matricielle-
sont les {dxi } :
ment :
J · dx(1) = −f (0)
D · a = ω2 a
avec des notations sans surprise. La matrice J des dérivées
∂fj avec évidemment :
partielles, Jij = , s’appelle la matrice jacobienne.    
∂xi g C C
On résout donc le système, ce qui permet de calculer les + −  
 ℓ1 m1 ℓ 1 m1 ℓ 1  a1
(1)
{xi } puis on recommence jusqu’à convergence, comme D=    
 , a =
C g C a2
dans le cas à une dimension. − +
m2 ℓ 2 ℓ2 m2 ℓ 2

4.5.4 Problèmes de vecteurs propres et de La matrice D s’appelle la matrice

2
dynamique du système
valeurs propres ou eigenproblems. et l’on s’aperçoit donc que ω est une valeur propre de
la matrice dynamique et que a en est un vecteur propre.
Il s’agit de résoudre l’équation : Pour un système 2 × 2 comme celui-ci, l’intérêt d’une telle
remarque n’est pas évident, mais pour un système 100 ×
A · x = λx 100 ? Par exemple, une molécule qui comporte ne serait-
où connaissant A, on en cherche les valeurs propres λ et ce que quelques dizaines d’atomes. . . il suffit alors d’écrire
les vecteurs propres x. la matrice dynamique du système, une matrice n × n où
n est le nombre de degrés de liberté du système, et d’en
chercher valeurs et vecteurs propres.
4.5.4.1 Un exemple : les modes propres d’un
Il se trouve qu’il y a des algorithmes très efficaces pour
ensemble d’oscillateurs harmoniques
calculer numériquement les valeurs propres et les vecteurs
couplés.
propres de très grosses matrices.
Prenons un cas très simple : deux pendules simples Ici encore, la façon de procéder dépend du type de ma-
couplés par un fil de torsion. L’énergie potentielle du trice que l’on veut étudier, et ici encore, il faut faire appel
système s’écrit : à des programmes de bibliothèque.
1
V = −m1 g cos θ1 − m2 g cos θ2 + C(θ1 − θ2 )2 4.5.4.2 Matrices tridiagonales symétriques : la
2
méthode QL.
avec des notations évidentes. Les équations du mouvement
La matrice dynamique du paragraphe 4.5.4.1
√ peut être
s’en déduisent sans difficulté :
 en remplaçant a1 par α1 = m1 ℓ1 a1 et a2
symétrisée √
 g C par α2 = m1 ℓ2 a2 . De plus, si le nombre de pendules

 θ̈1 = − ℓ sin θ1 − m ℓ (θ1 − θ2 )
1 1 1 est plus grand que deux, si les pendules sont alignés et

 g C chaque pendule n’interagit qu’avec ses deux voisins les plus
 θ̈2 = − sin θ2 − (θ2 − θ1 )
ℓ2 m2 ℓ 2 proches, la matrice D est tridiagonale symétrique. Il se
trouve que beaucoup de problèmes peuvent être ramenés
Puisque l’on s’intéresse ici à un problème linéaire, on peut au calcul des valeurs propres d’une matrice tridiagonale
se restreindre à des oscillations de petite amplitude, et symétrique qui est justement le cas le plus simple.
avec l’approximation habituelle, on obtient : La plupart des programmes de bibliothèque utilise la
 méthode QL qui consiste à faire une série de transforma-
 g C

 θ̈1 = − ℓ θ1 − m ℓ (θ1 − θ2 ) tions orthogonales :
1 1 1

 g C
 θ̈2 = − θ2 − (θ2 − θ1 ) As+1 = Ls · Qs
ℓ2 m2 ℓ 2
où Ls est une matrice triangulaire inférieure et Qs une
un système pour lequel on cherche des solutions station- matrice orthogonale, c’est-à-dire que :
naires périodiques du type :
t
iωt iωt
Q−1
s = Qs
θ 1 = a1 e , θ 2 = a2 e
Une série de théorèmes, que nous n’étudierons pas ici,
ce qui donne : montrent que l’on peut décomposer Ls de la façon suivante

 g C
 2
 ω a1 = a1 + (a1 − a2 ) Ls = Qts · As
ℓ1 m1 ℓ 1

 g C écrire Qs comme un produit de rotations planes et que la
 ω 2 a2 = a2 + (a2 − a1 )
ℓ2 m2 ℓ 2 séquence
As+1 = Qts · As · Qs
et :
   15. C’est d’ailleurs un exercice conseillé : le déterminant donne une
 g C 2 C équation bicarrée en ω, on trouve donc deux solutions positives et

 + − ω a1 − a2 = 0 donc deux fréquences propres ; à chaque fréquence propre correspond
ℓ1 m1 ℓ 1 m1 ℓ 1
  un couple (a1 , a2 ) d’amplitudes pour les deux pendules, c’est-à-dire

 C g C un mode propre. Le mouvement des pendules est une combinaison
 − a1 + + − ω 2 a2 = 0 linéaire de ces deux modes.
m2 ℓ 2 ℓ2 m2 ℓ 2
60 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

fera apparaı̂tre les valeurs propres sur la diagonale. l’on cherche également). Pour simplifier les notations, il
Pour l’utilisateur, il suffit de fournir deux tableaux uni- est d’usage d’écrire la même équation comme suit :
dimensionnels contenant la diagonale et la sous-diagonale
de la matrice initiale A ou A0 . Au retour, on obtient < ψ|H|ψ >
E=
les valeurs propres à la place de la diagonale en général < ψ|ψ >
classées par ordre de valeur décroissante. Si l’on veut aussi L’énergie E dépend évidemment de la fonction d’onde et
les vecteurs propres, il faut également fournir un tableau l’on montre que si l’on modifie légèrement ψ, E doit être
n×n et. . . bien lire la documentation pour déterminer si un minimum par rapport à ce changement, si toutefois E et
vecteur propre donné occupe une ligne ou une colonne de ψ sont solutions du problème.
la dite matrice ! En général, les vecteurs propres obtenus On développe alors la fonction d’onde sur une base de
sont normalisés à 1, soit, pour un vecteur propre ai donné : fonctions connues χℓ :
X X
a2i,ℓ = 1 ψ= cℓ χ ℓ
ℓ ℓ

où ai,ℓ est la ℓ-ième composante du vecteur propre ai . en espérant que la base choisie ≪ marchera ≫. Le principe
variationnel ci-dessus dit que le meilleur jeu de coefficients
4.5.4.3 Rendre une matrice tridiagonale. cℓ est celui pour lequel E est minimum, donc pour un δck
quelconque, le δE doit être nul au premier ordre. Avec ces
Quand la matrice n’a pas la forme requise, il faut la notations, l’équation (4.11) s’écrit :
transformer d’abord, par exemple, lorsque les pendules
X
couplés de notre exemple ≪ voient ≫ leurs seconds voisins, c∗ℓ cm Hℓm
ou bien lorsque l’objet étudié est une molécule en vibra-
tion dont les atomes sont couplés les uns aux autres en E = ℓmX (4.12)
c∗ℓ cℓ
trois dimensions.
ℓ
La méthode tourne toujours autour du même genre
d’opérations : on fait une séquence du type : où
Hℓm =< χℓ |H|χm >
As+1 = Rts · As · Rs
à condition toutefois que la base de fonctions soit or-
où Rs est une rotation plane judicieusement choisie et là thonormée, soit :
encore une batterie de théorèmes appropriés montre que
< χℓ |χm >= δℓm
l’on doit converger vers une matrice tridiagonale.
Si l’on impose une variation δck au coefficient ck dans
4.5.4.4 Problèmes aux valeurs propres généra- l’équation (4.12), on obtient alors :
lisés.
δE = !
Ce sont des problèmes du type : X X X
∗ ∗
δck cm Hkm + cℓ δck Hℓk c∗ℓ cℓ
A · x = λB · x (4.10) m X ℓ ℓ
− c∗ℓ cm Hℓm (δc∗k ck + c∗k δck )
où l’on cherche les valeurs propres λ et les vecteurs propres ℓm
x, A et B étant des matrices connues : voyons un exemple.
or δE doit être nul ∀k, ∀δck , ce qui donne, après avoir
ré-injecté l’équation (4.11) dans l’expression ci-dessus :
4.5.4.4.1 L’équation de Schrödinger. La résolu-
tion numérique de l’équation de Schrödinger est un X
cm Hkm = E ck ∀k
problème particulièrement difficile et, outre qu’un tome m
entier ne suffirait pas à le traiter complètement (voir,
par exemple, la référence [12]), c’est un domaine où autrement dit
la recherche est active ! Ici, nous nous contenterons de H·c=Ec
l’équation stationnaire et l’on tentera une résolution en avec des notations sans surprise. On reconnait là une
développant la fonction d’onde ψ sur une base de fonc- équation aux valeurs propres : la résoudre donne à la fois
tions connues : c’est, a priori, une approximation car rien les énergies propres et les coefficients correspondants du
ne dit que la ≪ vraie ≫ solution puisse être correctement développement de la fonction d’onde.
développée sur la base choisie, surtout si celle-ci est réduite Pour des raisons diverses, il peut arriver cependant que
à un nombre fini, voire un petit nombre, de fonctions. la base de fonctions utilisée ne soit pas orthonormée : par
La consultation d’un cours de physique quantique mon- exemple, si l’on cherche des fonctions d’onde électroniques
tre que l’on peut poser le problème de la façon suivante : dans le champ d’un ensemble de noyaux, on peut vouloir
R ∗ utiliser des fonctions d’onde localisées sur les noyaux
ψ (X)H(X)ψ(X)dX
E= R (4.11) atomiques avec un certain recouvrement. Les produits
ψ ∗ (X)ψ(X)dX scalaires :
< χℓ |χm >= sℓm
où H est le Hamiltonien (connu) du système considéré,
X désigne l’ensemble des variables du problème, ψ(X) deviennent alors les éléments d’une matrice S qui n’est
la fonction d’onde que l’on cherche et E l’énergie (que plus la matrice unité. Le problème se reformule légèrement
Physique numérique, Philippe Depondt 61

pour donner après le même genre de calcul, le résultat où p~i est le moment dipolaire porté par l’atome i et ~ri est
suivant : la position de celui-ci.
H·c=ES·c Chaque atome est donc soumis au champ extérieur E ~ ext
que l’on applique et au champ dû à tous les autres dipôles :
un problème aux valeurs propres généralisé similaire à
(4.10). X
~ ri ) = E
E(~ ~ ext + E~ dip (~ri )
j
j, j6=i
4.5.4.4.2 Résolution. La méthode est en général très
simple : il suffit de remplacer (4.10) par : ~ dip (~ri ) est le champ produit en ~ri par le dipôle porté
où E j
par l’atome j. Donc :
B−1 · A · x = λ x
 
La matrice B−1 · A n’est généralement pas symétrique X
p~i = α E~ ext + E~ dip (~ri ) (4.13)
j
même si A et B le sont. Les sous-programmes de bib-
j, j6=i
liothèque font alors une décomposition de B en
ainsi, pour calculer les valeurs des moments dipolaires p~i ,
B = L · Lt
il faut connaı̂tre les champs dipolaires mais pour obtenir
et le problème se re-écrit : les champs dipolaires, il faut connaı̂tre les moments dipo-


laires : on tourne en rond.
C · Lt · x = λ Lt · x On peut, certes, tenter de remplacer E ~ dip (~ri ) par son
j
expression en fonction de p~j et résoudre, par exemple, par
avec :
t la méthode de Newton le système d’équations :
C = L−1 · A · L−1
p~i − f~i ({~
pj , j ∈ [1, n]}) = 0 i ∈ [1, n]
La matrice C a les mêmes valeurs propres que le problème
initial et ses vecteurs propres sont Lt · x. En principe, cela suppose cependant de calculer toutes les dérivées
toutes ces transformations sont transparentes pour l’util-
isateur. ∂ f~i
∂~
pj
4.5.4.5 Conclusion
une entreprise parfois un peu laborieuse, surtout si n est
Tous ces algorithmes sont efficaces et rapides : il ne faut grand.
surtout pas se priver de les utiliser quand le problème [0]
On peut toutefois partir d’une solution d’essai p~i , cal-
s’y prête, même si l’on ne maı̂trise pas absolument leur
culer les champs dipolaires correspondants, puis, à l’aide
fonctionnement, car ils sont dans l’ensemble assez ro- [1]
bustes 16 . En revanche, les bibliothèques de programmes de l’équation (4.13), de nouvelles valeurs p~i , puis de nou-
[2]
sont souvent extrêmement riches et l’on a parfois du mal veaux champs et p~i et ainsi de suite. La solution sera
à déterminer quel est le sous-programme qui répondra le obtenue quand on aura atteint un ≪ point fixe ≫ tel que :
mieux à la question posée : il faut prendre le temps de [k+1] [k]
réfléchir, de lire la documentation disponible, hélas pas p~i ≃ p~i
toujours limpide, voire se poser la question si une refor-
avec une précision suffisante.
mulation du problème de façon légèrement différente ne
permettrait pas, par exemple, de symétriser la matrice
étudiée ou si une écriture avec des termes complexes ne 4.6.2 Formulation générale.
pourrait pas simplifier considérablement la vie de celui qui
On cherche donc la solution du système d’équations :
écrit le programme !
xi = fi (x1 , x2 , . . . , xn ), i ∈ [1, n]
4.6 Problèmes autocohérents. ou
x = f (x)
ou self-consistent problems en anglais.
où les lettres en caractères gras représentent des vecteurs
4.6.1 Qu’est-ce donc ? de n éléments. On part d’une solution d’essai x[0] et l’on
construit la séquence :
Imaginons, par exemple, un diélectrique constitué d’un
ensemble d’atomes polarisables qui, lorsqu’ils sont soumis x[k+1] = f (x[k] )
à un champ électrique, voient leur nuage électronique
déformé. Ils portent alors un moment dipolaire dont on Le point fixe sera considéré comme atteint quand les
supposera ici selon l’approximation d’usage qu’il est pro- x[k] n’évolueront plus de façon significative à chaque
portionnel au champ : génération.

~ ri )
p~i = α E(~ 4.6.3 Est-ce que ça converge ?
16. ce qui ne dispense pas bien sûr de vérifier sur des problèmes
dont la solution est connue que les programmes marchent conven-
Rien n’est moins sûr ! Prenons un cas très simple pour
ablement, et, comme d’habitude, ne pas oublier d’user de l’esprit lequel n = 1 et :
critique du physicien. . . f (x) = ax
62 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

La solution est évidemment x = 0. Si l’on veut résoudre Pour que cela converge, on montre 17 qu’il suffit que :
ce problème par la méthode ci-dessus, on part d’un x[0]
choisi arbitrairement et ||A|| < 1
x[1] = a x[0] , x[2] = a x[1] = a2 x[0]
où ||A|| est l’une des normes de A :
et bien sûr :
n
X
x[k] = ak x[0]
||A||m = max |aij |
Si |a| < 1, la convergence est acquise, mais sinon ça di- i
j=1
verge !
Étudions maintenant le cas : ou bien
n
X
f (x) = tanh x ||A||l = max |aij |
j
là encore la solution x = 0 est connue. Le programme pour i=1

résoudre celà est d’une grande simplicité : ou encore

v
uX
program autoco n
u n X
implicit none ||A||k = t |aij |2
real :: x=1. ! point de depart de la recherche i=1 j=1
integer :: k, kmax=100000
open(1,file=’autoco.res’) En particulier, si l’on a :
write(1,*) 0, x
do k = 1, kmax 1
x = tanh(x) aij < , ∀ i, j ∈ [1, n]
n
if( mod(k, 10) == 0 ) write(1,*) k, x
enddo la suite converge.
close(1) Pour un système non-linéaire, la matrice A devient la
end matrice jacobienne J à proximité du point fixe : cela sup-
1
pose que l’on soit capable d’évaluer cette matrice au point
fixe qui est justement ce que l’on cherche !
Afin de tempérer cette note apparemment pessimiste,
l’on mentionnera -et le lecteur est chaleureusement in-
0.1
vité à le vérifier- que le problème du diélectrique con-
verge de façon très satisfaisante en moins de 10 pas de cal-
x

cul à la suite d’un effort de programmation modeste. Ces

0.01 méthodes peuvent ainsi se révéler extrêmement précieuses
dans bien des cas, même si l’évaluation a priori de leurs
chances de succès relève parfois plus de l’astrologie que de
0.001
10 100 1000 10000 100000
la science. . .
k

Figure 4.16 – Convergence plus que médiocre de la

recherche autocohérente de la solution de l’équation x =
tanh x (les échelles sont logarithmiques).
Le résultat est malheureusement assez décevant (figure
4.16) : après 105 pas, on en est encore à quelques millièmes
de la solution ! On était habitué à mieux. . . Si l’on essaie
d’appliquer le critère ci-dessus, on s’aperçoit que la dérivée
de notre fonction tend vers 1 lorsque x tend vers zéro :
on est à la limite de la condition de convergence |a| < 1,
ainsi, dans ce cas, plus on s’approche de la solution, plus la
convergence devient difficile. On en concluera néanmoins
que le critère ci-dessus, a priori valable pour une fonction
linéaire, l’est également pour une fonction non-linéaire à
condition d’en connaı̂tre la dérivée au point fixe, ou du
moins d’être capable d’estimer si elle est, en valeur ab-
solue, inférieure à 1
Ce genre de raisonnement est généralisable à des
systèmes linéaires du type :
x = Ax + b
On obtient évidemment que :


x[k] = Ak x[0] + I + A + A2 + . . . + Ak−1 b
4.7 Recherche des minima d’une
fonction.
Il arrive bien souvent que l’on ait besoin, par exem-
ple, du minimum de l’énergie potentielle d’un système
qui dépend d’une ou plusieurs variables pour en obtenir
l’équilibre stable : mettons, un ensemble d’atomes qui
composent une molécule dont on veut la conformation à
l’équilibre compte tenu des potentiels d’interaction atome-
atome.
Un autre exemple, qui sera étudié plus en détail dans le
chapitre 4.8, est celui de la recherche du minimum d’écart
possible entre des données expérimentales et les prévisions
d’un modèle théorique qui dépend lui-même d’un certain
nombre de paramètres : il faut donc chercher les valeurs
de ces paramètres qui donne l’écart le plus faible possible.
On pourrait aussi, dans un autre ordre d’idées, chercher
le chemin optique le plus court pour un rayon lumineux,
encore que la résolution d’une équation différentielle or-
dinaire selon les méthodes du chapitre 4.9 paraisse plus
facile dans un bon nombre de cas.
17. Voir par exemple la référence [2], p. 322.
Physique numérique, Philippe Depondt
4.7.1 Du mouvement des amibes (mé- résoudre en δxi en suivant la méthode de Newton déjà
thode du simplex). vue :
4.7.1.1 À une dimension
On cherche donc le minimum d’une fonction f (x). On
pourrait imaginer quelques chose qui s’apparente à la
méthode de la dichotomie : on choisit un intervalle, on
prend le milieu, on regarde s’il est plus bas que les bords,
etc. En fait, il suffit, dans un espace unidimensionnel, de
prendre deux points : a et b. Mettons que f (a) < f (b),
alors on cherchera un point c symétrique de b par rap-
port à a : on va dans le sens où ça décroı̂t et cela s’ap-
pelle une réflexion. Si f (c) < f (a) c’est sans doute qu’on
pouvait aller plus loin : on double alors le déplacement
dans le même sens (dilatation) ; sinon, c’est qu’on est allé
trop loin, alors on divise le déplacement par deux (con-
traction). Puis on recommence l’opération jusqu’à ce que
l’intervalle entre les deux derniers points soit plus petit
que la précision voulue.
4.7.1.2 À N dimensions.
Le principe est le même : si l’on est dans un espace à N
dimension, on part de N + 1 points de l’espace : la figure
obtenue s’appelle un simplex, par exemple, si N = 2, c’est
un triangle. On remplace alors le point du simplex qui
donne la valeur la plus élevée de la fonction par un autre
obtenu en faisant une réflexion par rapport au centre de
gravité du simplex, puis des dilatations ou des contractions
à la demande. Ainsi, le simplex se déplace en se déformant,
telle une amibe, en cherchant toujours à se concentrer sur
point le plus bas. Quand il devient assez petit, le problème
est résolu.
La méthode du simplex a le mérite de ne nécessiter au-
cun calcul de dérivée et d’être simple à mettre en œuvre.
Autant dire, cependant, qu’elle est assez inefficace : elle est
à réserver aux problèmes pas trop lourds numériquement
pour lesquels on n’a pas de raison de faire d’effort partic-
ulier.
4.7.2 Méthode de Newton
Il y a une méthode évidente : puisque l’on peut chercher
les zéros d’un ensemble de fonctions par la méthode de
Newton, il suffit, lorsqu’on cherche les minima d’une fonc-
tion, de chercher les zéros de ses dérivées. Soit donc f (x)
une fonction d’un ensemble de n variables désignées par
x = (x1 , . . . , xn ). Un extremum est donné par :
∂f
di (x) = =0 ∀i
∂xi
cela donne un système de n équations dont on cherche les
zéros, or la variation δdi (x) de di pour des variations δxi
s’écrit :
X ∂di X ∂2f
δdi (x) = δxj = δxj (4.14)
j
∂xj j
∂xi ∂xj
La matrice H telle que
∂2f
Hij =
∂xi ∂xj
s’appelle la matrice Hessienne. C’est cette matrice qui
intervient dans le système linéaire (4.14) que l’on doit
63
H · δx = −d
avec des notations évidentes. Le vecteur d donne les vari-
ations qu’il faudrait imposer aux variables x (ou xi ∀i)
pour annuler l’écart dans l’approximation linéaire. Comme
la fonction f (x) n’est pas a priori linéaire, il faut recom-
mencer l’opération jusqu’à convergence.
C’est souvent efficace et c’est extrêmement simple à
mettre en œuvre (à condition de pouvoir calculer les
dérivées secondes qui composent la matrice hessienne),
mais il faut être conscient qu’on ne se donne, alors, pas
tous les moyens pour réussir. En effet, la méthode de
Newton recherche les zéros d’un ensemble de fonctions
complètement indépendantes, alors que les dérivées d’une
fonction ne le sont pas. En outre, la matrice Hessienne
n’est pas toujours disponible aisément.
4.7.3 Recherche à une dimension : inter-
polation parabolique.
Admettons que l’on connaisse trois points x = a, b et c
avec a < c < b d’une part, et f (c) < f (a) et f (c) < f (b)
de l’autre. La deuxième condition impose qu’il doit y avoir
un minimum au moins dans l’intervalle [a, b].
f(b)
f(a)
f(c)
a c x b
Figure 4.17 – Recherche de minimum parabolique à une
dimension.
On assimile alors localement la fonction à une parabole
passant par les trois points (figure 4.17) :
(x − c)(x − b)
f (x) ∼ p(x) = f (a) +
(a − c)(a − b)
(x − a)(x − c) (x − a)(x − b)
f (b) + f (c)
(b − a)(b − c) (c − a)(c − b)
dont on cherche le minimum :
p′ (x) = 0
soit :
1 f (a)(c2 − b2 ) + f (b)(a2 − c2 ) + f (c)(b2 − a2 )
x=
2 f (a)(c − b) + f (b)(a − c) + f (c)(b − a)
64 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

puis on recommence avec une procédure similaire à celle Mettons que l’on démarre la recherche d’un point x0
de la dichotomie : si x ∈]a, c[ on prend les points a, x avec une direction de recherche r0 , l’on écrira donc :
et c, sinon, on prend c, x et b et l’on calcule par la
même méthode une nouvelle estimation x′ et ainsi de suite x 1 = x 0 + α 0 r0
jusqu’à obtenir la précision voulue. Il reste cependant la
il faut chercher α0 tel que f soit minimum sur la direction
question de savoir si le minimum de la parabole est bien
r0 , or en développant (4.17) et en écrivant la dérivée par
un minimum et non un maximum ! On peut vérifier si par
rapport à α0 , on doit chercher α0 tel que :
exemple, f (x) est bien inférieur à f (c) ; s’il ne l’est pas on
peut prendre par exemple le point milieu de c et de x. α 0 r0 · H · r0 + x 0 · H · r0 + g · r0 = 0

4.7.4 Méthode du gradient conjugué. où l’on a tenu compte du fait que H est une matrice
symétrique 18 , ce qui donne une expression de α0 :
Soit de nouveau une fonction f (x) où x est un vecteur
dans un espace de dimension quelconque n. On cherche le r0 · r0
α0 = −
minimum de cette fonction. r0 · H · r0
Une première idée qui pourrait venir à l’esprit serait de Si l’on répète la même séquence, la nouvelle direction de
suivre la ligne de plus grande pente (steepest descent) : on recherche r1 doit être orthogonale à r0 parce que justement
suit une droite parallèle au gradient local de la fonction : nous sommes déjà sur un minimum de la fonction dans la
~
grad(f ) direction r0 , donc :
δx = −α (4.15)
~
kgrad(f )k r1 · r0 = 0
où α est un scalaire obtenu par exemple par la méthode ce que l’on vérifie facilement par le calcul.
du paragraphe 4.7.3. À deux dimensions, l’on obtient donc les zizags de la
figure 4.18 et avec un plus grand nombre de dimensions,
ça doit être, a priori, pire. . . On remarque cependant que
si les courbes de niveaux de la figure 4.18 avaient été des
cercles, la convergence aurait été obtenue en un pas, à
condition de choisir une direction de recherche parallèle
au gradient !
Il serait donc habile de tenter de faire entrer en ligne
de compte la géométrie des courbes de niveaux et d’intro-
Figure 4.18 – La ≪ ligne de plus grande pente ≫ dans duire non pas le produit scalaire ordinaire x · y, qui est
une vallée étroite. Il faut un grand nombre de pas pour bien adapté à une symétrie sphérique, mais le H-produit
atteindre le fond de la vallée. scalaire adapté à la géométrie de H :

Il se trouve que c’est souvent assez peu efficace même x·H·y

si cela peut donner de bons résultats dans certains cas :
en effet, si l’on cherche un minimum au fond d’une vallée Sans entrer dans les démonstrations 19 ni dans le détail
étroite et si l’on part d’un bord de la vallée, on va partir de l’algorithme, il suffit alors de chercher une série de di-
dans une série de zigzags plutôt inutiles (figure 4.18). rections de recherches di qui soient H-orthogonales entre
Pour trouver une meilleure solution, il faut étudier d’un elles de telle façon que :
peu plus près la méthode de la plus grande pente : il s’agit
xi+1 = xi + αi di
en fait d’une approximation de f par une fonction quadra-
tique : en choisissant αi pour que la recherche donne un minimum
sur la direction di , et
1X ∂2f X ∂f
f (x) ∼ xi xj + xi + f0 (4.16) di · H · dj = 0, ∀i 6= j
2 i,j ∂xi ∂xj i
∂xi
Il se trouve que contrairement aux apparences, on peut
où l’on peut introduire la matrice Hessienne H et le gra- très bien se passer de la connaissance (et de l’espace
dient g de f tel que mémoire correspondant) de la matrice Hessienne en util-
∂f isant le fait que les résidus ri doivent être justement les
gi = gradients de f !
∂xi
Moralité : une fois encore, ne pas chercher à réinventer
L’équation (4.16) se reécrit en notations matricielles : ce qui existe déjà, utiliser des sous-programmes de bib-
1 liothèque ! Ce qu’il faut retenir de ces méthodes, c’est
f (x) ∼ x · H · x + g · x + f0 (4.17) qu’elles sont proches de la méthode de Newton déjà
2
étudiée pour la recherche de zéros et qu’elles ont les
et
2 2
f ′ (x) ∼ H · x + g = r 18. Parce que Hi,j = ∂x∂ ∂x
i
f
j
= ∂x∂ ∂x
j
f
i
= Hj,i , donc on se conva-
inc aisément que x0 · H · r0 = r0 · H · x0 .
où r est le résidu qui devrait être nul si l’on était au point 19. Volontiers confuses dans la littérature, en tous cas guère pas-
x solution. C’est aussi le vecteur qui indique la direction sionnantes. . . mais ce n’est qu’une opinion qu’il n’est pas obligatoire
de plus grande pente, direction de recherche. de partager ! On se reportera éventuellement à la référence [7].
Physique numérique, Philippe Depondt 65

mêmes défauts. Ainsi, il s’agit toujours d’une recherche Choisissons alors, par exemple, λ pour que :
locale d’un minimum d’une fonction assimilée à une fonc- ∂f ∂g
tion quadratique qui ne possède qu’un seul minimum. La +λ =0
≪ vraie ≫ fonction n’est en général pas quadratique et si
∂xn ∂xn
elle possède plusieurs minima, on en trouvera au mieux alors les n − 1 variables x1 , . . . , xn−1 sont indépendantes.
un, sans savoir s’il n’y en a pas un nettement plus profond La relation (4.19) est donc vraie pour tout jeu de variables
juste à côté ! La méfiance et la circonspection sont les deux x1 , . . . , xn−1 , en particulier, si
mamelles du calcul numérique. . . dxi = 0, ∀i 6= k
On verra toutefois, dans le chapitre 4.11, des façons
d’éviter ces défauts lorsque le paysage du potentiel est ce qui donne puisque dxk 6= 0 :
compliqué et que le nombre de paramètres est élevé. ∂f ∂g
+λ =0
∂xk ∂xk
4.7.5 Minimisation avec contrainte : les une relation vraie pour tout k, puisqu’il a été choisi arbi-
multiplicateurs de Lagrange. trairement. C’est aussi vrai pour k = n puisqu’on a choisi
Imaginons que l’on doive chercher comme auparavent λ ainsi : on retrouve ainsi la symétrie un instant perdue. . .
un minimum d’une fonction de n variables : Le résultat de tout ceci est que si l’on définit la fonction :
Q = f (x) + λg(x)
min(f (x))
le problème revient à chercher le minimum de Q avec
mais que les variables représentées par x ne soient pas la contrainte (4.18), mais ce qui est nouveau par rap-
indépendantes mais reliées par une relation : port au problème précédent, c’est que les n variables sont
indépendantes et que l’on peut utiliser les méthodes clas-
g(x) = 0 (4.18) siques.
Prenons, par exemple, un système de pendules couplés
c’est ce que l’on appelle une contrainte. Imaginons par dont l’énergie potentielle s’écrit :
exemple que l’on cherche la configuration d’équilibre d’un X 1 X 2
ensemble d’atomes mais que deux atomes donnés soient V =− mi gℓi cos θi + Cij (θi − θj )
liés par une liaison très rigide, covalente par exemple, et i
2 i,j>i
que la distance entre ces deux atomes soit connue. On a
avec des notations standards. Admettons que l’on cherche
ainsi un système de n − 1 variables indépendantes et l’on
l’équilibre d’un tel système (en dehors évidemment de la
pourrait reécrire l’équation (4.18) :
solution triviale : certains angles peuvent être supérieurs
xn = g̃(x1 , . . . , xn−1 ) à π) avec la contrainte que la somme des angles soit nulle
(mettons qu’un système d’engrenages plus ou moins com-
et l’on rechercherait le minimum d’une fonction à n − 1 plexe impose cela) :
variables : X
θi = 0
i
min(f (x1 , . . . , xn−1 , g̃(x1 , . . . , xn−1 )))
L’on écrira donc :
Outre le fait que la recherche de la fonction g̃ n’est pas X
toujours facile, cette méthode est discutable en ce sens que Q=V +λ θi
i
l’on a choisi d’éliminer la variable xn , mais pourquoi pas
plutôt xn−1 ou xi ? Dans certains cas le choix est évident, et en exprimant les dérivées :
dans d’autres non. ∂Q
Si l’on est à un extremum de f , alors pour tout ensemble =0
∂xk
de variations infinitésimales des xi on doit avoir :
on obtient :
Xn
∂f X
dxi = 0 λ = −mk gℓk sin θk − Ckk′ (θk − θk′ ), ∀k
i=1
∂x i k′ 6=k

or les dxi ne sont pas indépendants à cause de l’équation soit en sommant :

 
(4.18) ; mais cette équation dit que g est une constante et 1 X X
que donc sa différentielle doit être nulle : λ=− mk gℓk sin θk − Ckk′ (θk − θk′ )
n
k ′ k 6=k
Xn
∂g
dxi = 0 que l’on peut réinjecter dans l’expression de Q pour
i=1
∂xi faire ensuite une minimisation par l’une des méthodes
habituelles.
ce qui introduit un lien entre les dxi . Il suffit d’addition- Tout ceci se généralise évidemment à un nombre quel-
ner ces deux relations en multipliant la deuxième par un conque de contraintes gℓ = 0, il suffit d’introduire autant
≪ multiplicateur de Lagrange ≫ λ :
de multiplicateurs de Lagrange que de contraintes :
n   X
X ∂f ∂g Q=f+ λℓ g ℓ
+λ dxi = 0 (4.19)
i=1
∂xi ∂xi ℓ
66 Licence de physique L3 : PHYTEM,
4.8 Modélisation de données
expérimentales.
Lorsqu’on fait des expériences, il est bien rare que
l’on n’utilise pas un logiciel d’acquisition et de traite-
ment des données expérimentales. Ces logiciels proposent
généralement des options intitulées par exemple smooth-
ing 20 ou curve fitting 21 ou least square fit 22 . L’objectif de
ce chapitre est d’expliquer ce que font au juste ces options,
comment ça marche, et quelles sont leurs limites. En effet,
il ne s’agit pas de magie, contrairement parfois à ce qu’il
paraı̂t, mais de bons vieux algorithmes bien pédestres,
faciles à comprendre et dont il vaut mieux connaı̂tre les
hypothèses sous-jacentes et les petites manies, faute de
quoi on a vite fait de faire dire à peu près n’importe quoi
aux résultats d’expérience !
4.8.1 Données et moindres carrés.
4.8.1.1 Quel est le problème ?
Lorsqu’on fait une expérience, on mesure une grandeur
y en fonction d’une autre grandeur x, par exemple la pres- des écarts, par exemple la somme des valeurs absolues ou
sion en fonction de la température p(T ), l’intensité lu- le sup des carrés. . . Le choix fait ici, ainsi que dans la
mineuse en fonction de sa fréquence ou de sa pulsation quasi-totalité des programmes, repose sur une hypothèse
I(ω), la position d’un objet en fonction du temps r(t). . . qu’il faut expliciter.
On peut aussi bâtir une théorie qui prédise la loi y = f (x)
et l’on veut savoir si la théorie est juste : cette théorie re-
pose sur des hypothèses physiques qui sont ainsi validées
ou non. C’est ce qu’on appelle la modélisation, on fait en-
trer une expérience dans le cadre d’un modèle.
En général, la loi issue de la théorie dépend aussi
de paramètres dits ≪ ajustables ≫. Par exemple, on
peut imaginer que si l’on mesure une pression de vapeur
saturante, la pression puisse s’écrire en fonction de la
température de la façon suivante :
∆E
P (T ) = P0 e− kT
une loi d’Arrhenius où ∆E est l’énergie qu’il faut fournir
pour arracher un atome à la surface de l’échantillon.
Ainsi, cette théorie, si elle est juste, donne potentiellement
également une information de type microscopique sur
l’échantillon étudié : on aimerait bien savoir évidemment
quelle est la valeur de ∆E qui est la plus en accord avec
les résultats expérimentaux : ∆E (ainsi que P0 ) est donc
un paramètre ajustable de la théorie parce qu’on n’en con-
nait pas la valeur a priori et l’on tentera donc d’ajuster
∆E aux données expérimentales.
Ainsi, il est important de comprendre que l’on est en
train de poser, non pas une, mais deux questions dis-
tinctes :
1. est-ce la théorie marche ?
2. quelles sont les valeurs (et les incertitudes) des
paramètres ajustables ?
Il se trouve que les logiciels courants répondent pra-
tiquement toujours à la seconde question, mais pas à la
première : cela vaut donc la peine de regarder d’un peu
plus près comment ça marche !
20. Lissage.
21. Ajustement de courbe.
22. Ajustement de moindre carré.
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
4.8.1.2 L’hypothèse de départ.
En pratique, l’on relève, pour n points de mesures
{xi , i = 1, n}, les n valeurs {yi , i = 1, n} correspon-
dantes. Mettons que l’on ait une théorie qui donne y en
fonction de x et d’un certain nombre de paramètres ajusta-
bles p1 , . . . , pm :
y = f (x, p1 , . . . , pm ) = f (x, {pj })
Ce qui nous intéresse, ce sont les écarts entre les yi mesurés
et les f (xi , {pj }) calculés à l’aide de la théorie. On définit
ainsi :
n
X
χ2 ({pj }) = (f (xi , {pj }) − yi )
2
i=1
On cherchera alors l’ensemble de paramètres {pj } qui
rendra χ2 le plus petit possible : c’est pour cela que
la méthode s’appelle ≪ méthode de moindres carrés ≫,
puisque χ2 est la somme des carrés des écarts entre théorie
et mesures.
On aurait pu choisir autre chose que la somme des carrés
Imaginons que l’on fasse un grand nombre de fois la
mesure de y pour une même valeur de x : on ne trouvera
pas la même valeur de y pour toutes les mesures mais
une distribution parce que la mesure n’est pas parfaite, il
y a des incertitudes, il y a des vibrations dans le sol, le
détecteur utilisé produit du bruit, l’électronique produit
également du bruit. . .
L’hypothèse qui mène à l’expression de χ2 ci-dessus est
que cette distribution est gaussienne, centrée autour de y0
avec un écart-type σ :
(y−y0 )2
p(y) = e− 2σ 2
à un coefficient de normalisation près 23 . Il se trouve que
pour un très grand nombre d’expériences, le théorème de la
limite centrale (valable pour les grands nombres) impose
que cette condition soit vérifiée. Toutefois, il faut faire
attention que des détecteurs très sensibles peuvent être
capables de répondre à un nombre de ≪ coups ≫ très faible
pour lequel ce genre de théorème n’est plus valable. Les
méthodes décrites ici ne sont alors plus en toute rigueur
directement utilisables.
4.8.2 Ajustement d’une fonction linéaire.
4.8.2.1 Sans les incertitudes.
Prenons pour commencer le cas le plus simple : y =
ax + b où les deux paramètres ajustables sont a et b. On
cherche donc a et b tels que
n
X
χ2 = (axi + b − yi )
2
i=1
23. √1 .
σ 2π
Physique numérique, Philippe Depondt 67

soit minimum. Il faut donc que les dérivées de χ2 par rap- c’est l’écart entre théorie et expérience pour le point i. Si
port aux deux paramètres soient nulles : l’on estime que cet écart est entièrement dû au paramètre
 n
n˚1, on obtient

 ∂χ2 X

 = 2xi (axi + b − yi ) = 0
 ∂a ∂ei ∂f (xi , {pj })
i=1 ei = δp1 = δp1
 Xn ∂p1 ∂p1

 ∂χ2

 ∂b = 2 (axi + b − yi ) = 0
i=1 une majoration de l’incertitude δp1 sur le premier
paramètre, or
Quelques lignes de calculs sans difficulté donnent :
 n
X n 
X 2
X n Xn Xn ∂f (xi , {pj }

 χ2 = e2i = )δp1

 n x y
i i − x i yi ∂p1

 i=1 i=1

 i=1 i=1 i=1

 a = !2

 X n Xn et en généralisant ceci à tous les paramètres pj :

 2

 n xi − xi
v
i=1 i=1 u
n
X Xn Xn Xn u χ2

 δpj = u n


 x2i yi − x i yi xi u X ∂f (xi , {pj })

 t

 b = i=1 i=1 i=1
!2i=1
∂pj

 Xn X n i=1



 n 2
xi − xi
 C’est ce que l’on appelle ≪ déviations standards es-
i=1 i=1
timées ≫ (estimated standard deviations ou esd ) et ce
Lire dans un fichier les n valeurs de x et de y et faire ce sont des estimations de majorants aux incertitudes sur les
calcul pour obtenir l’équation de la droite est extrêmement paramètres.
simple (c’est d’ailleurs un petit exercice de programmation Dans le cas d’une fonction linéaire, évidemment, ces for-
conseillé 24 ) : on comprend que les éditeurs de logiciels ne mules se simplifient aisément, mais elles s’appliquent 25
se privent pas de l’inclure dans leurs productions. aux autres cas aussi.

4.8.2.2 Avec les incertitudes.

4.8.2.3 Exercice pratique et divertissant.
Il y a une faiblesse criante dans ce que nous avons fait
-Étape n˚1 : remplir une coupelle en plastique ou un pot
jusqu’à présent : on ne voit nulle part d’incertitude ! Ad-
de yaourt ou de petit suisse vide avec un peu d’eau.
mettons donc que chaque mesure (xi , yi ) soit affectée d’une
-Étape n˚2 : poser la coupelle ou le pot de yaourt sur un
incertitude σi . On doit alors redéfinir χ2 de façon qu’une
pèse-lettres et l’ensemble (précautionneusement) sur un
mesure ≪ compte ≫ d’autant plus que son incertitude est
radiateur.
petite :
-Étape n˚3 : pendant une semaine ou plus, relever plusieurs
n
X 2 fois par jour le temps écoulé depuis le début de l’expérience
(f (xi , {pj }) − yi )
χ2 ({pj }) = et la masse indiquée par le pèse-lettre. Mettre ces données
σi2
i=1 expérimentales dans un fichier.
Dans le cas de la fonction linéaire cela s’écrit évidemment : -Étape n˚4 : faire une hypothèse physique. Puisque la
n
température du radiateur peut être considérée en première
X (axi + b − yi )
2
approximation comme constante, la vitesse d’évaporation
χ2 =
i=1
σi2 de l’eau peut être considérée comme constante et donc
la masse d’eau restante s’exprimer comme une fonction
Un calcul à peine plus compliqué que précédemment donne linéaire du temps :
de la même façon les expressions de a et de b.
On peut alors introduire le ≪ facteur de confiance m(t) = ṁ t + m0
pondéré ≫ ou weighed reliability factor :
v où, donc, ṁ et m0 sont des constantes.
u
u χ2 -Étape n˚5 : déterminer ṁ et m0 selon les méthodes
Rw = u n
u X (f (xi , {pj }))2 ci-dessus, ainsi que les déviations standards. Tracer
t
les courbes expérimentale et théorique sur un même
σi2
i=1 graphe ainsi que les écarts entre courbe théorique et
expérimentale.
c’est un écart quadratique ramené à la moyenne des carrés
de la fonction. Il s’exprime en général en % : si Rw vaut par -Étape n˚6 : s’interroger sur les résultats obtenus.
exemple 10%, cela signifie en gros que la fonction théorique -Étape n˚7 : changer la valeur affichée sur le thermostat et
est éloignée de 10% des valeurs expérimentales, en unités recommencer l’expérience.
de σ. -Étape n˚8 : tracer la courbe ṁ(T ) pour 253 < T < 333K.
Ce que l’on aimerait avoir, c’est l’incertitude sur a et b
puisque ce sont les résultats de tous ces calculs. Posons : 4.8.2.4 Une généralisation possible.

ei = f (xi , {pj }) − yi Ces méthodes qui ont le grand mérite d’être simples et
faciles à programmer ne sont pas limitées strictement aux
24. Il est prudent de travailler en double précision à cause des
dénominateurs. 25. On n’ose parler de validité !
68 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

fonctions linéaires. Reprenons l’exemple de la loi d’Arrhe- 4.8.3 Ajustement d’un polynôme.
nius :
∆E On peut généraliser facilement les équations du para-
P = P0 e− kT
graphe 4.8.2.1 au cas d’un polynôme de degré p :
Si l’on fait les changements de variable : p
X
2 p
1 P (x) = c 0 + c 1 x + c 2 x + . . . + c p x = cj xj
y = ln P x = − j=0
kT
on obtient On cherche, bien sûr, les p + 1 coefficients cj , et donc,
y = ∆E x + ln P0  !2 
X p
k
où ∆E et ln P0 tiennent le rôle de a et b dans le problème  c k x i − yi 
∂χ 2
∂ X n 
précédent. Ainsi, si l’on peut exprimer le problème de la  k=0 
=  2 =0
façon suivante : ∂c j ∂c j  σ i 
 i=1 
g(y) = a h(x) + b
où g et h sont des fonctions connues sans paramètre
ajustable (ici, k est la constante de Boltzmann, connue), Il est aisé de se rendre compte que si l’on pose :
tout ce qui est ci-dessus est utilisable sans difficulté.  Xn

 xj+k
i

 Ajk = 2
i=1
σ i
4.8.2.5 Un caveat. n
X yi x j


 Bj =
 2
i

i=1
σ i

le problème se ramène à la résolution d’un système linéaire

(p + 1) × (p + 1) :
A·C=B
avec des notations évidentes. De plus :
v
u
u χ2
Rw = u n
u X P (xi )2
t
i=1
σ2

et : s
χ2
δck =
Akk
Les généralisations du type :

Figure 4.19 – L’ajustement d’une fonction linéaire à g(y) = P (h(x))

des données aléatoires donne un résultat. Ici : 0.79875 −
où g et h sont des fonctions connues sont évidemment
0.24841 × x. Quel sens donner à ces nombres ? Aucun !
possibles.
À condition de disposer d’un sous-programme de
Malheureusement, tout ceci est un peu trop beau. En résolution de systèmes linéaires, tout ceci est très simple à
effet il suffit de considérer les équations de ce chapitre programmer, ça marche très bien et c’est rapide car il n’y
pour constater que ces méthodes donneront toujours un a pas à converger plus ou moins laborieusement vers une
résultat, si absurde soit-il. La figure 4.19 montre l’ajuste- solution.
ment d’une droite sur un nuage de points aléatoires. Alors, s’agit-il du programme ≪ résout tout problème,
On obtient des nombres. marche à tout coup ≫ ? Poser la question est évidemment
Ces nombres n’ont, bien sûr, aucun sens. un début de réponse.
Moralité : ce n’est pas parce qu’un programme d’ajuste- Revenons au pot de yaourt du paragraphe 4.8.2.3.
ment donne un résultat que le modèle est validé et que les Il est probable que l’ajustement d’une fonction linéaire
paramètres qu’il donne sont bons. laissera des écarts entre cette fonction et les données
Il ne faut pas oublier d’être physicien : quand on ajuste expérimentales : faut-il alors prendre un polynôme de
un modèle, c’est qu’on pense qu’il est adapté, puis on degré plus élevé ? Il est clair que l’ajustement en sera
doit discuter les valeurs obtenues pour les paramètres meilleur : à la limite, si l’on prend un degré égal au nombre
en les considérant comme des grandeurs physiques et de points moins un, p = n − 1, on obtiendra un polynôme
en se posant par exemple la question des conséquences passant par tous les points expérimentaux ! Mais les coef-
qu’entraı̂nent les valeurs obtenues. Si, par exemple, dans ficients ainsi introduits ont-ils un sens physique ? Non !
le cas de la loi d’Arrhenius, on trouve ∆E ∼ 106 joules Il faut d’abord se poser des questions physiques. Par
(au lieu de quelques eV), on est en droit de se demander exemple, y a-t-il une raison pour laquelle le modèle choisi
si l’on a bien mesuré de la sorte l’énergie pour arracher ne conviendrait pas ? Comme le thermostat a un cycle de
un atome d’une surface comme on le pensait initialement. 24 heures car on chauffe moins la nuit, ne pourrait-on pas
Physique numérique, Philippe Depondt 69

plutôt introduire cette périodicité dans le problème ? On

pourrait tenter quelque chose comme

¯ + µ sin 2π t
ṁ = ṁ
τ
Évidemment, c’est plus difficile parce qu’il ne s’agit plus
d’un polynôme et il faudra recourir aux méthodes du para-
¯
graphe 4.8.6, mais c’est peut-être plus réaliste, puisque ṁ
devient alors la vitesse moyenne d’évaporation et µ l’am-
plitude des variations périodiques. On peut même aller un
peu plus loin en remarquant que ṁ est sans doute propor-
tionnel à la pression laquelle obéit probablement à une loi
d’Arrhenius en fonction de la température. . .

4.8.4 Dérivée locale d’une courbe

expérimentale. Figure 4.20 – Un cosinus bruité, sa dérivée calculée avec
On peut aussi prendre la question différemment : l’in- q = 3 et avec q = 10.
connue ≪ intéressante ≫ de l’expérience est la vitesse
d’évaporation ṁ : c’est cela que l’on cherche à mesurer.
On voudrait calculer la dérivée locale de la mesure et c’est
à cette grandeur là que l’on tentera d’appliquer quelque Lij = c2i δx2 j 2 + c1i δxj + c0i
théorie. mais seul la valeur en xi de l’ajustement local nous
Il suffit d’ajuster localement une fonction linéaire : intéresse :
f (x) = c x + c Li0 = c0i
1i 0i

à condition de rester proche de xi . Le χ2 devient local car on remplacera les xi par les valeurs lissées Li0 . À la
autour du point xi : suite de calculs sans difficulté, on obtient, toujours par les
mêmes méthodes :
+q
X 2 q
X
χ2i = (c1i xk+i + c0i − yi+k )
J 4 yi + (J4 − J2 k 2 )(yi+k + yi−k )
k=−q
k=1
Li0 = c0i = (4.20)
où q détermine la largeur de l’intervalle autour de xi où ce J0 J4 − J22
calcul est fait. Le coefficient c1i est donc la dérivée locale
recherchée : un calcul sans difficulté donne : où
q
X
3
+q
X Jℓ = jℓ
c1i = k yi+k j=−q
δx q(q + 1)(2q + 1)
k=−q
soit :
26 q(q + 1)(2q + 1)
dans le cas où xi = x0 + iδx . Évidemment, le résultat J0 = 2q + 1, J2 = ,
que l’on trouve dépend de q : si l’on choisit une valeur 3
de q petite, le résultat risque d’être sensible au bruit, en q(q + 1)(2q + 1)(3q 2 + 3q − 1)
revanche, si q est trop grand, on perdra les fluctuations J4 =
15
rapides (voir la figure 4.20). Il faut choisir autant que pos-
sible qδx < ∆x l’ordre de grandeur des variations que l’on (les Jℓ pour ℓ impair sont bien sûr tous nuls) et
cherche à détecter.
Exercice : essayer de calculer ṁ(t) à partir des données q(q + 1)(2q + 1)2 (4q 2 + 4q − 3)
J0 J4 − J22 =
de mesure. On constatera qu’il faut choisir un intervalle 45
de mesure sensiblement plus court que la durée des vari-
C’est encore extrêmement facile à programmer et rapide
ations quotidiennes de la température : l’idéal étant un
à l’exécution. Il faut cependant réaliser que 1˚ le résultat
enregistrement toutes les heures par exemple.
dépend de q et 2˚ il ne s’agit en fait que d’une moyenne
pondérée de points voisins. Il y a ici une hypothèse
4.8.5 Lissage : a dirty trick ! sous-jacente très importante : c’est que les variations
Il arrive que les informations intéressantes d’une intéressantes sont de longueur d’onde ou de dimension car-
expérience soient difficilement visibles sur la courbe actéristique grande par rapport aux fluctuations dues au
expérimentale obtenue à cause du bruit. La plupart des bruit et donc à l’intervalle balayé dans l’équation (4.20).
logiciels d’acquisition offrent des options de smoothing ou C’est pour cela qu’il vaut généralement mieux, sauf pour
lissage visant à réduire le bruit. Il s’agit d’ajuster locale- des raisons cosmétiques ne pas faire de lissage, et, au
≪ ≫

ment un polynôme comme précédemment, par exemple un contraire, ajuster une fonction physiquement justifiée aux
polynôme d’ordre 2 : résultats non lissés : si l’information intéressante est là et si
le modèle choisi est susceptible de la révéler, l’ajustement
P+q 2 q(q+1)(2q+1)
26. Il faut se rappeler au passage que −q
k = 3
. devrait la faire apparaı̂tre.
70 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

4.8.6 Ajustement non-linéaire. de se convaincre que le minimum trouvé est bien le

minimum de la fonction
Ce qui rend l’ajustement de polynômes si simple,
– le fait que d’avoir trouvé le minimum de χ2 ne valide
c’est que la dépendance d’un polynôme par rapport aux
en aucun cas le modèle utilisé.
paramètres, c’est-à-dire aux coefficients, est linéaire : ax2 +
bx + c est une fonction linéaire de a, b et c, même si ce Ces mises en garde ne doivent toutefois pas être vues
n’est pas une fonction linéaire de x. En revanche, on peut comme devant dissuader d’utiliser ces outils : il faut
vouloir chercher à ajuster une fonction comme : les utiliser, ils sont d’une grande puissance ! Parfois, un
ajustement difficile ou qui paraı̂t donner des résultats dou-
L0 teux est une indication qu’un autre modèle (pas forcément
L(x) =  2 plus compliqué, d’ailleurs) serait peut-être meilleur. Il faut
x − x0
1+ simplement se rappeler que l’ordinateur qui fait le calcul
γ
est un serviteur puissant mais. . . stupide ! Au physicien de
C’est une lorentzienne comme sur la figure 4.21 où, comme faire son métier et de garder un regard critique.
le montre une analyse élémentaire, L0 est la hauteur Il existe, au reste, de bonnes habitudes qui peuvent
de la courbe, x0 la position de son maximum et γ sa aider à éviter des mésaventures. La première est de tracer
demi-largeur à mi-hauteur. Il est facile de montrer que sur un même graphe la courbe théorique et les résultats
la lorentzienne est le module au carré de la transformée de expérimentaux pour voir si ça ressemble ! L’œil humain
t
Fourier de eiωt− τ et donc la réponse spectrale des oscilla- est un bon juge en la matière. On peut pousser un peu
tions amorties, ce qui en fait une courbe très répandue en plus loin en traçant la courbe des écarts entre fonction
spectroscopie, par exemple optique : la position du som- théorique et expérience : en principe, on ne devrait voir
met de la courbe donne la fréquence de l’oscillateur et sa que du bruit, c’est-à-dire un signal aléatoire, symétrique
largeur, l’amortissement. par rapport à l’axe des abscisses. Si des zones où les
écarts sont systématiquement positifs ou négatifs appa-
1 raissent, c’est peut être le signe qu’il y a là à chercher
0.9 davantage. On peut aussi refaire l’ajustement à partir de
0.8 jeux de paramètres initiaux différents : il vaudrait mieux
0.7
que le résultat final n’en dépende pas trop ! Si certains
paramètres se retrouvent affectés d’une déviation standard
0.6
estimée très élevée (par exemple d’un ordre de grandeur
0.5 comparable au paramètre lui-même), on se demander s’il
0.4 est vraiment utile de le garder : ne pourrait-on pas imag-
0.3 iner un modèle dont il est absent ? Si oui, est-ce que le
résultat obtenu est très différent du précédent ?
0.2
Voici un exemple authentique : il s’agissait d’une
0.1
expérience de diffusion Raman, c’est-à-dire de diffusion
0 inélastique de la lumière. On éclairait un échantillon avec
−5 0 5 10
de la lumière monochromatique de longueur d’onde connue
Figure 4.21 – Lorentzienne avec L0 = 1, γ = 0.5 et x0 = 5145Å, et on analysait la lumière diffusée par l’échantillon
2. à l’aide d’un ensemble de réseaux. Le résultat expérimental
était l’intensité lumineuse en fonction de la pulsation
Les paramètres que l’on veut ajuster sont L0 , x0 et γ, I(ω) et la courbe obtenue ressemblait à la figure 4.21
or L n’est linéaire ni en x0 ni en γ ; alors on linéarise le avec du bruit. On connaissait les propriétés du disposi-
problème en sachant que le résultat ne sera pas correct tif expérimental et la théorie disait que le résultat de-
mais en espérant qu’il sera moins mauvais que le point vait être le produit de convolution d’une lorentzienne
de départ et l’on répète l’opération jusqu’à ce qu’une so- par une ≪ fonction d’appareil ≫ qui reproduisait les car-
lution acceptable soit trouvée. Il s’agit donc, une fois de actéristiques du dispositif. L’ajustement donna, sans sur-
plus, de rechercher un minimum de χ2 en fonction de ses prise, hauteur, position et largeur de la lorentzienne. On
paramètres, seulement, il n’y a plus de solution simple, traça alors la courbe des écarts pour s’apercevoir qu’il
il faut utiliser une méthode du type Newton ou gradient y avait une bosse systématiquement positive au pied de
conjugué avec les précautions qu’imposent ces méthodes : cette lorentzienne. On tenta alors de reprendre l’ajuste-
ce n’est pas parce que cela fait partie d’un logiciel tout ment avec d’autres paramètres initiaux, et/ou en bloquant
fait que ces méthodes deviennent infaillibles, elles con- à des valeurs ≪ raisonnables ≫ l’un ou l’autre paramètre
servent les défauts déjà vus. Si le point de départ de la sans jamais réussir à réduire cette bosse. . . Finalement,
recherche, les paramètres initiaux, est trop éloigné d’une l’on décida d’introduire dans le modèle une deuxième
solution, le résultat obtenu risque d’être absurde, si le lorentzienne, toujours convoluée avec la fonction d’ap-
modèle comporte un trop grand nombre de paramètres pareil : le résultat devint excellent ! La lumière diffusée
ajustables (chaque paramètre ajoute une dimension à l’es- comportait donc deux pics à deux fréquences différentes
pace de recherche) la signification du résultat final risque et non un : le premier était celui que l’on voyait à l’œil
d’être assez discutable. . . nu, le deuxième, beaucoup plus faible en intensité, à une
Ainsi, lorsqu’on ajuste un modèle théorique à une fréquence légèrement supérieure, était caché dans le pied
expérience, on est donc confronté à deux types de diffi- du premier : l’analyse attentive du résultat de l’ajustement
cultés : avait seule permis de le détecter. Restait évidemment à ex-
– la recherche du minimum de χ2 , il est parfois difficile pliquer d’où il venait, ce deuxième pic. . . : il s’avéra qu’en
Physique numérique, Philippe Depondt 71

fait le premier pic était dû à des imperfections du dispositif Il suffit d’ajouter une deuxième lorentzienne :
expérimental et que l’information physique résidait dans f(x) = l1/(1+((x-x1)/g1)**2)+l2/(1+((x-x2)/g2)**2)
le deuxième. x1 = 940 ; x2 = 950 ; l = 1000
fit f(x) ’lorentz.out’ u 1:2:(1) via l1, l2, x1,
x2, g1, g2
Comme beaucoup d’autres programmes, le logiciel de tracé
de courbe gnuplot comporte une fonction fit qui permet de et l’on obtient :
2500
faire toutes sortes d’ajustements de fonctions à des données f(x)
’lo2’

sans avoir à écrire soi-même un programme. La syntaxe en

est assez simple, par exemple : 2000

fit a*x**2+b*x+c ’fichier’ via a,b,c

permet d’ajuster un polynôme du deuxième degré aux
valeurs contenues dans un fichier. Implicitement, la première 1500

colonne du fichier contient les valeurs de x, la deuxième

celles de y et la troisième celles des incertitudes sur y. Si
1000
ces dernières sont inconnues ou constantes, on peut taper :
fit a*x**2+b*x+c ’fichier’ using 1:2:(1) via a,b,c
ce qui fixe la valeur de cette incertitude uniformément à 1. 500

Le résultat de l’opération est la valeur de a, b et c.

On peut faire des choses plus sophistiquées :
f(x) = l/(1+((x-x0)/g)**2) 0
900 920 940 960 980 1000
x0 = 940 ; l = 1000
fit f(x) ’lorentz.out’ u 1:2:(1) via l, x0, g avec les valeurs :
On ajuste alors une lorentzienne à des valeurs contenues dans l1 = 2019.76 +/- 8.07 ; l2 = 112.795 +/- 6.978 ; x1
un fichier, en donnant des valeurs initiales à plusieurs vari- = 940.013 +/- 0.02164 ; x2 = 953.61 +/- 0.4528 ; g1
ables pour ≪ aider ≫ le programme. Pour tracer le résultat : = 4.96645 +/- 0.03408 ; g2 = 5.86099 +/- 0.7297
plot f(x), ’lorentz.out’ On peut même tracer les écarts entre la fonction théorique
ce qui donne la figure ci-dessous. et les données :
l = 2007.89 +/- 14.49; x0 = 940.12 +/- 0.03819 ; g = 5.26853 +/- 0.05383 plot "lorentz.out" using 1:($2-f($1))
2500
fonction 60
donnees

50
2000
40

30
1500
20

10
1000

-10
500

-20

0 -30
900 920 940 960 980 1000
-40
On observe une petite ≪ bosse ≫. . . qu’à cela ne tienne ! Voir 900 920 940 960 980 1000

la table 4.2.

Table 4.1 – Fit avec gnuplot Table 4.2 – Fit avec gnuplot (suite de la table 4.1).

Cette anecdote n’a rien d’exceptionnel : pratiquement 4.9.1 Un exemple : les lignes de champ.
tout expérimentateur en a d’autres du même style à racon-
Admettons que l’on puisse calculer en chaque point ~r le
ter, ce genre d’aventure fait partie du métier ! ~ r) dû à une distribution de charges et
champ électrique E(~
que l’on en veuille tracer les lignes de champ. Une ligne
de champ est définie par le fait qu’elle est en chaque point
parallèle au champ :
4.9 Systèmes d’équations diffé-
~ r)
d~s // E(~
rentielles ordinaires.
où le vecteur d~s est le vecteur élémentaire tangeant au
Les physiciens sont extrêmement prolifiques lorsqu’il point ~r à la ligne de champ (figure 4.22) et s est l’abscisse
s’agit de produire, à partir de problèmes divers, des curviligne sur la ligne de champ.
équations différentielles ordinaires (par exemple, les Si les coordonnées de d~s sont (dx, dy, dz), on obtient
équations du mouvement de la mécanique newtonienne). évidemment en chaque point ~r :
Malheureusement, l’inspiration manque parfois lorsqu’il dx dy dz ds
s’agit de les résoudre, en particulier quand elles ne sont = = =
Ex Ey Ez E
pas linéaires : un petit programme de résolution numérique
peut alors s’avérer précieux. ~ et E = kEk.
où, bien sûr, ds = kdsk ~ On aboutit alors
72 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

ds la position). Il faut alors fixer des conditions initiales

(0)
yℓ (x0 ) et un pas d’intégration fini dx et procéder pas
à pas :
(k) (k−1)
yℓ = yℓ + fℓ (xk−1 , {yp(k−1) })dx

Il s’agit simplement d’une approximation linéaire des fonc-

tions yℓ pour chaque pas d’intégration k où la pente des
Ligne de champ fonctions est estimée à partir du résultat précédent (figure
4.23).

Figure 4.22 – Une ligne de champ

y (2) (3)
(1) (2) f
à un système de trois équations différentielles du premier y f
(1)
f
ordre : (0)
f
dx Ex (~r) (0)
= y
ds E(~r)
dy Ey (~r)
= dx
ds E(~r)
dz Ez (~r)
=
ds E(~r)
dont la résolution doit donner les équations paramétriques
x(s), y(s) et z(s) en fonction de l’abscisse curviligne s de
la ligne champ considérée.
Pour résoudre numériquement ce système, on part d’un
point donné (x0 , y0 , z0 ) (les conditions initiales pour une x0 x1 x2
ligne donnée), et l’on choisit un pas d’intégration fini ds,
comme pour les intégrations numériques du chapitre 4.3.2. Figure 4.23 – La méthode d’Euler (ici à une dimen-
Il reste alors à intégrer pas à pas : sion, c’est-à-dire une seule équation différentielle) : on cal-
cule les dérivées en un point, on prolonge les fonctions
xn = xn−1 + dx linéairement en ce point en utilisant les dérivées sur un
yn = yn−1 + dy pas d’intégration fini dx ce qui donne un nouveau point
de départ d’où l’on peut recommencer.
zn = zn−1 + dz

avec Comme pour les problèmes d’intégrales, la difficulté est

évidemment le choix du pas d’intégration : la première
Ex (xn−1 , yn−1 , zn−1 ) règle est évidemment qu’il doit être petit par rapport à une
dx = ds
E(xn−1 , yn−1 , zn−1 ) distance de variation significative des fonctions étudiées.
Ey (xn−1 , yn−1 , zn−1 ) Ici, une fois de plus, il ne faut pas oublier que l’on est
dy = ds physicien : par exemple dans le cas des lignes de champ,
E(xn−1 , yn−1 , zn−1 )
Ez (xn−1 , yn−1 , zn−1 ) on peut tenter de tracer deux lignes très proches et vérifier
dz = ds qu’elles ne se croisent pas. . .
E(xn−1 , yn−1 , zn−1 )
c’est ce que l’on appelle la méthode d’Euler. Pour tracer 4.9.3 La méthode d’Euler
d’autres lignes de champ, il suffit de partir d’autres con- ≪ améliorée ≫ ou méthode de
ditions initiales et de recommencer.
Heun.
4.9.2 La méthode d’Euler. La méthode d’Euler donne souvent des résultats satis-
faisants, mais elle a le défaut que les dérivées sont évaluées
Soit donc, pour généraliser, un système de n équations au début de l’intervalle dx : il y a là une dissymétrie
différentielles du premier ordre du type : génante, car il n’y a pas de raison d’évaluer les dérivées
au début plutôt qu’à la fin ou au milieu de l’intervalle. On
dyℓ
= fℓ (x, {yp }), ∀ℓ ∈ [1, n] retrouve les questions abordées pour l’intégration dans le
dx
chapitre 4.3.2 par la méthode des rectangles, à gauche, à
et l’on cherche à calculer numériquement les valeurs droite ou centrés. La différence est qu’alors, on pouvait cal-
des yℓ (x) en connaissant les expressions des dérivées culer la fonction à intégrer n’importe où : ce n’est plus le
fℓ (x, {yp }) en fonction de x et de l’ensemble des yp (dans cas puisque les valeurs des fonctions sont les réponses que
l’exemple précédent, on avait les dérivées des coordonnées l’on cherche justement. On ne connait que les dérivées en
d’un point sur la ligne de champ par rapport à l’abscisse fonction des valeurs prises par ce que l’on cherche, puisque
curviligne en fonction du champ, lui-même dépendant de les fℓ dépendent des yp : on tourne en rond !
Physique numérique, Philippe Depondt 73

(4)
y(x) première estimation de la dérivée
(2) (3)
deuxième estimation
(1)
y(x+dx) (3)
(2)
moyenne des 2 dérivées

x x+dx

Figure 4.24 – Méthode d’Euler améliorée dx/2

dx
Ce que l’on aimerait faire, c’est une estimation de la
dérivée au milieu de l’intervalle dx (au demi-pas) en faisant
une moyenne entre les valeurs des dérivées au début et à Figure 4.25 – Les quatre évaluations de la dérivée dans
la fin de l’intervalle : la méthode de Runge-Kutta d’ordre 4.
(k−1) (k)
fℓ (xk−1 , {yp
}) + fℓ (xk , {yp })
fℓ (xk−1/2 , {yp(k−1/2) }) =
2
(4.21) subroutine rk4(x,y,dx,n,deriv)
(k)
Comme la valeur de yp est inconnue, on peut faire !--------------------------------------------!
une première estimation à l’aide de la méthode d’Euler ! sous programme de resolution d’equations !
précédente ; puis on applique l’équation (4.21) pour ! differentielles du premier ordre par la !
obtenir la dérivée au demi-pas et enfin on peut utiliser ! methode de Runge-Kutta !
de nouveau la méthode d’Euler avec cette dérivée corrigée ! x = abscisse !
! y = valeurs des fonctions !
(figure 4.24).
! dx = pas !
Le coût de cette amélioration est évidemment que ! n = nombre d’equations differentielles !
l’on doit faire deux estimation des dérivées par pas ! deriv = variable contenant le nom du !
d’intégration, mais évidemment, ce coût peut être com- ! sous-programme qui calcule les derivees !
pensé si l’on peut obtenir la même précision, voire !--------------------------------------------!
mieux, qu’avec la méthode d’Euler en prenant un pas implicit none
d’intégration deux fois plus grand. integer , intent(in) :: n
real, dimension(n), intent(inout) :: y
real , intent(in) :: x, dx
4.9.4 La méthode de Runge-Kutta d’or- ! d1, d2, d3, d4 = estimations des derivees
dre 4. ! yp = estimations intermediaires des fonctions
real, dimension(n) :: d1, d2, d3, d4, yp
Il se trouve que la méthode de Heun est assez peu real :: ddx, c = 1.0/6.0
utilisée car, la méthode de Runge-Kutta d’ordre 4 est un
pas supplémentaire dans cette direction qui offre souvent ddx = dx/2
un très bon compromis : elle tente de faire une meilleure call deriv(x ,y ,d1,n); yp=y+d1*ddx
estimation des dérivées à l’aide d’une moyenne de 4 esti- call deriv(x+ddx,yp,d2,n); yp=y+d2*ddx
call deriv(x+ddx,yp,d3,n); yp=y+d3*dx
mations (d’où l’ordre 4).
call deriv(x+dx ,yp,d4,n); y =y+c*(d1+2*d2+2*d3+d4)*dx
La première estimation est celle d’Euler : on calcule les
dérivées au point x connaissant les yp (x) déjà calculés au end
pas précédent. On fait alors un demi -pas de longueur dx 2
par la méthode d’Euler pour évaluer les valeurs des yp
au demi-pas : cela permet de calculer de nouvelles valeurs
des dérivées (figure 4.25). On revient au point de départ et -Exercice : vérifier que le programme ci-dessus fait bien
l’on utilise ces nouvelles dérivées pour refaire un demi-pas ce qui est annoncé. . .
d’Euler et obtenir de nouvelles valeurs des yp : on ne trou- Pour utiliser ce sous-programme, il faut un programme
vera pas le même résultat puisqu’on n’utilise pas les mêmes principal qui fasse une boucle sur x et qui gère les
dérivées, il ne s’agit toujours que d’estimations. Cela per- entrée-sorties et un autre sous-programme qui contient la
met d’obtenir une troisième estimation de dérivées. Cette physique du problème, soit le calcul des dérivées : dans le
troisième estimation est utilisée pour faire un pas complet, cas des lignes de champ, il doit calculer les composantes
cette fois-ci, d’Euler, toujours à partir du même point de du champ, sa norme et faire les rapports.
départ : quatrième estimation des yp et des dérivées. . .
Il reste alors à faire une moyenne pondérée de ces qua- Cela ressemble certes à une recette de cuisine, mais
tre estimations en faisant compter celles du milieu deux c’est un des chevaux de bataille des physiciens : c’est une
fois plus et faire enfin un pas de longueur dx. Le sous- méthode remarquablement efficace ! Une illustration en est
programme correspondant est très simple : donnée figure 4.26.
74 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Figure 4.27 – Vérification de la périodicité du problème

de Volterra-Lotka résolu par la méthode de Cranck et
Nicholson.

la variation des fonctions étant entièrement calculée à par-

tir des valeurs des dérivées au début de l’intervalle : on
Figure 4.26 – Lignes de champ d’un système de trois
pourrait tout aussi bien faire le même calcul en utilisant
charges calculées à l’aide de la méthode de Runge-Kutta
les dérivées à la fin de l’intervalle :
d’ordre 4.
(k+1) (k) (k+1)
yℓ = yℓ + fℓ (xk+1 , {yℓ′ })dx
4.9.5 La méthode de Cranck et Nicholson La méthode de Heun faisait une estimation des dérivées
Même la méthode de Runge-Kutta, malgré toutes ses en fin de l’intervalle par la méthode d’Euler, mais il y a
qualités, ne donne pas toujours entière satisfaction. Un ex- là encore une part d’arbitraire : on peut remarquer toute-
emple classique et le modèle proies-prédateurs de Volterra- fois que l’équation ci-dessus est une équation implicite,
(k+1)
Lotka 27 . Le nombre x de proies croı̂t au cours du temps les inconnues yℓ figurant dans le deuxième membre ;
d’un coefficient a mais diminue proportionnellement au il faut donc résoudre un système d’équations (en général
nombre de prédateurs y : non-linéaires) :
dx (k+1) (k) (k+1)
= x (a − by) yℓ − yℓ − fℓ (xk+1 , {yℓ′ })dx = 0
dt
c’est une recherche de zéro qui peut être faite par la
De même, le nombre de prédateurs décroı̂t d’un taux c à méthode de Newton déjà vue (§4.5.3). Cette méthode est
cause de la mortalité, mais croı̂t proportionnellement aux appelée la méthode d’Euler implicite mais elle n’apporte
ressources disponibles en proies, soit : guère par rapport à la méthode d’Euler explicite déjà vue
dy -elle est tout aussi dissymétrique- sinon qu’elle est sensi-
= y (−c + d x) blement plus compliquée !
dt
La méthode de Cranck et Nicholson est une moyenne
On démontre que les solutions de ce système d’équations entre la méthode d’Euler explicite et la méthode d’Euler
sont périodiques au cours du temps : un bon test est donc implicite, qui rétablit ainsi la symétrie à la manière de la
de vérifier la périodicité du résultat numérique obtenu en méthode de Heun, mais de façon plus rigoureuse :
traçant, par exemple, y en fonction de x afin de voir si  
(k) (k+1)
la trajectoire obtenue repasse toujours au mêmes endroits fℓ (xk , {yℓ′ }) + fℓ (xk+1 , {yℓ′ })
(k+1) (k)
(voir la figure 4.27). . . ce qui n’est, bien sûr, jamais par- yℓ = yℓ +
2
dx
faitement obtenu !
(k+1)
Un autre exemple célèbre est l’équation de Schrödinger ce qui donne à résoudre en yℓ′ :
dépendant du temps : si l’on ne fait pas très attention, on  
(k) (k+1)
obtient que la norme de la fonction d’onde diverge expo- fℓ (xk , {yℓ′ }) + fℓ (xk+1 , {yℓ′ })
(k+1) (k)
nentiellement avec le temps, ce qui est fâcheux ! yℓ − yℓ − dx = 0
2
Dans les deux cas, la méthode de Cranck et Nicholson (4.22)
peut être une solution. C’est une méthode assez lourde puisqu’il faut résoudre
Si l’on revient à la méthode d’Euler, la critique qui en un système non-linéaire d’équations (4.22) par la méthode
avait été faite était qu’elle est dissymétrique : de Newton, ce qui suppose de calculer la matrice jacobi-
enne des dérivées partielles et un programme de résolution
(k+1) (k) (k)
yℓ = yℓ + fℓ (xk , {yℓ′ })dx de systèmes linéaires appelé itérativement en espérant que
27. voir par exemple :
les solutions trouvées accepteront de converger. Il s’agit
http://perso.univ-rennes1.fr/gregory.vial/agreg/cplt/ cependant d’un moyen puissant pour se tirer de situations
volterra.pdf. délicates, à garder donc dans ses archives au cas où !
Physique numérique, Philippe Depondt 75

4.9.6 Équations d’ordre supérieur à 1. Les vitesses sont évaluées au demi-pas, alors que les posi-
tions et les forces sont évaluées au pas entier, ce qui sup-
Pour le moment, on s’en est tenu à des systèmes prime la dissymétrie qui était génante dans la méthode
d’équations d’ordre un : en fait, c’est beaucoup moins re- d’Euler.
strictif que cela en a l’air. Soit par exemple, une équation Cette méthode est fort utilisée sous des formes di-
du deuxième ordre : verses dès que l’on s’intéresse à la dynamique de systèmes
d2 y dy comportant un grand nombre de particules (de quelques
2
+a =f dizaines à quelques dizaines de milliers. . .).
dx dx
où a peut être une constante ou une fonction de y. Si l’on
introduit une variable supplémentaire z qui est la dérivée
4.9.8 Le problème du pas d’intégration.
première de y, on obtient : Dans tout ces problèmes d’équations différentielles, on
 l’a vu, le pas d’intégration est non-nul, il est petit, certes,
 dy
 =z mais il n’est pas nul. ≪ Il n’y a qu’à ≫ le choisir as-
dx sez petit. . . Ce n’est, hélas, pas toujours aussi simple :
 dz = f − az

si on le choisit trop petit, on multiplie le nombre des
dx
itérations, ce qui allonge inutilement la durée du calcul,
deux équations différentielles du premier ordre. On peut mais aussi multiplie les erreurs d’arrondi ; trop diminuer
donc toujours décomposer des équations différentielles le pas d’intégration diminue la précision du calcul, on perd
d’ordre supérieur à un en plusieurs équations d’ordre un à sur tous les tableaux ! Un compromis s’impose alors, mais
condition d’introduire des variables supplémentaires qui selon quel critère ?
sont les dérivées successives des fonctions. Ainsi, trois Il appartient à chacun de se poser cette question et de
équations du deuxième ordre se transforment aisément en tenter d’y répondre par une étude a priori du problème.
six équations du premier ordre, une équation du troisième Par exemple, s’il s’agit d’un système mécanique isolé non-
ordre devient trois du premier ordre, etc. dissipatif, la somme de l’énergie potentielle et de l’énergie
cinétique doit rester constante au cours du calcul, c’est la
4.9.7 Méthode de Verlet. physique qui le dit ! La périodicité attendue du problème
de Volterra-Lotka est aussi un bon critère, la conserva-
Les systèmes d’équations différentielles du deuxième or- tion de la norme de la fonction d’onde pour l’équation de
dre sont d’un intérêt particulier en physique puisque les Schrödinger également. Bien souvent, on peut résoudre le
équations du mouvement d’un ensemble de n mobiles en système d’équations différentielles dans un cas proche de
interaction s’écrivent : celui qui nous intéresse mais dont on connait la solution
d2~rℓ d~
r analytique (un système linéaire, par exemple) et vérifier
= ~ℓ ({~rp , p }), ∀ℓ ∈ [1, n]
f que le calcul numérique donne bien le même résultat, ou
dt2 dt
un résultat très proche du calcul analytique.
Cela se résout sans difficulté majeure par la méthode Ces questions ne sont pas à négliger : revenons à
de Runge-Kutta, voire par Cranck-Nicholson, puisque l’équation logistique du premier TP Si on la considère
cela donne 3n équations du deuxième ordre et donc 6n comme une équation différentielle, implicitement, puisque
équations du premier ordre. la population d’insecte de la génération n + 1 est calculée
Si l’on se restreint à des interactions de paire, les forces un an après celle de la génération n, le pas d’intégration
s’écrivent : est de un an. On pourrait imaginer d’intégrer analytique-
Xn
f~ℓ = f~ℓℓ′ ment cette équation et considérant le temps comme une
ℓ′ =1,ℓ′ 6=ℓ
variable continue et donc un pas d’intégration qui tend
vers zéro :
soit, en tenant compte du principe de l’action et de la
réaction 28 , n(n−1)
2 forces à calculer. Si l’on est en train x(t + dt) = r x(t) (1 − x(t)) dt
de s’intéresser à un système composé d’un grand nombre
d’atomes, ou à une galaxie comportant beaucoup d’étoiles, soit :
cela fait vite un nombre prodigieux de forces à calculer et dx x(t + dt) − x(t)
= = x (r(1 − x) − 1)
l’expérience prouve que le programme va passer 99% du dt dt
temps dans le sous-programme de calcul des forces ; il est
Il s’agit d’une équation différentielle qui se résoud analy-
vital d’optimiser ces calculs là. Or, ce n’est sans doute pas
tiquement à la main avec un peu de travail 30 , ou alors
une très bonne idée, dans ce cas là, d’utiliser un algorithme
grâce à un logiciel de calcul formel, et l’on obtient :
comme Runge-Kutta 29 qui exige quatre estimations des
forces par pas de calcul ! (r − 1)x0
x(t) =
L’algorithme de Verlet est une réponse très simple à ce rx0 + (r(1 − x0 ) − 1) e−(r−1)t
problème :
où x0 = x(t = 0). Pour r > 1, cette expression con-

 dt dt fℓ ({~rℓ′ (t)}) verge exponentiellement vers son point fixe : plus de chaos !
 ~vℓ (t + ) = vℓ (t − ) + dt
2 2 mℓ On obtient donc un énorme changement qualitatif (figure

 ~r (t + dt) = ~r (t) + ~v (t + )dt dt 4.28) 31 .
ℓ ℓ ℓ
2 30. On peut faire le changement de variable x(t) = a
où a,
b+cy(t)
28. f~ℓ′ ℓ = −f~ℓℓ′ . b et c sont des coefficients à déterminer et y(t) la nouvelle variable.
29. sans parler de Cranck-Nicholson. . . 31. Voir H. Krivine, J. Treiner, A. Lesne, soumis Am. J. Phys.
76 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

1
dt=1
continu
où x+ et v + sont les inconnues. On a donc deux fonction
0.9
dont on doit chercher le zéro par une méthode de Newton :
0.8

0.7 v + v+
0.6 f (x+ , v + ) = x − x+ + δt
2
0.5
sin x + sin x+
x

0.4 g(x+ , v + ) = v − v+ − δt
2
0.3

0.2 On doit appliquer à x+ et v + des variations dx+ et dv + de

0.1 façons à ce que ces fonctions s’annulent, c’est-à-dire que
0
0 5 10 15 20 25 30 35 40 45 50
df = −f et dg = −g ; or, en linéarisant, comme d’habitude
t
∂f ∂f
df = dx+ + dv +
Figure 4.28 – Résolution numérique avec dt = 1 et ∂x+ ∂v +
résolution analytique de l’équation logistique pour r = 4 : ∂g ∂g
dg = dx+ + dv +
qui a raison ? ∂x+ ∂v +
∂f ∂g
Le calcul numérique est-il donc faux ? Cela dépend du Les dérivées sont aisées à calculer : = = −1,
∂x+ ∂v +
modèle. Si l’on considère qu’il n’y a pas de saison et que le ∂f δt ∂g δt
= et = − cos x+ . Cela donne, tous calculs
taux de reproduction des insectes dépend instantanément ∂v + 2 ∂x+ 2
de la population à l’instant t, alors c’est le calcul avec le faits :
temps continu qui est correct. Si, au contraire, on considère f + g δt
que le taux de reproduction des insectes dépend de l’état dx+ = 2


δt 2
de la génération précédente au moment de la ponte et donc 1 + cos x+ 2
de la façon dont elle a pu se nourrir l’année précédente, dx+ − f
dv + =
alors c’est le pas d’intégration d’un an qui est correct. δt
2
Au physicien - averti, bien sûr -, donc, de choisir son
modèle en connaissance de cause et de faire ses choix en Le programme qui fait tout cela et calcule la variance de
conséquence ! l’énergie en fonction du pas de temps peut s’écrire :
program pendule
4.9.9 Quelle méthode choisir ? implicit none
integer, parameter :: n = 2
Comme chaque fois que l’on dispose de plusieurs
real, dimension(n)
:: theta
méthodes pour résoudre un problème se pose la question : real
:: t, dt, tmax
laquelle choisir ? Il serait bien sûr tellement agréable de double precision
:: e, em, e2m, e0
pouvoir répondre de façon univoque et définitive ! C’est, integer
:: nstep, step, it
hélas, trop demander. character (len=1)
:: ode
À titre indicatif, on a tenté de comparer les méthodes :: d external
exposées ci-dessus dans le cas d’un pendule simple, dont
l’équation du mouvement s’écrit : write(*,’("Runge-Kutta, Euler, Heun, Verlet, &
& Cranck-Nicholson ? ")’,advance=’no’)
ẍ = − sin x read(*,*) ode
open(1, file = ’pendule.var’)
où x est l’angle que fait le pendule avec la verticale. tmax = 157. ! 25 periodes
Comme il s’agit d’un système non-dissipatif (sans force do it = -24, 4 ! boucle sur la valeur du
de frottement), l’énergie doit rester constante ; ainsi la dt = 10.**(0.25*it) ! pas de temps
variance de l’énergie au cours d’une simulation devrait nstep = nint(tmax/dt)
être nulle : voilà donc un test pour mettre ces algo- em = 0. ; e2m = 0.
rithmes à l’épreuve. Pour les méthodes d’Euler, Verlet, theta(1) = 1.5 ; theta(2) = 0. ! cond. init.
e0 = theta(2)**2*0.5 - cos(theta(1))
Heun et Runge-Kutta, l’application est facile : il suf-
do step = 1, nstep ! boucle sur le temps
fit de décomposer l’équation du deuxième ordre en deux t = step*dt
équations du premier ordre, en introduisant une variable select case (ode)
supplémentaire v : case(’R’)
call rk4(t, theta, dt, n, d)
ẋ = v case (’E’)
v̇ = − sin x call euler(t, theta, dt, n, d)
case (’H’)
Pour Cranck-Nicholson, il y a un peu plus de travail ; call heun(t, theta, dt, n, d)
soient, pour simplifier les notations, x = x(t) et v = v(t) case(’V’)
x+ = x(t + δt) et v + = v(t + δt). Cela s’écrit : call verlet(t, theta, dt, n, d)
case(’C’)
v + v+ call cranck(t, theta, dt, n, d)
x+ = x+ δt
2 case default
sin x + sin x+ stop
v+ = v− δt end select
2
Physique numérique, Philippe Depondt 77

e = theta(2)**2*0.5 - cos(theta(1)) - e0 ! energie external :: deriv

em = em + e ; e2m = e2m + e*e integer :: count
enddo dth = dt/2.d0
em = em/nstep ; e2m = e2m/nstep x = y(1) ; v = y(2)
write(1,*) dt, e2m -em*em ! variance de l’energie xp = x + v*dt ; vp = v - sin(x)*dt ! Euler
enddo do count = 1, 100 ! Newton
close(1) f = x - xp + (v + vp)*dth
end g = v - vp -(sin(x) + sin(xp))*dth
dx = (f+g*dth)/(1+cos(xp)*dth**2)
subroutine d(t,theta,dtheta,n) ! derivees dv = (dx-f)/dth
implicit none if ( abs(dx) < eps .and. abs(dv) < eps ) exit
integer, intent(in) :: n xp = xp + dx ; vp = vp + dv
real, intent(in) :: t enddo
real, dimension(n), intent(in) :: theta y(1) = xp ; y(2) = vp
real, dimension(n), intent(out) :: dtheta end
dtheta(1) = theta(2) ; dtheta(2) = -sin(theta(1))
La figure 4.29 montre le résultat de ces calculs et la table
end
4.3 donne le temps que cela prend. Le meilleur algorithme
subroutine heun(x,y,dx,n,deriv) est bien sûr celui qui donne la variance la plus faible pour
implicit none le pas de temps le plus grand et la durée d’exécution la
integer :: i, n, nmax plus courte. . .
real , intent(in) :: x, dx
100000
real, dimension(n), intent(inout) :: y Euler
Verlet
real, dimension(n) :: yp, k1, k2 Heun
Runge−Kutta 4
call deriv(x,y,k1,n) ; yp = y + dx*k1 Cranck−Nicholson
1
call deriv(x+dx,yp,k2,n) ; y = y + dx*0.5*(k1 + k2)
end
Variance

subroutine euler(x,y,dx,n,deriv) 1e−05

implicit none
integer , intent(in) :: n
real , intent(in) :: x, dx 1e−10
real, dimension(n), intent(inout) :: y
real, dimension(n) :: k1
call deriv(x,y,k1,n) ; y = y + dx*k1 1e−15
1e−06 1e−05 1e−04 0.001 0.01 0.1 1 10
end dt

subroutine verlet(x,y,dx,n,deriv) Figure 4.29 – Variance de l’énergie d’un pendule sim-

implicit none ple en fonction du pas de temps pour plusieurs méthodes
integer , intent(in) :: n d’intégration (échelles logarithmiques).
real , intent(in) :: x, dx
real, dimension(n), intent(inout) :: y
real, dimension(n) :: dy Euler 2mn 8s
call deriv(x,y,dy,n) Verlet 2mn 10s
y(2) = y(2) + dy(2)*dx ; y(1) = y(1) + y(2)*dx
Heun 3mn 2s
end
Runge-Kutta 5mn 34s
subroutine rk4(x,y,dx,n,deriv) Cranck-Nicholson 2mn 57s
implicit none
integer , intent(in) :: n Table 4.3 – Durées d’exécution du programme ci-dessus
real , intent(in) :: x, dx pour les différentes méthodes (sur un PC).
real, dimension(n), intent(inout) :: y
real :: ddx, c= 1.0/6.0 On constate d’abord que la méthode de Verlet, pour
real, dimension(n) :: yp, k1, k2, k3, k4 une durée d’exécution identique à celle d’Euler et un effort
ddx = 0.5*dx de programmation mineur, permet de gagner un ordre de
call deriv(x ,y ,k1,n) ; yp = y+ddx*k1 grandeur dans le pas d’intégration et plusieurs ordres de
call deriv(x+ddx,yp,k2,n) ; yp = y+ddx*k2 grandeur de précision : Euler paraı̂t donc à rejetter sans
call deriv(x+ddx,yp,k3,n) ; yp = y+dx*k3 hésitation ! La méthode de Heun permet une amélioration
call deriv(x+dx ,yp,k4,n) sensible des résultats par rapport au deux précédentes,
y = y+dx*( k1 + 2.0*k2 + 2.0*k3 + k4 )*c
mais Runge-Kutta fait encore nettement mieux puisqu’on
end
gagne à peu près un ordre de grandeur pour le pas de
subroutine cranck(t,y,dt,n,deriv) temps pour une durée d’exécution à peine deux fois plus
implicit none grande. Quant à Cranck & Nicholson, elle se situe à peu de
integer , intent(in) :: n choses près dans la même gamme de qualité que Heun, au
real , intent(in) :: t, dt prix d’un effort de programmation nettement supérieur.
real, dimension(n), intent(inout) :: y Ainsi, la méthode de Runge-Kutta offre un rapport
double precision :: x, v, xp, vp, dx, dv, f, g, & qualité-prix excellent ce qui explique son succès auprès
dth, eps = 1.e-8 des physiciens !
78 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Il convient toutefois de nuancer assez nettement ce ou en développant l’exponentielle :

verdict : dans le problème ci-dessus, l’amplitude des os- X
cillations a été choisie forte. Si l’on choisit de faire le f (t) = aℓ cos(−2πℓνt) + ibℓ sin(−2πℓνt)
même calcul pour des amplitudes plus faibles, les résultats ℓ
changent : en particulier, Cranck & Nicholson ne fait alors
guère mieux qu’Euler (ce qui confirme que cette méthode où les coefficients aℓ et bℓ sont complexes, ou encore en
est à réserver aux cas difficiles) ! Si, au lieu d’un pendule, décomposant les coefficients cℓ en module et phase :
on en avait eu 1000, couplés entre eux, il est fort probable X
f (t) = kcℓ k eiϕℓ e−2πiℓνt
que la méthode de Verlet aurait sensiblement amélioré son
ℓ
score. . . X
La conclusion de tout ceci est que, sauf raison contraire = kcℓ k ei(−2πℓνt+ϕℓ )
a priori, dans la plupart des cas, la méthode de Runge- ℓ
Kutta est un excellent point de départ, mais pour des
Ce genre de développement est limité aux fonctions
systèmes du second ordre sans frottement pour lesquels
périodiques de période τ = ν1 , mais on peut généraliser
les temps de calcul des dérivées est grand (typiquement
en considérant que la fréquence, au lieu d’être limitée à ν
quelques milliers d’atomes en interaction), Verlet est sans
et à ses harmoniques 2ν, 3ν, . . ., ℓν,. . ., varie continûment,
doute un meilleur choix. Ces remarques ne doivent toute-
ainsi la somme de l’équation (4.23) devient une intégrale :
fois en aucun cas servir de prétexte pour se dispenser de
tests sérieux pour chaque tentative particulière : caveat Z ∞
emptor 32 . f (t) = F (ν) e−2πiνt dν (4.24)
−∞

L’imagination des numériciens et des mathématiciens et inversement :

appliqués concernant la résolution d’équations différen- Z ∞
tielles ordinaires paraı̂t infinie : la littérature sur la F (ν) = f (t) e2πiνt dt
question est surabondante. En particulier, toutes les −∞
méthodes à pas variable qui permettent d’adapter en
cours de calcul la longueur du pas d’intégration sont où la fonction F (ν) est la transformée de Fourier de f (t),
complètement ignorées ici. Se reporter au besoin à la f (t) est la transformée de Fourier inverse de F (ν). La fonc-
littérature, par exemple, la référence [19] dans la bibli- tion f (t) n’a plus de raison d’être périodique.
ographie. Dans l’équation (4.23), le coefficient complexe cℓ donne
le poids et la phase du terme d’ordre ℓ du développement,
c’est-à-dire de la contribution de fréquence ℓν : la même
4.10 Transformées de Fourier rapi- note (c’est-à-dire un son de même fréquence fondamentale)
jouée sur un clavecin et sur un piano ne produit pas le
des. même son, c’est que la suite des cℓ n’est pas la même.
Dans ce chapitre, nous verrons de façon aussi concrète Dans l’équation (4.24), le terme F (ν) donne de la même
que possible ce qu’est une transformée de Fourier pour un façon le poids et la phase de la contribution de fréquence
physicien, sans que cela remplace un cours plus formel, ν du signal temporel : il s’agit d’une décomposition en
puis l’on étudiera ce qu’en font les logiciels et sous- fréquences.
programmes de transformée rapide afin de tenter de saisir
la puissance mais aussi les limites de cet outil extraordi- 4.10.1.1 Un exemple : le paquet d’ondes.
naire.
Imaginons, par exemple, que l’on allume une lumière
à l’aide d’un interrupteur à un instant t0 − τ2 et que la
4.10.1 La transformée de Fourier en maintienne allumée pendant un temps τ , puis on l’éteint.
physique. Mettons, pour simplifier, que la lumière soit monochroma-
tique de fréquence ν0 . On a ainsi produit une onde plane
Au début du XIXe siècle, en 1822, le baron Joseph interrompue, pour ainsi dire de durée finie, dont l’ampli-
Fourier 33 , dans sa Théorie analytique de la chaleur, util- tude peut s’écrire, au point ~r = 0 :
isa pour résoudre la relation qui porte son nom (φ ~ =

~
−κ grad T , le flux de chaleur est proportionnel au gradi- E(t) = E0 e−2πiν0 t si t0 − τ2 < t < t0 + τ2
ent de température) des développements sur une base de E(t) = 0 sinon
sinus et de cosinus : les séries de Fourier. En notations
complexes 34 : La transformée de Fourier d’un tel signal donne, à la
suite d’un petit calcul :
X
f (t) = cℓ e−2πiℓνt (4.23) Z t0 + τ2
ℓ E0 e2πi(ν−ν0 )t dt =
t0 − τ2
32. ≪ Que l’acheteur ouvre l’œil ≫.
33. À ne pas confondre avec Charles Fourier, philosophe, auteur
de l’utopie sociale fouriériste et des phalanstères. E0 τ e2πi(ν−ν0 )t0 sinc π(ν − ν0 )τ (4.25)
34. On peut considérer, pour se fixer les idées, t comme un temps 35
et ν comme une fréquence, mais les relations données ici sont plus donc, essentiellement un sinus cardinal représenté sur la
générales : coordonnées spatiales et vecteur d’onde, par exemple, figure 4.30.
sont susceptibles du même traitement, c’est d’ailleurs le cas pour la
sin x
relation de Fourier. 35. sinc x = x
.
Physique numérique, Philippe Depondt 79

1
Ces considérations ne se limitent bien sûr pas à l’op-
0.8 tique : un instrument de musique capable de ≪ tenir ≫ une
0.6 note, comme un orgue, un violon ou une trompette, pro-
0.4 duira un son dont la hauteur ou la fréquence est bien
0.2 définie, alors que pour une percussion, timbale ou tam-
0
bour, dont le son est très court dans le temps, la hauteur de
la note est beaucoup moins facile à définir (même s’il existe
−0.2
des timbales de hauteurs différentes). De même, dans le do-
−0.4
maine des communications, en général, on utilise une onde
−0.6 porteuse d’une certaine fréquence : il faut que la durée
−0.8 des impulsions qui codent l’information soit relativement
−1 longue par rapport à la période de la porteuse afin d’éviter
0 2 4 6 8 10
frequences un élargissement trop grand du spectre de fréquence ce qui
1 se traduit généralement par une dégradation de la qualité
0.9 de la transmission.
0.8
0.7
4.10.1.2 Quelques propriétés importantes.
0.6 4.10.1.2.1 Notations. La notation utilisée jusqu’ici
0.5 prend la convention temps-fréquence, or on pourrait tout
0.4 aussi bien éviter le facteur 2π grâce à la pulsation ω =
0.3
2πν : Z ∞
0.2 F (ω) = f (t) eiωt dt
−∞
0.1
et Z ∞
0 1
0 2 4 6 8 10 f (t) = F (ω) e−iωt dω
frequences 2π −∞

Évidemment, le changement de variable introduit le fac-

Figure 4.30 – Transformée de Fourier d’une onde plane teur de 1/2π dans la transformée inverse. Les notations
interrompue : en haut partie réelle de l’équation (4.25) sont parfois diverses : il arrive de√ trouver ce facteur réparti
pour ν0 = 5, τ = 1 et t0 = 10. En bas, module au carré (i.e. équitablement sous forme de 1/ 2π dans les expressions
produit par son complexe conjugué) de la même chose : de la transformée directe et inverse, ou purement et sim-
c’est ce que l’on appelle le ≪ spectre ≫. plement supprimé. . . Il est vrai que cela n’a guère d’impor-
tance puisqu’il ne s’agit ≪ que ≫ d’un facteur multiplicatif !
On a raisonné ici en termes de temps et de fréquence
On constate que l’onde plane interrompue, au lieu de
mais rien n’oblige à ce que t soit un temps : il peut très
n’avoir qu’une fréquence bien définie ν0 comme une onde
bien s’agir d’une coordonnée spatiale z et dans ce cas, on
plane infinie, s’étale sur tout un spectre de fréquences. Ce
remplacera la pulsation par le vecteur d’onde k = 2π λ où λ
spectre est centré sur ν0 , la fréquence de l’onde plane de
peut être considéré comme une longueur d’onde, par exem-
départ. Le premier zéro du sinus cardinal donne une esti-
ple, si ρ(z) est la densité électronique dans un matériau :
mation de la largeur du spectre : on trouve ν − ν0 = ± τ1 .
Z ∞
Ainsi, si la durée τ du paquet d’ondes devient grande
jusqu’à tendre vers l’infini, le spectre de fréquence se S(k) = ρ(z) eikz dz
−∞
resserre autour de ν0 jusqu’à ne plus comporter que la
fréquence ν0 : on retrouve l’onde plane infinie. Au con- la quantité S(k) s’appelle le facteur de structure et c’est
traire, si la durée du paquet d’onde devient petite, la dis- ce que l’on mesure (ou du moins son module au carré)
tribution des fréquences s’élargit jusqu’à devenir infinie. lors d’expériences de diffraction de rayons X : c’est une
Concrètement, si en actionnant à la main un inter- grandeur d’une considérable importance en physique de la
rupteur, l’on allume une lumière ou un laser, puis on matière condensée : à partir de la connaissance du facteur
38
l’éteint une seconde plus tard, la largeur de la distribu- de structure, on peut remonter à la densité électronique,
tion de fréquences sera de l’ordre de 1Hz ; or la fréquence et en admettant que les électrons se situent à proximité
de la lumière visible est plutôt dans le domaine des des noyaux, la structure atomique du matériau considéré.
14
10 Hz : l’élargissement en fréquences est complétement C’est donc un moyen très puissant d’investigation de la
négligeable, le paquet d’ondes peut être considéré comme matière.
infini sans inconvénient, c’est d’ailleurs l’approximation De façon plus générale, les mathématiciens ne se
habituelle en optique. En revanche, si l’on choisit d’u- préoccupent pas toujours du sens physique des variables
36
tiliser un laser à impulsions, chaque impulsion durant utilisées pour s’intéresser à l’objet mathématique ≪ trans-
37
quelques centaines de femtosecondes (ça s’achète dans formée de Fourier ≫ qui peut s’écrire :

13 Z ∞
le commerce), la largeur spectrale est de l’ordre de 10 Hz
ce qui n’est plus du tout négligeable comme le montrera ϕ(u) = f (x) eiux dx
le cours d’optique. −∞

38. En principe. . . toutefois, la grosse difficulté vient de ce qu’on

36. Ou pulse en bon franglais. mesure le module de S(k) seulement et donc on perd la phase de la
37. 1fs=10−15 s. fonction complexe.
80 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

et la transformée inverse : dans l’équation (4.24) :

Z ∞ Z ∞ Z ∞ 
1
f (x) = ϕ(u) e−iux du f (t) =
′
f (t′ ) e2πiνt dt′ e−2πiνt dν
2π −∞ −∞ −∞
Z ∞ Z ∞
′
4.10.1.2.2 La distribution de Dirac. Intuitive- = f (t′ ) e2πiν(t −t) dν dt′
−∞ −∞
ment, il s’agit d’une ≪ fonction ≫ 39 δ(x) qui vaut zéro
partout sauf en x = 0 où. . . elle est infinie. Soit une fonc- après inversion de l’ordre des intégrations. L’intégrale sur
tion f (x), alors, la propriété fondamentale de la distribu- ν donne δ(t′ − t) et finalement :
tion de Dirac est : Z ∞
Z ∞
f (t) = f (t′ ) δ(t′ − t) dt′
f (x) δ(x) dx = f (0) −∞
−∞
ce qui est vrai.
ou bien à l’aide d’un changement de variable trivial :
Z ∞ 4.10.1.2.3 Linéarité. La transformée de Fourier est
f (x) δ(x − x0 ) dx = f (x0 ) une transformation linéaire : il est facile de se convain-
−∞
cre que la transformée de Fourier d’une somme est la
Si l’on applique ceci à la transformée de Fourier, on somme des transformées de Fourier et que la transformée
obtient : Z ∞ de Fourier d’une fonction multipliée par une constante est
le produit de la transformée de Fourier par cette constante,
δ(x) eiux dx = 1
−∞ Z ∞ Z ∞ Z ∞
la transformée de Fourier d’une Dirac est une constante (f (x) + g(x)) eiux dx = f (x) eiux dx + g(x) eiux dx
−∞ −∞ −∞
(un, en l’occurence) : c’est le cas extrême du paquet d’on-
des infiniment court : sa largeur spectrale est infinie, sa et Z ∞ Z ∞
transformée de Fourier non seulement infiniment large Cf (x) e iux
dx = C f (x) eiux dx
mais constante. −∞ −∞
Inversement, Cela est vrai bien sûr aussi pour les transformées in-
Z ∞ verses. Les propriétés suivantes sont tout aussi faciles à
1
C e−iux dx = C δ(x) démontrer :
2π −∞ Si. . . alors. . .
f (x) est réel ϕ(−u) = [ϕ(u)]∗
la transformée de Fourier d’une constante est la distribu-
f (x) est imaginaire pur ϕ(−u) = −[ϕ(u)]∗
tion de Dirac. On peut s’en convaincre en remarquant que,
f (x) est paire ϕ(u) est paire
tant que x est non nul, l’intégrale s’effectue sur un nom-
f (x) est impaire ϕ(u) est impaire
bre infini de périodes des cosinus et sinus de l’exponentielle
f (x) est réelle et paire ϕ(u) est réelle et paire
complexe, or, bien évidemment :
f (x) est réelle et impaire ϕ(u) est imag. et impaire
Z 2π Z 2π f (x) est imag. et paire ϕ(u) est imag. et paire
sin x dx = cos x dx = 0 f (x) est imag. et impaire ϕ(u) est réelle et impaire
0 0
Par ailleurs, si ϕ(u) est la transformée de Fourier de
et le résultat final est nul. En revanche, quand x = 0, f (x), celle de f (ax) est a1 ϕ( ua ) et celle de f (x − x0 ) s’écrit
l’exponentielle vaut 1 et le résultat est infini. Si donc, la ϕ(u) eiux0 .
transformée de Fourier d’une constante donne une Dirac,
c’est que l’onde plane infinie a une distribution spectrale 4.10.1.2.4 Produit de convolution. Imaginons que
qui ne comporte qu’une seule fréquence. l’on fasse une expérience pour mesurer une grandeur y en
La distribution de Dirac est parfois fort utile, si , par fonction d’une autre grandeur x, mais l’appareil de mesure
exemple, on a une distribution de charge ρ(z) qui ne com- n’est évidemment pas parfait : si on le règle sur une cer-
porte qu’une charge ponctuelle q située en z0 , on peut taine valeur x = x0 , il ≪ bave ≫ un peu et le résultat
écrire : obtenu sera une superposition de contributions issues de
ρ(z) = q δ(z − z0 ) points voisins de x0 :
et introduire ceci sans arrière-pensée dans les intégrales Z
et transformées de Fourier que l’on choisira afin d’utiliser ymesure (x0 ) = y(x) a(x0 − x) dx (4.26)
tous les théorèmes habituels.
La distribution de Dirac permet également de vérifier où a(x) est la ≪ fonction d’appareil ≫ dont on peut espérer
que l’expression de la transformée de Fourier inverse qu’elle a un maximum relativement marqué en x = 0. . . Le
donnée au début de ce chapitre est correcte : il suffit d’in- cas arrive, par exemple, si l’on fait une mesure de disper-
jecter l’expression : sion de la lumière à l’aide d’un prisme avec un faisceau de
Z ∞ lumière incident qui ne serait pas parfaitement fin (figure
F (ν) = f (t) e2πiνt dt 4.31).
−∞ L’équation (4.26) est un produit de convolution de la
39. Ce n’est pas une fonction au sens mathématique, mais une fonction y par la fonction a. C’est un objet que l’on
distribution. La nuance sera explicitée en mathématiques. retrouve fréquemment, dans les problèmes de fonction
Physique numérique, Philippe Depondt 81

ν1 0.4

ν2 0.35

0.3

0.25

0.2

0.15
A
0.1

0.05

0
−2 −1 0 1 2 3 4
Figure 4.31 – Au point A, on reçoit une superposition de
lumière de deux fréquences différentes ν1 et ν2 parce que Figure 4.32 – Gaussienne pour C = 1, x0 = 1 et σ = 0.5.
le faisceau incident n’est pas parfaitement fin. En fait, on
reçoit aussi toutes les fréquences intermédiaires ce qui fait
où x0 est l’emplacement du sommet et σ sa variance.
que le résultat est la superposition de toutes ces contribu-
C’est une courbe (figure 4.32) qui ressemble beaucoup à
tions comme dans l’équation (4.26).
la lorentzienne si ce n’est que les ≪ pieds ≫ en sont moins
large à cause de l’exponentielle qui décroı̂t plus vite que
d’appareil comme on l’a vu, mais aussi par exemple la fraction rationnelle. Si l’on en calcule la transformée de
lorsqu’un système répond avec retard à une sollicitation et Fourier dans le cas le plus simple (x0 = 0, σ = 1), l’on
que son état est le produit de convolution de la sollicitation obtient :
aux instants précédents par une ≪ fonction mémoire ≫. Z ∞ Z ∞
1 x2 1 x2

Le produit de convolution d’une fonction f par une fonc- ϕ(u) = √ e− 2 eiux dx = √ e− 2 cos ux dx
−∞ 2π π −∞
tion g se note par un astérisque :
Z ∞ parce que le sinus de la partie imaginaire de l’exponentielle
est impair et donc l’intégrale correspondante nulle. En sup-
f ∗g = f (x′ ) g(x − x′ ) dx′
−∞ posant que tous les théorèmes de convergence souhaitables
s’appliquent ici, une dérivation par rapport à u sous le
et c’est une fonction de x. Par un changement de variable, signe intégral donne :
il est facile de montrer que : Z ∞
1 x2
ϕ′ (u) = − √ x e− 2 sin ux dx
g∗f =f ∗g 2π −∞

Si l’on calcule la transformée de Fourier du produit de En intégrant cette expression par parties (par rapport à
convolution f ∗ g, on obtient : x), on a :
Z ∞ Z ∞Z ∞ h i∞ Z ∞ 
1 x2 x2
′
[f ∗ g](x′ ) eiux dx′ =
′
f (x)g(x′ − x) eiux dxdx′ ϕ′ (u) = √ e− 2 sin ux −u e− 2 cos ux dx
2π −∞ −∞
−∞ −∞ −∞
Z ∞Z ∞
soit :
= f (x)g(X) eiu(X+x) dxdX
−∞ −∞
ϕ′ (u) = −uϕ(u)
Z ∞ Z ∞
une équation différentielle qui donne :
= f (x) eiux dx g(X) eiuX dX
−∞ −∞ u2
ϕ(u) = K e− 2

soit le produit des transformées de Fourier. C’est un

théorème important : où K est une constante d’intégration qui, via l’expression
de la transformée inverse, vaut 1. Donc :
La transformée de Fourier d’un produit de convolution Z ∞
1 x2 u2
est le produit des transformées de Fourier. √ e− 2 eiux dx = e− 2 (4.27)
2π −∞
Le produit des transformées de Fourier est souvent Le résultat final est que la transformée de Fourier d’une
beaucoup plus facile à faire que le produit de convolution gaussienne est une gaussienne.
lui-même, et quand on verra l’efficacité des transformées En posant u = 0 dans l’équation (4.27), on obtient :
de Fourier rapides numériques. . . Z ∞
x2 √
e− 2 dx = 2π
4.10.1.2.5 Quelques transformées de Fourier −∞
≪ célèbres ≫. On a déjà vu que la transformée de l’intégrale de Gauss.
Fourier d’une fonction créneau donnait un sinus cardinal Des changements de variables ad hoc permettent de
et que la distribution de Dirac donnait une constante. généraliser l’équation (4.27) en une relation utile pour bien
-La gaussienne. La fonction de Gauss s’écrit : des calculs :
Z ∞ r
C (x−x0 )2
−αx2 −βx π β2
√ e− 2σ2 e dx = e 4α (4.28)
2π −∞ α
 82 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où α et β peuvent être complexes à condition que ℜe (α) >

0 : ces relations expliquent que de nombreux modèles
ondes de choc
théoriques partent de distributions gaussiennes alors qu’il
n’y a pas forcément toujours d’hypothèse physique très
convaincante pour le justifier 40 . . .
v 0000000000000000
1111111111111111
-L’oscillateur harmonique amorti. Le mouvement 0000000000000000
1111111111111111
0000000000000000
1111111111111111
1111111111111111
0000000000000000
0000000000000000
1111111111111111
0000000000000000
1111111111111111
d’un oscillateur harmonique amorti peut s’écrire :

z(t) = z0 e−iω0 t−αt si t > 0
z(t) = z0 si t ≤ 0
L
où ω0 et α sont réels. La transformée de Fourier de ceci l
donne : x
Z 0 Z ∞
z0
z0 eiωt dt + z0 ei(ω−ω0 )t−αt dt = z0 δ(ω) +
−∞ 0 α − i(ω − ω0 ) t1 t2
t

Si l’on en prend le module au carré, c’est-à-dire la densité

spectrale, on obtient : Figure 4.33 – Modélisation des ondes de chocs produites
! par un objet qui se déplace à vitesse supersonique. L’axe
2 2 2α 1/α2 horizontal supérieur donne une allure de la pression en
I(ω) = z0 δ (ω) + δ(ω) 2 +
2
α + ω02 1 + ω−ω0 fonction de la position et l’axe inférieur en fonction du
α
temps pour un auditeur immobile au sol.
soit une lorentzienne centrée en ω0 , la fréquence de l’oscil-
lateur, et de demi-largeur à mi-hauteur α, le coefficient
d’amortissement (à condition d’ignorer les Dirac sans où ℓ est une dimension caractéristique des extrémités de
grand intérêt et dues à la partie t < 0 lorsque l’oscillateur l’objet (rayon de courbure de la pointe avant par exemple).
ne bouge pas). Comme l’oscillateur amorti est un objet as- Pour simplifier, on considérera l’objet comme symétrique
sez répandu dans le monde des physiciens, cela montre que et chaque onde de choc comme gaussienne : c’est un
la lorentzienne est un objet mathématique d’usage plutôt modèle, il est fort probable que le profil des variations de
courant : c’est bien souvent le premier candidat plausible pression ne soit pas gaussien ; toutefois on peut espérer
comme modèle à ajuster à quelque expérience. . . que quelques propriétés physiques importantes puissent
être mises en évidence malgré cette simplification. La sur-
4.10.1.3 Un exemple : le bang supersonique. pression ressentie au sol et due aux ondes de choc s’écrit
alors :  
L’intérêt des transformées de Fourier par rapport aux (t−t1 )2 (t−t2 )2

séries du même nom est de pouvoir traiter des fonctions p(t) = p0 e− 2δt2 − e− 2δt2
qui ne sont pas périodiques. Bien sûr, tout ce qui est
Il s’agit de calculer maintenant la dépendance en
détonation, percussion, etc., entre dans ce cas.
fréquence car l’oreille humaine perçoit la hauteur des sons,
Ainsi, un objet qui se déplace dans l’air avec une vitesse
autrement dit leur fréquence : il s’agit donc de faire une
supersonique (un avion, par exemple) produit le fameux
transformée de Fourier en utilisant les relations ci-dessus.
double ≪ bang ≫ : il s’agit de la succession de deux on-
L’équation (4.28) permet d’écrire de façon générale,
des de choc que l’on peut être tenté de modéliser de façon
simple. Il suffit de se rappeler les vagues d’étrave d’un Z ∞ Z ∞ r
t−t 2
−( τ 0 ) iωt iωt0
2
−( τt ) iωt iωt0 π − ω2 τ 2
bateau (qui lui aussi se déplace plus vite que les ondes -les e e dt = e e e dt = e 2
e 4
−∞ −∞ τ
vagues- qu’il produit : les bateaux sont pratiquement tou-
jours supersoniques !) pour considérer que l’objet traı̂nera et, donc, la transformée de Fourier de p(t) s’écrit facile-
avec lui une onde de surpression initiée à l’avant et une ment 41 :
onde de dépression initiée à l’arrière (figure 4.33). L’audi- Z ∞ 
(t−t )2 (t−t )2
teur, immobile au sol, percevra la première à l’instant t1 p̃(ω) = p0 e − 2δt1
−e − 2δt2
eiωt dt
et la seconde à l’instant t2 avec −∞

L  r r 
∆t = t2 − t1 = iωt1 π − ω2 2δt2 iωt2 π − ω2 2δt2
v = p0 e e 4 −e e 4
2δt2 2δt2
où L est la longueur de l’avion et v sa vitesse. r
π iωt1 − ω2 δt2

La durée de chacune de ces impulsions peut s’évaluer = p0 e e 2 1 − e−iω∆t
approximativement comme : δt2
La densité spectrale correspondante s’écrit :
ℓ
δt = π −ω2 δt2
v I(ω) = p̃(ω)p̃∗ (ω) = p20 e (1 − cos ω∆t) (4.29)
40. Un peu loin de la physique, les calculs boursiers se basent en δt2
général sur des distributions ≪ normales ≫ ou gaussiennes des fluc-
La figure 4.34 montre l’allure de cette courbe. L’en-
tuations des cours, tout simplement parce que là s’appliquent des
théories d’intégration bien établies. . . alors qu’on sait très bien que veloppe gaussienne a une largeur en fréquence ∆ω =
dans bien des cas les cours de la bourse ne suivent pas des distri- 1 1
√ , soit en fréquence ∆ν = √ . La pulsation
butions de fluctuations gaussiennes : c’est un peu l’histoire du type 2δt 2π 2δt
qui cherche ses clefs sous le réverbère parce qu’au moins là, il voit
quelque chose ! 41. C’est le gros avantage des gaussiennes !
Physique numérique, Philippe Depondt 83

2
analyse en transformée de Fourier d’un phénomène somme
ν0
toute assez compliqué.
1.5

enveloppe gaussienne 4.10.1.4 Un deuxième exemple : résolution de

∆ν
l’équation de Poisson.
1

Il peut arriver que l’on ait intérêt à résoudre un

problème en passant par les transformées de Fourier plutôt
0.5
que directement.
Ainsi, l’équation de Poisson de l’électrostatique s’écrit :
0
0 5 10 15 20 25
∂2V ∂2V ∂2V ρ(x, y, z)
freq
∇2 V = + + =−
∂x2 ∂y 2 ∂z 2 ε0
Figure 4.34 – Densité spectrale du double bang, eq.(4.29).
En noir, l’enveloppe gaussienne, en bleu la courbe où ρ est une distribution de charges et V (x, y, z) le poten-
complète. Les unités sont arbitraires. tiel électrostatique associé. En général, on est confronté
au problème qui consiste à calculer V connaissant ρ. On
peut utiliser des méthodes similaires à celle décrite au
ω0 qui correspond au premier maximum de la partie paragraphe 4.5.1, mais celles-ci ont souvent l’inconvénient
périodique (cos ω∆t = −1 ⇒ ω∆t = π) est donnée par d’être assez consommatrices de ressources de calcul, au-
π 1 delà parfois de celles dont on dispose. On peut également
ω0 = ou la fréquence correspondante ν0 = .
∆t 2∆t tenter l’intégration directe :
Que signifient ces résultats ? Admettons qu’il s’agisse
d’un avion assez gros (Concorde peut-être) avec L = 100m 1
V (x, y, z) = ×
et ℓ = 0, 1m qui se déplace à peu près à la vitesse du son, 4πε0
soit v = 300m/s (ce sont des ordres de grandeurs, sans Z Z Z
∞ ∞ ∞
plus). Cela donne ∆t = 0, 3s, ν0 ∼ 1, 7Hz et ∆ν ∼ 380Hz. ρ(x′ , y ′ , z ′ )
42
p dx′ dy ′ dz ′
La gamme de fréquences auxquelles l’oreille humaine est −∞ −∞ −∞ (x − x′ )2 + (y − y ′ )2 + (z − z ′ )2
sensible s’étend de 20Hz à 20 000Hz, le La du diapason se
Si, toutefois, on discrétise l’espace par n points dans
situant à 440Hz.
chaque direction, V (x, y, z) sera représenté par n3 valeurs
L’intervalle de temps ∆t est assez long pour que les deux
qu’il faudra calculer en sommant sur n3 valeurs de ρ, soit
chocs soient perçus séparément. La largeur totale du spec-
n6 termes. . . le processus risque de se révéler laborieux si
tre présentant une intensité audible s’étend en gros jusque
n est grand !
vers 500Hz et l’écart entre les harmoniques est très faible
Une autre façon de procédre consiste à utiliser une triple
(1,7Hz) : on percevra donc deux détonations séparées as-
transformée de Fourier, ainsi, V (x, y, z) est la transformée
sez graves dont le spectre est essentiellement un continuum
de Fourier inverse de Ṽ (kx , ky , kz ) :
qui va du seuil inférieur de 20Hz 43 à quelques centaines
de Hertz. 1
Si l’on s’intéresse maintenant à une hélice superson- V (x, y, z) = 3
×
(2π)
ique 44 pour laquelle L = 0, 2m et ℓ = 1mm, on obtient
Z ∞Z ∞Z ∞
∆ν ∼ 35 000Hz et ν0 ∼ 850Hz.
Les choses deviennent alors qualitativement assez Ṽ (kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz
−∞ −∞ −∞
différentes : l’enveloppe du spectre s’étend largement au-
delà de la limite perceptible, mais la fréquence fonda- Comme Ṽ ne dépend pas de x, y et z et en supposant
mentale (850Hz) est parfaitement audible puisqu’elle est que l’on puisse dériver sous le signe somme, une dérivée
proche du La situé une octave au-dessus du diapason partielle s’écrit :
(880Hz). Ainsi, on percevra un son dont la fréquence est ∂2V 1
= ×
relativement bien définie et toutes ses harmoniques. On ∂x2 (2π)3
peut évidemment ajouter à cela le fait qu’une hélice tourne ZZZ
et donc ce signal est répété à chaque passage d’une pale Ṽ (kx , ky , kz ) × −kx2 e−i(kx x+ky y+kz z) dkx dky dkz
et le son sera donc perçu comme continu (la fréquence de
passage des pales est de l’ordre de 100Hz). avec évidemment des expressions similaires pour y et z.
Ce modèle est bien sûr simpliste et les valeurs On définit ρ̃ de la même façon :
numériques sont à prendre comme des ordres grandeur,
tout au plus, mais il montre assez bien la puissance d’une ρ(x, y, z) =
ZZZ
42. jeune et en bonne santé. . . 1
43. les fréquences plus basses que 20Hz sont également perçues par ρ̃(kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz
(2π)3
le corps humain, mais par l’intermédiaire de la cage thoracique et
non les oreilles. En appliquant l’équation de Poisson, on obtient alors :
44. pendant la deuxième guerre mondiale, alors que les moteurs
à réaction offraient des performances très médiocres au prix d’une ZZZ
consommation de carburant gargantuesque et d’une fiabilité catas- Ṽ (kx , ky , kz ) k 2 e−i(kx x+ky y+kz z) dkx dky dkz =
trophique, l’option de fabriquer des hélices supersoniques pour gag-
ner en vitesse ne paraissait pas absurde. Les ingénieurs s’aperçurent ZZZ
toutefois assez rapidement qu’ils avaient fabriqué là un dispositif très 1
efficace pour, disaient-ils, ≪ transformer de l’énergie en bruit ≫ ! ρ̃(kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz
ε0
84 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où k 2 = kx2 + ky2 + kz2 . Si on choisit Ṽ tel que : où fℓ = f (xℓ ) et Fk = ϕ(uk ). À l’utilisateur de faire les
adaptations nécessaires !
ρ̃(kx , ky , kz ) L’expression (4.30) est celle de la transformée de
Ṽ (kx , ky , kz ) =
ε0 k 2 Fourier discrète ou Discrete Fourier Transform ou encore
DFT. La transformée de Fourier discrète inverse s’écrit
alors la relation de Poisson est vérifiée. évidemment :
Cette méthode est donc de calculer la transformée de n−1
X 2πikℓ
Fourier de ρ(x, y, z) puis la transformée de Fourier in- fℓ = Fk e − n
ρ̃(kx , ky , kz ) k=0
verse de pour obtenir V (x, y, z). Le calcul du
k2
~
champ E(x, y, z) est aisé, car on obtient facilement que : 4.10.2.1 Conséquences.

~ V
~ = −grad L’approximation ci-dessus n’est pas anodine : il faut
E
donc faire un peu attention lorsqu’on utilise ces outils,
donne en transformée de Fourier : pourtant extrêmement courants et indéniablement très
utiles.
Ẽx (kx , ky , kz ) = ikx Ṽ (kx , ky , kz )
Ẽy (kx , ky , kz ) = iky Ṽ (kx , ky , kz ) 4.10.2.1.1 Périodicité. La première remarque que
l’on puisse faire est que l’on remplace en fait une trans-
Ẽz (kx , ky , kz ) = ikz Ṽ (kx , ky , kz ) formée de Fourier par une série de Fourier : autrement
dit, on postule que la fonction considérée est périodique.
ce qui est évidemment très aisé à calculer.
On risque bien sûr de rencontrer quelques difficultés 1
quand k = 0, mais il suffit de noter que : 0.9
ZZZ 0.8
Ṽ (k = 0) = V (x, y, z) dx dy dz 0.7
0.6
pour voir que le choix de la valeur de Ṽ (k = 0) n’est qu’un 0.5
choix de la constante arbitraire du potentiel : Ṽ (k = 0) = 0.4
0 peut être une bonne option.
0.3
La méthode peut paraı̂tre assez lourde, mais en fait, la
0.2
grande rapidité des transformées de Fourier numériques
0.1
permet de résoudre ainsi bien des problèmes qui n’au-
raient pas de solution sinon. Il faut cependant maintenant 0
0 1 2 3 4 5 6 7 8 9
se préoccuper de ce que font réellement les transformées
de Fourier numériques proposées dans les bibliothèques de Figure 4.35 – Une gaussienne ≪ périodique ≫ et mal
calcul car il s’agit bien sûr d’approximations et cela peut coupée !
avoir des conséquences, parfois imprévues.
En principe, ce n’est pas bien grave parce qu’on peut
4.10.2 La transformée de Fourier discrète. choisir une très grande période, ≪ infinie ≫ en pratique
par rapport aux dimensions ce que l’on veut étudier :
Il existe des méthodes numériques très efficaces pour c’est d’ailleurs généralement ce que l’on fait. Toutefois,
calculer des transformées de Fourier ; elle reposent toutes il y a parfois des choix maladroits : par exemple, si l’on
cependant sur une même approximation : veut calculer la transformée de Fourier d’une gaussienne
Z n−1
centrée en zéro, on sait que la partie imaginaire doit être
∞ X
f (x) eiux dx ∼ f (xℓ ) eiuxℓ δx nulle puisque la gaussienne est paire ; or, si par malheur,
−∞ ℓ=0
on a choisit pour faire le calcul, l’intervalle [0, X], X > 0
et grand par rapport à la variance, on est en train de
avec : couper en deux la gaussienne à son maximum en x = 0 et
xℓ = xmin + ℓ δx à l’autre extrémité de l’intervalle, la valeur de la gaussi-
et enne sera presque nulle (figure 4.35). Mais, en x = X,
xmax − xmin subitement à cause de la périodicité, la fonction retrouvera
δx =
n une valeur non négligeable : une variation rapide qui don-
ainsi, x0 = xmin et xn−1 = xmax − δx , on est dans la nera des contributions de haute fréquence. De plus, notre
même situation que celle de l’intégration par la méthode fonction n’est plus paire : la partie imaginaire n’a plus de
des rectangles. raison d’être nulle ! Un intervalle [−X, X] serait plus judi-
On remplace donc l’intégrale de −∞ à ∞ par une série cieux. . . On peut certes tenter d’être habile, mais alors, il
discrète sur un échantillonnage de points pris sur un in- faut être sûr de soi : on peut garder l’intervalle [0, X] (et
tervalle borné. donc diviser par deux le nombre de points nécessaires), et
En fait pour des raisons de généralité des programmes, forcer la partie imaginaire à zéro. On perdra alors toutefois
on se borne à calculer la série : une possibilité de détecter des erreurs !
n−1
X
Fk = fℓ e
2πikℓ
n (4.30) 4.10.2.1.2 Pas de calcul. La discrétisation de
ℓ=0
l’équation (4.30) a aussi des conséquences. Pour faire la
Physique numérique, Philippe Depondt 85

correspondance entre l’intégrale et la somme discrète, on 4.10.2.1.3 Une ≪ fausse ≫ symétrie. Calculons le
doit faire l’égalité : terme Fn−k de la DFT, c’est-à-dire le symétrique de Fk
2πikℓ
par rapport au milieu de l’intervalle :
eiuk xℓ = e n

n−1
X n−1
X
2πiℓ(n−k) 2πiℓk
sachant que : Fn−k = fℓ e n = fℓ e2πiℓ e− n

xℓ = xmin + ℓ δx ℓ=0 ℓ=0

et en posant : or e2πiℓ = 1, et donc :

uk = umin + k δu
n−1
X
soit : 2πiℓk
Fn−k = fℓ e− n = F−k
2πikℓ
ei(umin +k δu )(xmin +ℓδx ) = e n ℓ=0
2πikℓ
ei(umin xmin +umin ℓδx +xmin k δu ) eikℓδx δu = e n ce qui est cohérent avec la périodicité mais si la suite fℓ
est réelle, ce qui arrive très souvent, on obtient :
Une chose au moins paraı̂t claire : ça ne marche pas ! On
doit donc supprimer xmin et umin . Fn−k = Fk∗
Ainsi, la DFT postule que l’intervalle commence en zéro.
Il faut donc utiliser la propriété que la transformée de et pour le spectre,
Fourier de f (x − x0 ) est ϕ(u) eiux0 : si l’on ne s’intéresse ∗
pas à la phase, c’est sans importance, mais dans le cas In−k = Fn−k Fn−k = Ik
contraire, il faut y penser.
seule la première moitié des points est utile : c’est à ne
La correspondance entre intégrale et somme discrète se
pas oublier lorsque l’on voudra déterminer l’intervalle de
ramène donc maintenant à :
définition de f . . .
2πikℓ
eikℓδx δu = e n
4.10.2.2 Fast fourier Transform = FFT.
soit :
2π Quand on veut calculer une transformée de Fourier
δu =
n δx numérique, il y a une chose à ne pas faire : c’est program-
or n δx est la longueur de l’intervalle choisi. mer directement l’équation (4.30) ! Cela revient à calculer
Ainsi, la résolution, c’est-à-dire l’intervalle de fréquence un grand nombre d’exponentielles complexes inutilement.
le plus petit que l’on puisse atteindre, de la transformée de Certes, quand le nombre de points dans l’échantillonnage
Fourier est (à 2π près) l’inverse de la longueur de l’inter- est réduit, il peut parfois être plus rapide de programmer
valle. rapidement une telle ≪ Slow Fourier Transform ≫ que de
Inversement n δu est la longueur de l’intervalle dans l’es- passer du temps à essayer de comprendre les documenta-
pace de la tranformée de Fourier et l’on obtient : tions des bibliothèques de programmes, hélas, pas toujours
limpides. Cependant, la transformée de Fourier est d’un
2π usage tellement courant en physique que, généralement,
n δu =
δx on a déjà utilisé une FFT de bibliothèque et que l’on a
Ainsi, la longueur de l’intervalle dans l’espace de la déjà déchiffré la documentation correspondante, et donc
transformée de Fourier est l’inverse du pas dans l’espace il devient aussi aisé de l’utiliser que de reprogrammer soi-
direct. même quelque chose, si simple cela soit-il !
Ces deux théorèmes qui ont l’air, il est vrai, trivi- Toutefois, l’argument massif est que l’algorithme FFT
aux, sont très importants car c’est ainsi que l’on choisit est très efficace dès que le nombre de points con-
l’intervalle d’intégration en fonction, par exemple, de sidéré devient important, et l’on a vu que des questions
la résolution fréquentielle voulue ou de l’intervalle de d’échantillonnage de fréquences pouvaient imposer de tra-
fréquences désiré. Ainsi, si l’on s’intéresse à un système vailler avec beaucoup de points.
d’oscillateurs pour lesquels les phénomènes intéressants Une première remarque est que l’équation (4.30) peut
se produisent aux environs de 10Hz, on peut vouloir un se reécrire :
intervalle de fréquences qui va de 0 à 20Hz : cela signi- n−1
X 2πi
fie que le pas de temps doit être obligatoirement de l’or- Fk = fℓ wnkℓ , si : wn = e n
dre de 1/20=0,05s (ici, l’on raisonne en temps-fréquence, ℓ=0
donc le facteur 2π disparaı̂t). De plus, si l’on veut pouvoir
distinguer des phénomènes dont les fréquences diffèrent Découpons la somme ci-dessus en deux moitiés, l’une com-
de 0,1Hz, cela entraı̂ne que la longueur de l’intervalle de prenant les termes pairs et l’autre les termes impairs :
temps est au minimum de 1/0,1=10s. Donc, n, le nombre (n−1)/2 (n−1)/2
de pas est égal, au minimum à 10s/0,05s = 200. Quitte X X
Fk = f2ℓ wn2kℓ + f2ℓ+1 wnk(2ℓ+1)
à se répéter, ces relations très simples entre pas de temps ℓ=0 ℓ=1
et fréquence sont fondamentales dès que l’on faire un us- (n−1)/2 (n−1)/2
age pratique de cet outil, en particulier, quand (comme X X
kℓ
= f2ℓ wn/2 + wnk kℓ
f2ℓ+1 wn/2
expérimentateur, par exemple) on a affaire au monde réel
ℓ=0 ℓ=1
qui a pour défaut principal que l’on ne peut pas considérer
toutes les constantes comme valant 1 (m = e = c = h̄ = On peut rediviser l’intervalle en deux et ainsi de suite : à
kB = 1) ! terme, l’on n’aura plus à calculer que des termes du type
86 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

w2kp . Reste à faire un tri pour repérer quels termes fℓ inter-
viennent dans quelle somme. . . toujours est-il qu’il s’agit
d’un processus dont le coût est proportionnel à n ln2 n
opérations au lieu de n2 . La différence peut être énorme : si
par exemple n = 210 = 1024, ce qui n’a rien d’exeptionnel,
alors n2 = 1 048 576 mais, n ln2 n = 1024 × 10 = 10240 :
un gain d’un facteur 100 !
Certes, il y a la restriction que n doit être une puissance
de deux, et un bon nombre de sous-programmes courants
l’exige, mais, 1o il est bien rare que l’on ne puisse pas en
tenir compte a priori dans la préparation des données ini-
tiales et 2o on peut toujours compléter si nécessaire l’in-
tervalle avec des zéros ! Il existe des programmes qui, au
lieu de découper l’intervalle en moitiés, commencent par
faire une décomposition de n en produit de nombres pre-
miers, puis effectuent les découpages à partir de là : cela
permet d’utiliser autre chose que des puissances de deux,
mais il est clair que si n lui-même est un nombre premier,
l’efficacité en sera plus que douteuse. . .
4.10.3 Filtrage de données expérimen-
tales.
Dans le paragraphe 4.8.5 décrivant une méthode de lis-
sage de données expérimentales, la conclusion était que
c’était sans doute une méthode assez peu recommend-
able. Une autre approche est de faire un filtre passe-bas
numérique.
Il s’agit de supprimer ou, du moins, de réduire le bruit
considéré comme un signal non-corrélé d’un point à un
autre : autrement dit, il s’agit de retirer ou de réduire
une contribution de haute fréquence. Ainsi, une première
idée est de faire une transformée de Fourier des données
expérimentales, puis fixer les termes de haute fréquence à
zéro, puis faire une transformée de Fourier inverse : on aura
donc ainsi purement et simplement supprimé les hautes
fréquences !
1 soumis au hasard comme ci-dessus, mais sans mémoire : le
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0 2 4 6 8 10
La remarque faite précédemment (§ 4.8.5) selon laque-
lle il vaut mieux faire l’ajustement d’un modèle sur les
données bruitées puis étudier les écarts qu’essayer ≪ d’em-
bellir ≫ les expériences en enlevant le bruit reste per-
tinente. Le filtrage proposé ici est toutefois sans doute
meilleur que la méthode proposée précédemment car on
peut contrôler précisément ce que l’on supprime, bien
mieux qu’avant en tous cas. Il faut reconnaı̂tre qu’il est
parfois utile, lors de phases intermédiaires, lors du réglage
d’une expérience, ou bien avant que l’on sache réellement
où l’on en est au point de vue modèle, de nettoyer ainsi
les données expérimentales afin de déterminer ≪ s’il y a
quelque chose à voir ≫. . . La règle générale est toutefois
que ces méthodes restent en principe à éviter quand on en
arrive à l’étape ultime de publication : le minimum est de
le signaler clairement quand on le fait.
4.11 Les méthodes de Monte-
Carlo.
On regroupe sous le nom de méthodes de ≪ Monte-
Carlo ≫ (à cause du célèbre casino) les méthodes qui re-
posent sur des tirages au sort : vaste monde dont nous
n’explorerons ici que quelques régions frontalières.
4.11.1 Processus stochastiques et chaı̂nes
de Markov.
On appelle ≪ stochastique ≫ (du grec stokhastês, devin)
un processus dont le résultat est soumis au hasard : quand
on lance un dé, on ne peut pas - en principe - prédire le
nombre qui en sortira. En revanche, le mouvement d’un
satellite autour de la terre n’est pas stochastique, puisque,
connaissant sa position et sa vitesse à un instant donné,
on peut prédire sa trajectoire dans le futur.
Une chaı̂ne de Markov est une séquence d’événements
dé ne se rappelle pas le nombre sorti lors du jet précédent,
ce n’est pas parce que j’ai obtenu un six au coup précédent
que je peux dire quoi que ce soit sur le résultat du coup
suivant (si le dé se rappelait le six et interdisait par ex-
emple d’obtenir deux fois de suite le même résultat, le
processus serait stochastique mais non-Markovien).
En physique, il y a bien sûr des processus imprévisibles
(les trajectoires individuelles de chaque atome d’un gaz en
thermodynamique statistique, par exemple) mais on peut
aussi avoir intérêt à utiliser des méthodes de tirage au sort
pour calculer des grandeurs qui n’ont rien d’aléatoire.

Figure 4.36 – La fonction 12 (1−tanh ν−ν 4.11.2 Les vicissitudes de π.

γ ) avec ν0 = 5 et
0

γ = 1 que l’on peut utiliser pour faire un filtre passe-bas. Le chapitre ≪ Nombres aléatoires ≫ des Numerical
Recipes (ref. [3]) commence par la remarque (p. 266) :
La méthode, si elle est souvent employée avec succés, ≪ Il peut paraı̂tre pervers d’utiliser un ordinateur, la
peut être considérée comme un peu brutale. Une autre plus précise et la plus déterministe de toutes les ma-
possibilité est alors de multiplier la transformée de Fourier chines conçues par l’esprit humain pour produire des nom-
par un fonction qui vaille 1 à basse fréquence et zéro à bres “aléatoires”. ≫ En effet, mais nous nous garderons
haute. Le choix est au goût de chacun : un bon candidat d’affirmer que la perversité n’a jamais fait reculer un
est cependant 21 (1 − tanh ν−ν γ ) où ν0 est le seuil et γ la mathématicien appliqué. . . Toujours est-il que bien avant
0

largeur du domaine où la fonction de filtrage décroı̂t (figure

4.36) 45 . la recette de la pâte feuilletée vue par Fernand Raynaud ; en partic-
ulier, le choix de γ, ici, paraı̂t être de l’ordre de la fameuse ≪ chaleur
45. Il est vrai que, parfois, les méthodes numériques font penser à patissière ≫ indispensable à la réussite de ladite recette !
Physique numérique, Philippe Depondt 87

l’invention des ordinateurs, au XVIIIe siècle, Georges Un ordinateur produit des séquences de nombres arbi-
Louis Leclerc comte de Buffon, un individu par ailleurs traires dont on espère qu’ils sont non-corrélés au problème
honorablement connu, calcula que, si on lance au hasard que l’on souhaite résoudre. C’est que l’on appelle sou-
une aiguille de longueur ℓ sur un réseau de droites par- vent des ≪ nombres pseudo-aléatoires ≫. Pour illustrer
allèles distantes d’une distance a, la probabilité que l’aigu-
ceci, imaginons qu’un touriste un peu obsessionnel décide
ille rencontre une droite s’écrit : de visiter les musées parisiens par ordre alphabétique :
c’est un ordre parfaitement déterminé, et si l’on recom-
2ℓ mence un peu plus tard, en appliquant la même règle,
p=
aπ l’ordre sera strictement le même 47 . Cependant, si l’on
une méthode probabiliste de détermination expérimentale s’intéresse aux thématiques de ces musées, on tombera sur
du nombre π. En effet, plusieurs tentatives de ce genre une séquence du type : Musée de l’Arc de Triomphe, Musée
eurent lieu au XIXe siècle malgré le caractère quelque peu des Armées, Musées des Arts Africains et Océaniens, etc. :
fastidieux de l’opération consistant à lancer un grand nom- une séquence complètement arbitraire et qui peut être
bre de fois une aiguille et à compter le nombre de fois considérée pratiquement comme. . . aléatoire car les arts
qu’elle recontre une droite 46 . africains et océaniens n’ont pas grand-chose à voir avec
les armées 48 . Bien sûr, l’ordre alphabétique introduit des
4 corrélations parasites : tous les Musées des Arts xxx se
suivent ! Ce sont des choses dont il faudra se méfier aussi
3.8
dans l’usage de générateurs de nombres ≪ aléatoires ≫ des
3.6 ordinateurs.
Comment cela fonctionne-t-il ? Un générateur de nom-
3.4 bres pseudo-aléatoires produit une séquence de nombres
3.2
entiers I1 , I2 , I3 ,. . ., compris entre 0 et m − 1 par la
réccurence :
3
Ij+1 = aIj + b, modulo m
2.8

2.6
où m est un nombre entier ≪ grand ≫ et a et b des entiers
1 10 100 1000 10000 100000 1e+06
positifs appelés ≪ multiplicateur ≫ et ≪ incrément ≫.
A priori, cette séquence se répète puisqu’il n’y a que m
Figure 4.37 – Calcul du nombre π par tirage au sort. valeurs possibles pour les I , ainsi, si l’on a plus que m
j
En abscisse le nombre de tirages en échelle logarithmique. tirages, on doit retomber sur les mêmes nombres : c’est
En ordonnée, les estimations de π correspondantes. Le un système périodique. On note qu’il faut initialiser la
résultat obtenu pour un million de tirages est 3,1428721 séquence avec une ≪ graine ≫ I0 49 . Finalement, si l’on
I
fait le rapport mj on obtiendra une séquence de nombres
Plus simplement encore, on peut remarquer que comme réels dans l’intervalle [0, 1[.
le rapport des surfaces d’un carré de côté a et d’un cercle On a clairement intérêt à choisir m aussi grand que pos-
de rayon a2 vaut π4 , on peut lancer des flèches, cailloux ou sible, soit, compte tenu de la représentation des nombres
tout autre projectile et compter le nombre de fois où le entiers sur quatre octets : m = 231 − 1 = 2 147 483 647.
projectile tombe dans le cercle et le diviser par le nombre Le choix de a et b (par exemple a = 75 = 16 807 et
total de tirs. Cela donne des estimations successives de b = 0) fait l’objet de débats infinis et dépend parfois de
π
4 (figure 4.37). Evidemment, plus les tirs sont nombreux, la machine utilisée. Dans la grande majorité des cas, on a
meilleure est l’estimation. intérêt à se servir du générateur fourni avec l’ordinateur
Même si l’on peut imaginer d’autres méthodes plus que l’on utilise plutôt que de tenter d’écrire quelque chose
économiques pour déterminer π, ces remarques montrent soi-même : il se trouve que le langage fortran fourni une
que l’on peut tenter de résoudre des problèmes qui ne fonction intrinsèque rand() 50 qui en général donne satis-
comportent a priori aucun caractère aléatoire à l’aide faction. Si la variable x est déclarée en real, l’instruction x
de méthodes probabilistes. On notera que pour que les = rand() donnera un nombre pseudo-aléatoire. Si l’on fait
théorèmes probabilistes, comme la limite centrale, puis- plusieurs tirages, on obtiendra une séquence de nombres
sent s’appliquer, il faut un grand nombre de tirages au sort, compris entre 0 et 1 avec une distribution uniforme (figure
comme dans la figure 4.37, et que donc la capacité des or- 4.38). Il existe aussi le sous-programme random number :
dinateurs à répéter de nombreuses fois la même opération call random number(x) remplira le tableau x de nombres
sans se lasser n’est pas à négliger. pseudo-aléatoires.
Le problème de la graine est un peu plus délicat : si
4.11.3 La production de nombres on ne la fixe pas, la séquence de nombre produits par
≪ aléatoires ≫.
rand() sera la même d’un usage à l’autre : si on arrête
l’exécution du programme, l’ordinateur ≪ oublie ≫ où
Mais comment une machine déterministe comme un or- il en était et si l’on relance l’exécution, il repart au
dinateur peut-elle produire des nombres aléatoires ?
47. À condition, évidemment, que la liste des musées n’ait pas
En fait, un ordinateur est incapable de produire des changé entre-temps.
nombres aléatoires et donc il n’en produit pas. . . 48. Sauf, bien sûr, si l’on se rappelle qu’il s’agit de l’ancien Musée
des Colonies, héritage des conquêtes militaires du XIXe siècle.
46. Ainsi, l’expérience faite en 1901 par Lazzerini, en jetant une 49. seed en anglais.
aiguille 3407 fois, donna : π = 3,1415929 (au lieu de 3,14159265). 50. pour random.
88 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

1
0.9 ?
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
60
0 seed=1
0 10 20 30 40 50 60 70 80 90 100 seed=2
50 seed=3
1.03
40

1.02 30

20
1.01
10

0
1
−10

0.99 −20

−30
0.98 0 500 1000 1500 2000 2500 3000 3500 4000 4500 5000

0.97 Figure 4.39 – Marche au hasard ou drunkard’s walk

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 (marche de l’ivrogne) avec trois graines différentes.
Figure 4.38 – En haut, une séquence de 100 nom-
bres pseudo-aléatoires et en bas, distribution des valeurs d’autres beaucoup moins : cet avertissement ne se veut pas
fournies par la même fonction intrinsèque rand() après dissuasif, comme les précédents, il vise à rappeler au min-
1 000 000 de tirages : on obtient une distribution uniforme. imum de prudence !

4.11.4 Obtenir une distribution autre

premier point et refait la même séquence. Dans cer-
tains cas, cela n’a aucune espèce d’importance, mais si, qu’uniforme.
par exemple, on veut comparer des moyennes effectuées Dans le paragraphe précédent, il a été montré comment
sur des échantillonnages différents, alors évidemment, il obtenir une séquence de nombres pseudo-aléatoires avec
vaut mieux pouvoir changer d’échantillonnage. Le sous- une distribution uniforme entre 0 et un, c’est à dire des
programme srand(i) 51 où i est un entier permet de le nombres qui ont une probabilité p0 (x)dx d’apparaı̂tre en-
faire : il suffit d’une instruction call srand(i) avant le tre x et x + dx qui s’écrit :
premier appel à rand(). Quelle valeur donner à i ? Soit 
l’on veut en garder la maı̂trise, alors, il faut prévoir de lire dx si 0 ≤ x < 1
p0 (x)dx =
au clavier la valeur de i, soit, on peut choisir la fonction 0 sinon
time qui donne l’heure sous forme d’un nombre entier : ce qui respecte la condition de normalisation :
call srand(time()) donnera. . . n’importe quoi, ce qui Z ∞
est ce qu’on voulait ! p0 (x) dx = 1
La figure 4.39 montre une marche au hasard : un ivrogne −∞
a une probabilité égale de faire un pas à gauche ou à droite Mais si l’on veut autre chose qu’une telle distribution uni-
de longueur quelconque, en-dessous d’une certaine valeur forme ? Soit une fonction y(x). On produit des nombres qui
(liée à la longueur des jambes dudit ivrogne). Ainsi, à ont une probabilité p0 (x)dx de tomber entre x et x + dx.
chaque pas, on doit ajouter à la position actuelle un nom- Si on leur fait subir la transformation y(x), on obtient
bre (pseudo)aléatoire compris entre −0, 5 et 0, 5 (c’est-à- une deuxième séquence de nombres dont la probabilité de
dire x = x + rand()-0.5). Trois graines différentes don- tomber entre y et y + dy est p(y)dy, mais c’est aussi celle
nent trois trajectoires différentes. Ce type de simulation de tomber entre x et x + dx pour la première séquence,
peut concerner, outre les errances 52 éthyliques, le mouve- soit :
ment brownien ou le cours d’une action en bourse ! |p(y)dy| = |p0 (x)dx|
Il faut donc retenir de tout ceci que l’ordinateur ne
Comme une densité de probabilité est positive, cela donne,
produit pas de nombres aléatoires et qu’il est bon de
se méfier un peu : faire le même calcul avec plusieurs dx
p(y) = p0 (x)
graines différentes, essayer plusieurs générateurs différents dy
si possible, voire utiliser des machines d’architectures
Sachant que p0 (x) vaut un, le problème est donc con-
différentes. . . Certains algorithmes sont très sensibles aux
naissant p(y), la distribution voulue, trouver la fonction y
imperfections des séquences de nombres pseudo-aléatoires,
telle que :
51. le s de srand est pour seed, évidemment. . . dx
52. sinon les errements. . . p(y) =
dy
Physique numérique, Philippe Depondt 89

donc, y(x) est la fonction réciproque d’une primitive de se généralise sans difficulté à des intégrales multidimen-
p(y). sionnelles du type :
Par exemple, si l’on voulait p(y) = e−y , alors, y(x) =
− ln x ; ou encore une distribution lorentzienne p(y) = Z b1 Z b2 Z bn
1 1
, cela donne y = tan πx (exercice : le vérifier). ... f (x1 , x2 , . . . , xn ) dxn . . . dx2 dx1
π 1 + y2 a1 a2 an
Malheureusement, ce n’est pas toujours aussi simple.
Si, par exemple, on veut une distribution gaussienne (ou
normale) : Ce type d’intégrale correspond en fait à des domaines
1 y2 d’intégration de géométrie simple (rectangle à deux dimen-
p(y) = √ e− 2 sions, parallélépipède à trois dimensions, etc.) ; on peut
2π
dans une certaine mesure, par des changements de vari-
le calcul de la fonction réciproque de la primitive n’a rien
ables appropriés (coordonnées cylindriques ou sphériques)
d’évident. . . En fait les choses s’arrangent si l’on passe en
adapter l’intégration à d’autres géométries. Il y a toutefois
coordonnées polaires à deux dimensions en pensant à la
des limites.
distribution de Maxwell-Boltzman :
v2
P (v) = v e− 2

avec
P (vx , vy ) dvx dvy = P (v) dv dϕ
Donc, si l’on fait deux tirages au sort√ avec ϕ ∈ [0, 2π[
avec une distribution uniforme et v = −2 ln x et x avec
également une distribution uniforme comprise entre 0 et
1, on obtient deux nombres aléatoires (vx = v cos ϕ et
vy = v sin ϕ) avec une distribution gaussienne : la figure
4.40 en est une illustration. Un exemple de subroutine
très simple capable de produire de tels nombres est donné
ci-dessous :
subroutine gauss_d(x1,x2)
implicit none
real :: x1, x2, v, phi, tpi = 6.28318531
v = sqrt(-2.*log(rand()))
phi = tpi*rand()
x1 = v*cos(phi) ; x2 = v*sin(phi)
end Figure 4.41 – Un domaine d’intégration un peu com-
pliqué. . .
0.45
Generated distribution
Normal distribution
0.4

0.35 Imaginons, par exemple, que l’on veuille calculer la fig-

0.3 ure d’interférences donnée par deux fentes d’Young, mais
0.25 la source lumineuse, au lieu d’être ponctuelle, est un fila-
p(x)

0.2 ment d’ampoule électrique épais, torsadé et courbé (figure

0.15
4.41), ou, pire, une galaxie vue à travers un télescope :
comme la source est incohérente, il faut donc intégrer les
0.1
intensités lumineuses issues de chaque point de la source.
0.05
Le domaine d’intégration est donc la source : il n’y a guère
0
−4 −2 0 2 4 d’habile changement de variable qui saute aux yeux !
x
Il existe une première solution qui consiste à intégrer sur
Figure 4.40 – Comparaison d’une distribution obtenue un volume de géométrie simple qui englobe la source, en
par l’algorithme donné dans le texte et d’une distribu- fixant la valeur de l’intensité lumineuse à zéro en dehors
1 x2 de la source.
tion gaussienne √ e− 2 . Le calcul a été fait avec 20000
2π L’autre solution consiste à tirer au sort des points dans
tirages au sort.
ce volume (figure 4.42), d’ignorer les points qui sont en
dehors de la source et de ne compter que ceux qui sont sur
C’est, certes, de l’ordre de la recette de cuisine et c’est
la source. Cette deuxième solution, si elle peut paraı̂tre
bien pour cela qu’il existe des ouvrages spécialisés et des
un peu absurde, a au moins deux mérites : 1o elle est
bibliothèques de programmes tous faits !
simple à mettre en œuvre, et 2o elle permet de tracer le
graphe du résultat en fonction du nombre de tirages au
4.11.5 Intégration multidimensionnelle sort, de sorte que lorsque le résultat ne fluctue que d’une
sur des domaines compliqués. valeur inférieure à un certain seuil, on peut considérer que
l’intégrale est calculée avec cette précision (c’est un peu
4.11.5.1 Principes
comme sur la figure 4.37 où l’on peut considérer que π
Au chapitre 4.3.2, on a vu des méthodes d’intégrations est calculé à partir du moment où les fluctuations sont
à une dimension comme la méthode des trapèzes. Celle-ci inférieures à la précision souhaitée).
90 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

quantité sin(xy) à toutes celles déjà obtenues. Il faut alors

normaliser le résultat en multipliant cette somme S par
VD
où VD est le volume (ici, avec deux variables seule-
nc
ment, c’est en fait une surface) de D et nc est le nombre
de ≪ coups au but ≫ c’est-à-dire le nombre de fois où l’on
est tombé dans D. Que vaut alors VD ? Il suffit de repren-
d
dre le raisonnement utilisé pour calculer π par le rapport
de la surface du cercle à celle du carré : c’est le volume
total Vt dans lequel on a fait des tirages multiplié par la
proportion de coups au but :
nc
VD = Vt
nt
où nt est le nombre total de tirages. Ainsi, en fin de
compte,
Vt
d ID = S
nt
Le programme qui fait cela est extrêmement simple :
Figure 4.42 – Si l’on veut calculer l’intégrale d’une fonc- program integr
tion dans un espace compliqué, on peut englober cet es- implicit none
pace dans un (hyper)cube, ici un carré d × d, tirer au sort real :: x, y, s
des points dans ce carré, c’est-à-dire, pour chaque point, integer :: i, imax = 100000000, n
tirer deux nombres compris entre 0 et d et n’ajouter la s = 0. ; n = 0
valeur de la fonction en ce point que s’il se trouve dans open(10,file=’integr_sin.out’)
l’espace d’intégration. Sinon, on l’ignore et on fait un nou- do i = 1, imax
veau tirage. x = 4*(rand()-0.5) ; y = 4*(rand()-0.5) ! [-2,2]
if ( 4*tanh(x-y)*exp(-(x**2 + y**2)) > 0.4 ) &
s = s + sin(x*y)
4.11.5.2 Tentative ≪ naı̈ve .
≫ if ( mod(i,5000) == 0 ) write(10,*) i, 16*s/i
enddo
Prenons un autre exemple : on veut calculer, write(*,*) 16*s/imax
Z end
ID = sin(xy) dx dy Ça donne -8.9420289E-02 pour 108 tirages et quelques
D
secondes de calcul. Le résultat en fonction du nombre de
où D est le domaine d’intégration. Si tirages est representé sur la figure 4.44. Les huit chiffres

D = {(x, y), tels que x2 + y 2 < π} -0.0885

-0.08875

c’est facile : ID = 0 ; mais si (figure 4.43) -0.089

-0.08925
2
+y 2 )
D = {(x, y), tels que 4 tanh(x − y) e−(x > 0.4} -0.0895

-0.08975
(4.31)
-0.09
c’est nettement plus compliqué ! Il suffit toutefois de tirer -0.09025

-0.0905
2 1 -0.09075

1.5 0.8 -0.091

0.6 -0.09125

1 0.4 -0.0915
0.2 -0.09175
0.5 0.0 -0.092

0 −0.2
100000 1e+06 1e+07 1e+08

−0.4 n_t

−0.5−0.6
−0.8 Figure 4.44 – Valeurs obtenues pour ID avec le domaine
−1 −1 (4.31) en fonction du nombre de tirages (l’axe des x a une
échelle logarithmique).
−1.5
−2 ≪ significatifs ≫ du résultat ci-dessus ne sont évidemment
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2 pas tous significatifs ! On constate aisément sur la figure
qu’avec tous ces tirages, on en a au plus 3, soit ID ≃
Figure 4.43 – Le domaine d’intégration D défini par −0.0894. . . Peut-on être plus efficace ?
l’équation (4.31) est délimité par la courbe continue
rouge. . .
4.11.5.3 Marche au hasard dans D
au sort des nombres x et y dans l’intervalle [−2, 2], et, si la Dans le calcul précédent, on a tiré au sort des nombres
condition de l’équation (4.31) est vérifiée, additionner la dans un domaine plus grand que le domaine d’intégration
Physique numérique, Philippe Depondt 91

D et on a simplement éliminé tous les tirages qui tombaient
en-dehors de D. On est en droit de se dire que c’est ineffi-
cace et qu’il vaudrait mieux tenter de ne tirer des nombres
que dans le bon domaine : c’est en toute rigueur impossi-
ble, mais, si, partant d’un point choisi dans D (par exem-
ple (0.5, −0.5) dans la figure 4.43), au lieu de tirer d’autres
nombres de façon indépendante, on se borne à se déplacer
au hasard dans le domaine, soit tirer au sort, non pas un
point, mais un petit déplacement (dx, dy), quitte à rejet-
ter les déplacements qui font sortir du domaine, on devrait
passer l’essentiel du temps (ou plutôt des tirages au sort)
dans le bon domaine.
Ainsi, on peut commencer par fixer un point de départ
dans D :
x0 = 0.5 ; y0 = -0.5 dans l’exemple ci-dessus, puis
calculer des déplacements −δx < dx < δx et −δy < dy <
δy :
dx = 2*delta_x*(rand()-0.5)
dy = 2*delta_y*(rand()-0.5)
et ajouter cela aux anciennes valeurs de x et y. Si le nou-
veau point obtenu est dans D le déplacement est conservé,
sinon, il est rejetté (c’est-à-dire que l’on revient à la po-
sition précédente). Dans tous les cas (voir une discussion
détaillée de ce point dans la réf. [21]), on ajoute la valeur
de la fonction à la somme que l’on aura déjà initiée.
En divisant cette somme par le nombre de tirages, on ob-
tient la valeur moyenne de la fonction dans le domaine : il
≪ suffit ≫ de multiplier par le volume du domaine VD pour
4.11.5.4 Échantillonnage par l’importance (im-
portance sampling )
Pourrait-on, pour ainsi dire, ≪ guider ≫ le hasard ? Il
faudrait pouvoir ≪ dire ≫ au hasard quand ça vaut le coup
de faire le calcul, car calculer l’intégrale d’une fonction en
sommant au hasard partout, y compris là où elle est nulle
ou presque n’a pas grand intérêt. Autrement dit, il serait
peut-être habile d’utiliser des tirages au sort, non pas avec
des distributions uniformes comme jusqu’à présent, mais
avec des distributions qui favorisent les endroits où la fonc-
tion a des contributions non négligeables. Formellement,
cela donne, avec l’exemple du calcul ≪ naı̈f ≫ ci-dessus (§
4.11.5.2) :
Z Z
sin(xy)
ID = sin(xy) dx dy = p(x, y) dx dy
D D p(x, y)
où p(x, y) est une densité de probabilité choisie de façon
à avoir des valeurs plus importantes là où la fonction a
elle-même des valeurs plus importantes.On sommera alors
sin(xy)
les valeurs prises par , où maintenant x et y sont
p(x, y)
choisis avec la densité de probabilité p(x, y). On pourrait
évidemment choisir comme distribution la fonction elle-
même, toutefois produire des nombres aléatoires avec une
distribution de probabilité sin(xy) comme ici n’est peut-
être pas si facile que cela. Une approximation de la fonc-
tion peut suffire : ici, il suffit de poser,

obtenir le résultat. Si on connait ce volume, c’est en effet p(x, y) ∝ |xy|

assez facile, sinon, par exemple dans le cas de l’équation
(4.31), il faut le calculer. . . par une méthode Monte-Carlo !
C’est ce qui est fait fig. 4.45 et l’on obtient des résultats
assez similaires à ce qu’on avait précédemment.
-0.088
-0.0882
-0.0884
puisqu’une approximation de sin(xy) quand x et y ne
sont pas trop grands est xy (on prend la valeur absolue,
puisqu’une densité de probabilité est toujours positive).
En utilisant la méthode du § 4.11.4, supposons que l’on
tire au sort des nombres X et Y avec des distributions
uniformes, on a alors
p(x, y) dx dy = dX dY

-0.0886
soit, en séparant
-0.0888
x dx = dX et y dy = dY
-0.089

-0.0892
et √ √
x= 2X y= 2Y
-0.0894

-0.0896
où l’on a oublié les problèmes de signe. . . On peut s’ar-
ranger pour que X et Y soient dans l’intervalle [−1, 1] et
-0.0898 remultiplier par le coefficient qui va bien pour que x et
-0.09 y soient dans l’intervalle [−2, 2] comme auparavant. C’est
1e+07 2e+07 4e+07 8e+07
n
plus simple que ça en a l’air :
program importance
Figure 4.45 – Valeurs obtenues pour ID avec le domaine implicit none
(4.31) en fonction du nombre de tirages (l’axe des x a une double precision :: x, y, xx, yy, s, z
échelle logarithmique) comme dans la figure 4.44, mais integer :: i, imax = 10000000
cette fois-ci par une marche au hasard dans le domaine
d’intégration D. s = 0. ; n = 0
open(10,file=’import_sampling.out’)
do i = 1, imax
xx = 2.*rand()-1. ; yy = 2.*rand()-1.
Qu’a-t-on gagné en faisant tout cela ? Pas grand-chose, x = 2.*sign(sqrt(abs(xx)),xx)
il faut le reconnaı̂tre, en termes de performances de calcul ; y = 2.*sign(sqrt(abs(yy)),yy)
toutefois, on est rassuré que cela ≪ marche ≫, ce qui sera if ( 4*tanh(x-y)*exp(-(x**2+y**2)) > 0.4 ) then
précieux quand on n’aura plus le choix. . . z = x*y
92 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

if ( abs(z) > 1.e-10 ) then ! no zero divide système 53 : autrement dit, sauf dans quelques cas 54 , on
s = s + sin(z)/abs(z) ne sait pas calculer la fonction de partition.
else Dans la formulation de Gibbs, quand on veut cal-
s = s + 1. culer une grandeur macroscopique, par exemple l’aiman-
endif tation d’un système magnétique, on doit prendre un
endif
grand nombre de systèmes identiques, placés dans le
if ( mod(i,10000) == 0 ) write(10,*) i, 4.*s/i
enddo
même état macroscopique, mais dans des états micro-
close(10) scopiques différents. La moyenne thermodynamique d’une
write(*,*) 4.*s/imax grandeur (notée hM i pour une aimantation, par exem-
end ple) est la moyenne de toutes les valeurs prises par cette
grandeur dans tous ces systèmes. C’est donc une très
On obtient la courbe de la figure 4.46. Pour des résultats grosse intégrale très compliquée et le rapport avec les para-
graphes précédents devrait commencer à poindre. . .
-0.085

-0.0855

-0.086 4.11.6.1 Faire de la thermodynamique statistique

-0.0865
avec un ordinateur.
-0.087

-0.0875 Soit donc un système dans l’ensemble canonique (c’est-

-0.088 à-dire en interaction avec un thermostat à température
-0.0885
T ) et une grandeur A dont on veut calculer la valeur
-0.089
moyenne :
-0.0895

-0.09
Z E(q1 ,q2 ,...,qn )
−
-0.0905 A(q1 , q2 , . . . , qn ) e kB T
dq1 dq2 . . . dqn
-0.091 hAi = Z E(q1 ,q2 ,...,qn )
−
-0.0915
e kB T
dq1 dq2 . . . dqn
-0.092
100000 1e+06 1e+07
n (4.32)
Les q1 . . . qn sont les variables microscopiques du système
Figure 4.46 – Valeurs obtenues pour ID avec le domaine (typiquement les positions, vitesses, etc., de tous les
(4.31) en fonction du nombre de tirages (l’axe des x a une atomes ; n est, on l’aura compris, très grand et les
échelle logarithmique) par une méthode d’échantillonnage intégrales très multidimensionnelles) ; E(q1 , q2 , . . . , qn ) est
par l’importance. L’échelle de l’axe des y est la même que l’énergie du système dans l’état microscopique défini par
pour la figure 4.44. les valeurs de ces variables, A(q1 , q2 , . . . , qn ) la valeur de
la grandeur A dans les mêmes conditions. La probabilité
très comparables, voire meilleurs que ceux de la figure 4.44, d’atteindre un état d’énergie E est proportionnelle à l’ex-
on a fait dix fois moins de tirages au sort (107 au lieu de ponentielle (dans une statistique de Maxwell-Boltzmann)
108 ) : on a gagné un ordre de grandeur en temps de calcul ! et le dénominateur de l’expression est la fonction de par-
Ça méritait un petit effort. . . tition qui sert ici à la normalisation.
Il est bien sûr hors de question de calculer directement
4.11.6 Simulation de Monte-Carlo- l’expression (4.32), mais nous avons vu qu’il existe des
chemins de traverse plus ou moins tortueux pour ce genre
Metropolis.
de situations.
À quoi tous les calculs d’intégrale plus ou moins com- Imaginons de faire une marche au hasard dans l’espace
pliqués ci-dessus peuvent-ils bien servir à part meubler la des états accessibles au système : partons donc d’un état
conversation d’un vieil enseignant ? dont on peut calculer l’énergie E1 . La probabilité que cet
On sait qu’en thermodynamique statistique, pour un état soit réalisé est :
système donné, un grand nombre d’états microscopiques E1
−k
correspondent à un même état macroscopique : par ex- e BT

emple, la connaissance de la pression et de la température p1 =

Z
d’un gaz suffisent à définir son état macroscopique qui cor-
respond à un nombre gigantesque d’états microsopiques En général, on ne peut pas calculer cette probabilité
possibles, définis, eux, par la position et la vitesse de puisque Z est inconnu. Faisons alors un pas au hasard
chacun des atomes qui composent le gaz. A priori, dans dans cet espace, on change alors d’état et l’énergie devient
l’ensemble canonique, quand on connait la fonction de par- E2 . La probabilité de ce nouvel état est
tition du système E2
−k
X e BT
E
− k iT p2 =
Z= e B Z
i
qui n’est pas plus calculable que p1 , mais Z, qui est une
on peut calculer toutes les grandeurs que l’on veut (T étant intégrale sur tous les états, n’a pas changé.
la température du thermostat et kB la constante de Boltz-
53. la somme discrète ci-dessus, peut être remplacée par une
mann). Le seul petit détail contrariant dans cette histoire intégrale multiple sur toutes les variables microscopiques du système,
est que la somme sur i dans l’équation ci-dessus est une si celles-ci varient continûment.
somme sur tous les états microscopiques acccessibles au 54. voir à ce sujet le cours de thermodynamique statistique.
Physique numérique, Philippe Depondt 93

2
La probabilité π1→2 de transiter de l’état 1 vers l’état 2
est simplement la probabilité p1 d’être dans l’état 1 mul- 1.5
tipliée par la probabilité conditionnelle p1→2 de transiter
de l’état 1 vers l’état 2, alors que le système est déjà dans 1

l’état 1 :
0.5

V
π1→2 = p1 p1→2
De même, en sens inverse : 0

−0.5
π2→1 = p2 p2→1
−1
Le principe dit ≪ de la balance détaillée ≫ stipule que 1 1.2 1.4
r
1.6 1.8 2

π1→2 = π2→1 ⇒ p1 p1→2 = p2 p2→1 Figure 4.47 – Le potentiel de Lennard-Jones, pour ε = 1

Cela signifie que si, par exemple, l’état 1 est très probable et σ = 1. Le potentiel est fortement répulsif pour r < σ
et l’état 2 très improbable, le système étant déjà dans l’état ce qui correspond à la répulsion dite de
≪ cœur dur ≫,

2 aura une forte probabilité d’aller dans l’état 1, alors que attractif dans le cas contraire.
s’il est dans l’état 1, il aura une faible probabilité d’aller
dans l’état 2. En revanche, si l’on regarde le système ≪ de la variation d’énergie correspondante ∆V . Si ∆V < 0,
loin ≫, d’un point de vue macroscopique, on ne sait pas p1→2 = 1, on garde la nouvelle configuration et l’on recom-
dans quel état microscopique il est, et les probabilités de mence. Si, en revanche ∆V > 0,
transition dans un sens ou dans l’autre sont égales.
− ∆V
On arrive ainsi à la relation suivante : p1→2 = e kB T
p2
p1→2 = p2→1 il faut donc garder cette nouvelle configuration avec cette
p1
probabilité.
soit On compare alors un nombre s, tiré au sort dans l’in-
(E −E )
− k2 T 1 tervalle [0, 1], avec cette probabilité de transition (figure
p1→2 = e B p2→1
4.48). La probabilité que p1→2 > s est justement. . . p1→2 !
une expression précieuse en ce sens que la fonction de par-
tition, justement redoutée, en a disparu !
L’algorithme de Monte-Carlo-Metropolis dit ceci : ≪ si s
E2 < E1 , le système qui se trouve dans l’état 1 transitera
vers l’état 2 avec une probabilité 1 : p1→2 = 1. Si au
(E2 −E1 )
−
contraire, E2 > E1 , alors, p2→1 = 1 et p1→2 = e kB T
.
Ainsi si l’on choisit : 0 1
(E −E )
p = exp(dE/kT)
− k2 T 1
p1→2 = min(1, e B )
dE
la marche au hasard ainsi produite obéira à la statistique Figure 4.48 – On calcule p = e− kT et on compare avec
de Maxwell-Boltzmann, ce que l’on voulait ≫. un nombre s tiré au sort dans l’intervalle [0, 1]. Plus p est
En effet, nous sommes maintenant en train de faire une grand, plus on a de chances que s < p : donc p est la
marche au hasard dans le domaine d’intégration avec une probabilité de garder la nouvelle configuration.
probabilité qui est justement celle que l’on attend, on fait
donc pour ainsi dire ≪ spontanément ≫ un échantillonnage Donc, si p1→2 > s, on conserve la nouvelle configuration,
selon l’importance. sinon on la rejette. Puis on recommence. . . À chaque pas,
on calcule la grandeur dont on veut la valeur moyenne et
l’on fait cette moyenne.
4.11.6.2 Concrètement. Une écriture possible de cet algorithme serait
Admettons, par exemple, que l’on s’intéresse à un en-
i = n*rand() + 1 ! tirage au sort d’un atome
semble d’atomes susceptibles de constituer un solide et ! i est dans l’intervalle [1,n], or 0 <= rand() < 1
que l’on puisse calculer l’énergie potentielle du système !
connaissant les positions atomiques : V ({~rℓ }), par exem- ! conserver l’ancienne configuration au cas ou il
ple : ! faudrait rejeter la nouvelle
 12  6 ! x_old = x(i) ; e_old = e
1X σℓm σℓm !
V = εℓm −2 ! deplacer l’atome i
2 rℓm rℓm
ℓ,m x(i) = x(i) + dx*(rand()-0.5)
!
si les interactions interatomiques sont des interactions de ! calcul de la nouvelle energie
paire du type Lennard-Jones (figure 4.47), mais il existe e = energie(x,n)
de nombreuses autres possibilités. de = e - e_old
Appliquons la méthode ci-dessus : à partir d’une config- !
uration initiale qui est, soit choisie, soit prise au hasard, if ( de > 0 ) then ! si l’energie a augmente
on tire au sort un déplacement atomique, et l’on calcule ! plus exp(-de/kt) est grand, plus la condition
94 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

−0.4
5x5 n’est sans doute pas bien choisi car on ne connait pas au
10x10
−0.6 20x20 départ quelles sont les ≪ bonnes ≫ configurations) jusqu’à
30x30
−0.8 40x40
50x50
ce que l’on aboutisse à une situation où l’ont obtient au fil
−1
70x70 des tirages autant d’augmentations que de diminutions de
l’énergie : le système se met à fluctuer autour d’une même
−1.2
Energie

énergie. Si l’on poursuit néanmoins les tirages au sort, on

−1.4 produit une succession de configurations possédant une
−1.6 énergie dont les fluctuations sont de l’ordre de kB T . Les
−1.8
configurations obtenues sont les configurations que par-
court le système à cette température : on peut faire des
−2
moyennes des grandeurs physiques pertinentes, étudier la
−2.2
0 1 2 3 4 5
structure, etc.
1.1
T Si l’on change la température, on peut étudier com-
1
5x5
10x10
ment les grandeurs évoluent, en particulier s’intéresser
0.9
20x20
30x30 aux changements de structure : les transitions de phase.
40x40
50x50 Les simulations de Monte-Carlo sont l’une des grandes
0.8 70x70
méthodes de simulation en matière condensée et les ap-
0.7
plications en sont multiples. Elle s’applique, comme on l’a
Aimantation

0.6
0.5
0.4
0.3
0.2
0.1
0
0 1 2 3 4 5
T
Figure 4.49 – Le résultat d’une simulation Monte-Carlo
Metropolis sur un ensemble de spins de tailles variables de
5 × 5 à 70 × 70, placés sur un réseau bidimensionnel carré,
avec des conditions aux limites périodiques et des inter-
actions ferromagnétiques entre premiers voisins du type
−Si Sj tendant à aligner les spins ; chaque spin peut pren-
dre les valeurs +1 ou −1. Pour plusieurs températures
différentes, on a fait quelques centaines de milliers tirages
au sort, et calculé l’énergie moyenne par spin (en haut)
et l’aimantation moyenne, également par spin (en bas).
On constate qu’à basse température, l’aimantation vaut
1 : tous les spins sont orientés dans le même sens ce
qui correspond à l’énergie potentielle la plus faible. Puis
vu, à des systèmes classiques dont les variables (ici, les po-
sitions atomiques) peuvent varier continûment, mais aussi
à des systèmes de spins dans le cadre du célèbre ≪ modèle
d’Ising ≫ (voir la figure 4.49).
4.11.7 Recherche du minimum d’une
fonction : le recuit simulé.
La méthode de Monte-Carlo-Metropolis, on l’a vu, per-
met de parcourir des états d’un système, même si l’état
initial que l’on avait choisi était inadapté : le système tend
à converger vers des états compatibles avec la température
choisie, et l’on imagine volontiers que si l’on fait diminuer
la température jusqu’à la faire tendre vers zéro, l’on tende
vers le minimum de l’énergie. Peut-on alors généraliser ce
genre de méthodes à la recherche du minimum d’une fonc-
tion, même s’il ne s’agit pas d’une énergie ?
120
100

l’aimantation diminue brusquement vers T = 2, 5 quand 80

le désordre thermique prend le dessus. Si les courbes
d’énergie se superposent (sauf pour 5 × 5) on observe, 60
sur les courbes d’aimantation, que la transition est mieux
40
marquée pour le système le plus gros : l’aimantation ne
devient véritablement nulle au-dessus de la transition que 20
pour un système infini pour lequel les fluctuations sont
négligeables. 0

! ci-dessous est difficile a remplir
if ( rand() > exp(-de/kt) ) then
! rejet de la nouvelle configuration
x(i) = x_old ; e = e_old
endif ! sinon on garde
endif
C’est un algorithme très simple que l’on peut optimiser de
multiples façons, en particulier de calculer directement la
variation d’énergie (la variation ne dépend que de l’atome
déplacé et de ceux avec lesquels il est en interaction, alors
que l’énergie concerne tous les atomes) peut représenter
un gain significatif de temps.
On fait alors de nouveaux tirages au sort. L’énergie
du système tend à évoluer (puisque le point de départ
−20
−10 −5 0 5 10
Figure 4.50 – Comment, à partir d’une analyse locale de
la dérivée de cette fonction peut-on être sûr d’aboutir sur
son minimum absolu ?
Les méthodes de recherche de minima de fonctions vues
au chapitre 4.7 ont en effet toutes le défaut de reposer
sur une analyse locale des dérivées de cette fonction, que
ce soit la méthode de la plus grande pente ou celle du
gradient conjugué. Rien ne garantit avec ces méthodes
que l’on a atteint le minimum absolu de la fonction : le
minimum trouvé peut n’être qu’un minimum local (fig-
ure 4.50), un autre plus profond se trouvant ailleurs. La
méthode du recuit simulé est une tentative pour s’attaquer
Physique numérique, Philippe Depondt
à ce problème. Soit, donc, une fonction :
f (x1 , . . . , xn ) = f (X)
où X désigne l’ensemble des {xℓ }, et l’on cherche le mini-
mum de cette fonction.
On démarre la recherche comme d’habitude par un point
[0] [0]
de départ, X [0] = (x1 , . . . , xn ), mais en général, il est
tiré au sort. Puis on modifie l’un des xℓ aléatoirement ce
qui donne X [1] . On fait alors une hypothèse ≪ thermody-
namique ≫ que la probabilité de transiter de l’état X [0] à
l’état X [1] est :
p0→1 = e−β0 ∆f , avec ∆f = f (X [1] ) − f (X [0] )
On est en train d’assimiler la fonction f à une énergie avec
β0 = 1/kB T0 , l’inverse d’une température fictive. On tire
alors au sort un autre nombre s compris entre zéro et un
avec une distribution uniforme. Si f a diminué en passant
de l’état X [0] à l’état X [1] , alors p0→1 > 1 > s. Si en
revanche, f a augmenté, alors p0→1 < 1 et donc peut être
soit supérieur ou inférieur à s ; or, plus f a augmenté, plus
p0→1 est petit, et plus sa probabilité d’être plus petit que
s est grande.
Si on se donne alors la règle : si p0→1 > s, on con-
serve la nouvelle configuration, sinon on la rejette, alors
p0→1 joue bien le rôle d’une probabilité de transition de
l’état X [0] vers l’état X [1] . Ainsi, de tirage au sort en
tirage au sort, on privilégie les cas ou f diminue, mais
pas systématiquement : si β0 est petit un certain nom-
bre de cas où f augmente seront conservés, ce qui permet
d’espérer sortir d’un éventuel minimum secondaire.
On modifie alors un autre xℓ et l’on recommence un
grand nombre de fois jusqu’à ce que les valeurs prises par
f ne fassent plus que fluctuer autour d’une même valeur.
Puis on diminue la température (en écrivant par exemple
βn = βn−1 B, B > 1) et l’on recommence et ainsi de suite,
jusqu’à ce que les variations de β ne modifient plus les
valeurs prises par f .
L’appellation ≪ recuit simulé ≫ se justifie donc, puisque
l’on a ≪ chauffé ≫ le ≪ système ≫ pour lui permet-
tre d’explorer un grand nombre de configurations (si la
température est élevée, la probabilité p0→1 est plus facile-
ment proche de un), puis on l’a ≪ refroidi ≫ progressive-
ment afin de le laisser chercher la configuration de plus
bas f .
Une application classique de cette méthode est le
problème dit ≪ du voyageur de commerce ≫ (figure 4.51) :
un voyageur de commerce doit explorer, pour y faire ses
affaires, un certain nombre de villes, mais pour gagner
du temps, il doit les visiter dans un ordre tel que la dis-
tance parcourue finale soit la plus courte possible. Le re-
cuit simulé est probablement la meilleure méthode pour
trouver un ordre optimal, sachant que le nombre de choix
est vite immense ((n − 1)! si la première et dernière
ville est fixée), dès que le nombre de villes commence à
croı̂tre un peu : une recherche systématique, seule suscep-
tible de fournir le minimum absolu, serait trop coûteuse
(fig. 4.52). Ce genre de méthode est bien adapté à des
problèmes comportant un grand nombre de variables et
converge vers un ensemble de solutions acceptables, à
défaut de la meilleure solution ; en revanche il est peu effi-
cace dans le cas où il existe une, ou un très petit nombre
de solutions, bien définies (fig. 4.53).
95
A
Figure 4.51 – Le problème du voyageur de commerce :
quel est l’itinéraire le plus court qui permette au voyageur
de commerce de visister toutes les villes ?
Une autre application parfois intéressante est ce que l’on
appelle le ≪ Monte-Carlo inverse ≫ pour laquelle la fonc-
tion dont on cherche le minimum est le χ2 correspondant
à une expérience ou un ensemble d’expériences. Pour une
expérience de diffraction de rayons X, par exemple, χ2 est
une fonction d’un grand nombre de paramètres : les po-
sitions atomiques. Un recuit simulé peut être parfois une
bonne solution pour en chercher le ( ou les ) minimum.
4.12 Le tri.
On ne dira pas grand-chose ici sur les algorithmes de tri
à proprement parler, sinon pour une mise en garde, car
cela sort un peu du domaine de la physique numérique
stricto sensu.
Il peut arriver que l’on ait à trier des nombres par
valeurs croissantes ou décroissantes : par exemple, si
l’on a calculé les positions d’un certain nombre d’atomes
et si l’on souhaite les représenter sur une figure, il est
souhaitable de tracer d’abord les atomes les plus éloignés
de l’observateur (ou les plus au fond de la figure) de telle
façon que les atomes les plus proches soient tracés ensuite
et puissent éventuellement les masquer. La méthode que
l’on imaginerait au premier abord consiste à comparer les
nombres deux à deux et à les permuter si nécessaire : c’est
très inefficace et extrêmement coûteux en temps machine
dès que le nombre d’éléments dans le problème dépasse
une dizaine ! À éviter donc dans la plupart des cas. . .
Le plus simple est évidemment d’aller chercher dans
une bibliothèque de programme une subroutine de tri
et de l’utiliser sans plus poser de question : c’est prob-
ablement la meilleure façon de gagner du temps ! Si un
tel programme n’est pas disponible, on peut tenter d’u-
tiliser la commande Unix sort sur un fichier, c’est efficace
mais pas toujours très souple d’emploi. Sinon, en général,
un algorithme du type Quicksort devrait donner satisfac-
tion : on partitionne en un endroit donné le tableau que
l’on veut trier et l’on en permute les éléments de telle
façon que tous les éléments précédents la partition soient
inférieurs à la valeur de l’élément frontière, et tous les
96 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

1 1
Random
0.9
0.8
0.8
0.6
0.7

0.6 0.4

0.5 0.2
0.4
Y 0
0.3
−0.2
0.2
−0.4
START 0.1

0 −0.6
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1 1
T=1 T=0.5 −0.8
0.9 0.9

0.8 0.8 −1
−1 −0.8 −0.6 −0.4 −0.2 0 0.2 0.4 0.6 0.8 1
0.7 0.7 X
0.6 0.6

0.5 0.5
Figure 4.53 – Le problème du voyageur de commerce,
0.4 0.4

0.3 0.3
traité par recuit simulé comme dans la figure 4.52, mais
0.2 0.2 dans un cas -des villes réparties sur un cercle- où la
0.1 0.1 meilleure solution est facile à deviner : ici la méthode par
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 recherche au hasard aboutit à un résultat assez peu con-
1 1

0.9
T=0.25
0.9
T=0.125 vaincant, le voyageur serait amené à faire plusieurs tours
0.8 0.8
sur le cercle, avec des retours en arrière, alors qu’un seul
0.7 0.7 tour suffirait ; la méthode n’est pas universelle. . .
0.6 0.6

0.5 0.5

0.4 0.4 en partage l’efficacité. Voir à ce sujet Numerical Recipes

0.3 0.3
ref. [3] dans la bibliographie.
0.2 0.2

0.1 0.1

0 0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1 1
T=0.0625 T=0.03125
0.9 0.9

0.8 0.8

0.7 0.7

0.6 0.6

0.5 0.5

0.4 0.4

0.3 0.3

0.2 0.2

0.1 0.1

0 0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1 1
T=0.015625 T=0.0078125
0.9 0.9

0.8 0.8

0.7 0.7

0.6 0.6

0.5 0.5

0.4 0.4

0.3 0.3

0.2 0.2

0.1 0.1

0 0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

Figure 4.52 – Itinéraires obtenus par recuit simulé pour

100 villes placées au hasard dans un carré de coté 1. En
haut, un itinéraire pris au hasard : la distance que le
voyageur de commerce doit parcourir est de l’ordre de
55. Puis la ≪ température ≫ fictive est progressivement
diminuée tout en faisant des tirages au sort pour permuter
les villes à visiter. La dernière figure propose un itinéraire
correspondant à une distance de 15 : le gain est significatif.
Chaque figure fait suite à plusieurs dizaines de millions de
tirages, mais le temps d’exécution sur un PC standard est
de quelques minutes. . .

suivants supérieurs. On trie alors chaque sous-tableau en

refaisant une autre partition dans chacun d’eux, etc. : c’est
une logique qui ressemble un peu à celle des FFT et elle
Chapitre 5
Introduction à la simulation numérique
5.1 Pourquoi la Simulation numé-
rique ?
Les chapitres précédents montrent comment la plupart
des problèmes physiques sont susceptibles de donner lieu à
des calculs sur ordinateur dès que les solutions analytiques
n’en sont pas triviales. Les méthodes de base (résolution de
systèmes linéaires, transformées de Fourier rapides, etc.)
qui font partie de la culture générale des physiciens y sont
exposées : ce sont les briques élémentaires que l’on utilise
pour bâtir des édifices plus imposants.
La simulation numérique est en effet simplement un pas
de plus dans cette direction : faute de pouvoir calculer ana-
lytiquement le comportement d’un système physique, on le
simule sur ordinateur. Il s’agit de résoudre numériquement
les équations qui régissent par exemple son évolution tem-
porelle, ou, plus simplement, calculer son état dans telles
ou telles conditions.
En revanche, les problèmes ≪ sérieux ≫, tels qu’on peut
les rencontrer dans un laboratoire de recherches ou dans un
environnement de développement industriel, nécessitent
souvent des calculs dont le volume dépasse assez largement
les quelques minutes de temps de calcul sur un PC ! Là
commence ce que l’on peut appeler ≪ le monde du calcul
scientifique intensif ≫ : voila certes une définition plutôt
qualitative. . . Cependant, il s’agit d’un domaine qui com-
porte ses méthodes spécifiques dont le but est d’obtenir
des résultats physiquement significatifs dans des délais
raisonnables ; l’appréciation de ce qui est ≪ significatif ≫ et
≪ raisonnable ≫ n’est certes pas universel, certains calculs
pouvant prendre plusieurs mois !
Ces méthodes peuvent se regrouper grossièrement en
deux grandes catégories :
1. Les méthodes de programmation efficaces qui perme-
ttent d’utiliser au mieux l’architecture et les capacités
de calcul de nos machines : c’est un volet plutôt ≪ in-
formatique ≫.
2. Le volet plus ≪ physique ≫ comporte les questions
physiques à proprement parler : le milieu étudié doit-
il être considéré comme continu ou composé d’atomes
et de molécules, quelles sont les approximations que
l’on peut faire, pour quels types de problèmes, quelles
informations physiques sur le système étudié peut-on
en attendre, que faire des résultats ?
Le premier volet est abordé dans le chapitre 6. Le présent
chapitre tente d’aborder le deuxième ; il ne prétend bien
sûr en aucun cas à l’exhaustivité tant le domaine est vaste !
On parlera donc principalement de :
1. La matière considérée comme un milieu continu.
97
2. La matière comme une collection de particules.
5.2 La matière considérée comme
un milieu continu.
5.2.1 Quels types de questions se pose-t-
on ?
Lorsqu’on s’intéresse à la matière comme un milieu con-
tinu c’est, en général qu’on se place à une échelle telle que
la structure atomique de la matière ne joue pas.
Par exemple, si l’on veut étudier la propagation d’une
onde électromagnétique en optique alors que la longueur
d’onde de la lumière visible λ ∼ 0, 5µm est beaucoup plus
grande que les distances inter-atomiques dans un solide
ou un liquide (∼ 1nm), alors on peut écrire l’équation de
propagation (ici, à une dimension) :
∂2E 1 ∂2E
= 2 (5.1)
∂x 2 vϕ ∂t2
où E est le champ électrique et vϕ la vitesse de phase
qui peut dépendre de x afin de traiter des systèmes com-
portant plusieurs matériaux d’indices différents ou bien
des matériaux inhomogènes dont l’indice peut varier con-
tinûment. Dans des cas plus compliqués, on pourra plutôt
écrire :
2~
∆E~ =∂ D
∂t2
avec une relation entre D~ et E~ qui peut ne pas être triviale
(anisotrope ou non-linéaire par exemple).
Un autre exemple, que l’on a déjà mentionné à pro-
pos des sytèmes linéaires (voir le paragraphe 4.5.1) est la
propagation de la chaleur dans un milieu qui peut être
hétérogène. On peut alors appliquer la loi de Fourier, tou-
jours à condition de se placer dans des conditions où celle-
ci s’applique (temps caractéristiques longs par rapport aux
vibrations atomiques, échelles grandes par rapport aux
distances inter-atomiques, . . .) :
~ r) = −κ(~r) grad
φ(~ ~ T (~r) (5.2)
~ r) est pro-
qui exprime que le flux de chaleur local φ(~
portionnel au gradient de température local, le coeffi-
cient de proportionnalité κ(~r) étant la conductivité ther-
mique : celle-ci, comme le milieu peut être inhomogène,
dépend de l’endroit où l’on se trouve. . . Une hypothèse
supplémentaire possible est celle du régime permanent : la
98 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

conservation de la quantité de chaleur (premier principe ainsi, l’indice entier i représente l’espace et l’indice entier
de la thermodynamique en l’absence de travail) donne, j le temps, et :

~ r) = Q̇(~r)
div φ(~ (5.3) E(x, t) = E(i δx , j δt ) = Ei,j

la divergence du flux est en chaque point la création ou De même la vitesse de phase se réécrit :
l’apport local (venant du monde extérieur) de chaleur.
D’autres exemples pourraient venir de l’hydrody- vϕ (i δx ) = vi
namique où l’on applique les équations d’écoulement d’un
L’équation (5.4) des différences finies permet d’écrire :
fluide, en tenant compte ou non de la viscosité, de la
mécanique des milieux continus où l’on déforme un solide ∂E(x, t) Ei+1,j − Ei,j
plus ou moins compliqué par des contraintes ( e.g. un ≃ (5.5)
∂x δx
système constitué de deux solides collés avec des coeffi-
cients de dilatation différents soumis à un accroissement ou
∂E(x, t) Ei,j − Ei−1,j
de température. . .), etc. ≃ (5.6)
∂x δx
Tous ces problèmes ont pour ingrédient commun qu’il
s’agit d’équations aux dérivées partielles, c’est-à-dire ce sont deux approximations possibles, équivalentes mais
d’équations différentielles de plusieurs variables qui con- qui n’ont pas exactement la même valeur. . . en fait, il
tiennent des dérivées partielles comme : faudrait pouvoir prendre la valeur du champ au demi-pas :
c’est parfois possible, parfois, non. Ce qui a été écrit ici,
∂ ∂ ∂ ∂ c’est plutôt :
, , ,
∂x ∂y ∂z ∂t
δx δx
Les systèmes macroscopiques ne sont pas les seuls suscep- ∂E(x + , t) ∂E(x − , t)
2 et 2
tibles de ce genre de traitement : l’équation de Schrödinger ∂x ∂x
pour une particule dans un potentiel est aussi une équation
c’est-à-dire les dérivées au demi-pas ; or ce sont les
aux dérivées partielles,
dérivées secondes, et non les dérivées premières, qui nous
 2  intéressent dans ce problème :
∂ h̄
ih̄ ψ(~r, t) = − ∆ + V (~r) ψ(~r, t)
∂t 2m δx δx
∂E(x + , t) ∂E(x − , t)
ainsi que bien sûr les équations de Maxwell de 2 − 2
∂ 2 E(x, t) ∂x ∂x
l’électromagnétisme. ≃
∂x2 δx
Ces questions ne sont pas forcément faciles à traiter, et,
parfois même dans certaines conditions et pour des raisons et en remplaçant les dérivées premières par les expressions
diverses, on ne sait pas les résoudre. Cependant, il existe (5.5) et (5.6), on obtient aisément l’approximation :
deux classes principales de méthodes pour s’y attaquer : les
méthodes de différences finies et les méthodes d’éléments ∂ 2 E(x, t) Ei+1,j + Ei−1,j − 2Ei,j
≃
finis. L’on mentionnera également les méthodes dites spec- ∂x2 δx2
trales.
La même opération peut être effectuée pour la dérivée
temporelle, sauf que c’est maintenant l’indice j qui est
5.2.2 La méthode des différences finies affecté, et en fin de compte, l’équation de propagation (5.1)
Si f est une fonction de plusieurs variables x1 , x2 ,. . ., se réécrit :
xn , on peut approximer la dérivée partielle par rapport à Ei+1,j + Ei−1,j − 2Ei,j 1 Ei,j+1 + Ei,j−1 − 2Ei,j
xi par : = 2
∂f
2
δx vi δt2
≃
∂xi Ce que l’on cherche, c’est le champ E en tous points à
f (x1 , . . . , xi + δxi
, . . . , xn ) − f (x1 , . . . , xi − δxi
, . . . , xn ) l’instant t + δt , le connaissant aux instant t et t − δt , ainsi :
2 2
δxi Ei,j+1 =
(5.4)
c’est la définition de la dérivée partielle, mais on ne passe  2
v i δt
pas à la limite : δxi prend une valeur petite mais finie, (Ei+1,j + Ei−1,j − 2Ei,j ) + Ei,j − Ei,j−1 ∀i
δx
c’est là que réside l’approximation et c’est de là que vient
(5.7)
l’expression différences finies.
ce qui se programme fort aisément en quelques lignes.
Dans les paragraphes qui suivent, différentes variantes
On appelle cela un schéma explicite puisque la solution
de la méthode sont montrées à l’aide d’exemples.
apparaı̂t explicitement : on doit connaı̂tre les conditions
initiales et calculer pas à pas les résultats au cours du
5.2.2.1 Le schéma explicite temps.
Prenons par exemple l’équation de propagation d’une La figure 5.1 montre un exemple simple de propaga-
onde électromagnétique dans un milieux unidimensionnel tion à travers une lame transparente d’un paquet d’ondes
(eq. (5.1) ) : il faut d’abord discrétiser le temps et l’espace, gaussien avec les réflexions sur les dioptres. On y voit bien
sûr le ralentissement du paquet dans le diélectrique (la
x = i δx t = j δt pente est plus forte, autrement dit, il faut plus de temps
Physique numérique, Philippe Depondt 99

30
2
25 1.5
1
20 0.5
0
−0.5
15 −1
t

−1.5
−2
10

0
0 5 10 15 20
x
Figure 5.1 – Propagation d’une onde à travers une lame transparente obtenue par l’équation (5.7). En abscisse,
la coordonnée spatiale x, en ordonnée le temps. La condition initiale est donnée par un paquet d’ondes gaussien
se déplaçant dans le sens des x croissants, puisque l’on doit définir les deux premiers pas de temps pour initialiser
l’équation (5.7).

pour parcourir la même distance) et les interférences entre et :

les ondes incidentes et réfléchies.
On pourrait, par exemple, compliquer le problème en κi+1 − κi−1 + 4κi −κi+1 + κi−1 + 4κi
− Ti+1 +2κi Ti − Ti−1
considérant : 4 4


D = ε0 (1 + χ1 )E + χ2 E 2 = −Q̇i δx2
soit une dépendance non-linéaire de D en fonction
Le résultat important ici est que l’on obtient un système
du champ électrique (ici un développement limité au
d’équations linéaires dont les inconnues sont les Ti : la
deuxième ordre, χ1 étant la susceptibilité du premier or-
température en chaque point, or, le nombre d’équations et
dre habituelle et χ2 le terme du deuxième ordre), ce qui
d’inconnues est donné par la discrétisation :
permet de sortir du domaine habituel des diélectriques
linéaires.
L
n=
δx
5.2.2.2 Le schéma implicite
Si l’on combine l’équation de Fourier (5.2) et la conser- où L est la longueur de l’échantillon. Autrement dit, le
vation de la chaleur (5.3), on obtient : nombre d’équations peut être énorme et il est donc exclu
  de tenter de le résoudre à la main !
~
div κ(~r) gradT (~r) = −Q̇(~r) Il suffit alors de poser :

soit, si l’on se restreint à un problème à une dimension : AT = Q (5.9)

∂κ(x) ∂T (x) ∂ 2 T (x)
+ κ(x) = −Q̇(x) (5.8) avec :
∂x ∂x ∂x2
A=
Comme dans le cas précédent, on peut discrétiser le
 
problème : .. ..
 . . 0 0 0 0 0 
Ti = T (i δx ) κi = κ(i δx ) Q̇i = Q̇(i δx )  .. .. 
 0 . . 0 0 0 0 
 
On a de nouveau le problème que l’on ne connaı̂t pas les  .. .. 
 0 0 . . 0 0 0 
valeurs des fonctions au demi-pas pour calculer les dérivées  
 κi+1 − κi−1 + 4κi −κi+1 + κi−1 + 4κi 
premières : on peut s’en sortir néanmoins en considérant  0 0 − 2κi − 0 0 
 4 4 
des intervalles de 2δx , et donc le demi-pas devient main-  .. .. 
 0 0 0 . . 0 0 
tenant δx . . . Cela donne, ainsi :  
 .. .. 
 0 0 0 0 . . 0 
κi+1 − κi−1 Ti+1 − Ti−1 Ti+1 + Ti−1 − 2Ti  
+ κi = −Q̇i .. ..
2δx 2δx δx2 0 0 0 0 0 . .
100 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

une très grosse matrice n × n, et deux matrices colonne : renumérotant : m = 3(i − 1) + α où α prend les valeurs 1,
   2, 3. La même opération est évidemment faite pour ℓ.
T1 −Q̇1 δx2 On conçoit aisément que la matrice A peut facilement
 ..   ..  devenir énorme à tel point qu’il faut parfois recourir à des
 .   . 
    méthodes sophistiquées pour résoudre le système linéaire !
T= 
 Ti 

Q =  −Q̇i δx 
2

 .   .. 
 ..   .  5.2.2.3 Contourner le schéma implicite
Tn −Q̇n δx2
Une façon d’éviter le schéma implicite pour retrouver un
Il reste à régler la question des conditions aux limites schéma explicite est d’écrire une équation d’évolution tem-
qui, dans ce cas ci, se réduisent à peu de choses, par ex- porelle du système au lieu de tenter de calculer d’emblée
emple : une situation d’équilibre où tous les points dépendent les
T0 = Ta et Tn+1 = Tb uns des autres. Avec une équation d’évolution, on part
d’une situation initiale et l’état au pas suivant dépend ex-
on introduit des points qui n’interviennent pas dans le plicitement de l’état initial : le système, si tout se passe
système (5.9), i = 0 et i = n + 1 qui représentent les bien, doit évoluer vers l’équilibre que l’on cherchait. Par
extrémités de l’échantillon et on fixe leurs températures à exemple, l’équation stationnaire (5.3) peut être remplacée
Ta et Tb . Cela oblige à modifier la première et la dernière par une équation hors d’équilibre :
ligne de A et de Q.
∂T (~r)
On peut aussi laisser les conditions aux limites libres, la C = Q̇(~r) − divφ
seule contrainte étant alors Q̇(x). ∂t
On fait appel alors à un sous-programme de bib- c’est-à-dire que la variation temporelle locale de
liothèque, ou bien pris dans un manuel de ≪ recettes température (multipliée par la capacité calorifique C d’une
numériques ≫, capable de résoudre le système (5.9). Si n cellule) est la production locale de chaleur diminuée de la
est grand, le système est parfois lourd à résoudre, cepen- chaleur qui s’écoule hors de la cellule. En combinant cela
dant, la matrice A comporte principalement des zéros (on avec la loi de Fourier (5.2), on obtient :
dit qu’elle est creuse), et dans le cas présent elle est tridi- ∂T (~r)  
C = Q̇(~r ) − div κ(~
r ) ~ T (~r)
grad
agonale ce qui facilite souvent la résolution numérique du ∂t
système d’équations.
On tombe ainsi sur un schéma explicite similaire à celui
Le résultat d’un exemple simple est montré sur la figure
de la propagation d’une onde du paragraphe 5.2.2.1. Le
5.2.
même problème que pour la figure 5.2 est ainsi traité sur
la figure 5.3.

Figure 5.2 – Une solution numérique de l’équation (5.9)

en fixant des conditions de température fixes aux deux
Figure 5.3 – Évolution temporelle de la distribution de
extrémités (T (x = 0) = 2 et T (x = 1) = 0) et sans
la température dans le cas représenté par la figure 5.2.
production de chaleur. La conductivité κ dépend de x.
L’état initial est donné par T = 0 sur tout le barreau
On retrouve le résultat connu que la température varie
sauf à la deuxième extrémité où elle vaut 2. Le système
linéairement tant que κ est constant, un changement de
évolue spontanément vers la situation d’équilibre trouvée
pente ayant lieu à chaque changement de valeur de la con-
précédemment.
ductivité.
L’avantage d’une telle procédure est d’éviter les risques
Ce schéma est appelé implicite puisqu’on n’ob- d’instabilité numérique liés à la résolution du système
tient pas d’expression du type Ti = . . ., comme d’équations, mais l’inconvénient en est un coût en
précédemment, mais un système d’équations qu’il faut ressources de calcul qui peut s’avérer prohibitif.
résoudre numériquement.
Si l’on veut résoudre un problème à trois dimensions,
5.2.2.4 Questions de stabilité
la méthode est la même dans le principe, la mise un œu-
vre étant un peu plus lourde. Les indices (ℓ, m) de A de- Même les schémas explicites peuvent parfois réserver
viennent composites : m ↔ (i, α) ; α ∈ {x, y, z} et en des surprises. . . Reprenons, par exemple, l’équation de
Physique numérique, Philippe Depondt 101

Schrödinger à une dimension et dépendante du temps On est dans la même situation que pour la méthode de
d’une particule dans un potentiel : Cranck et Nicholson (paragraphe 4.9.5). L’inconnue dans
ce problème est ψ ℓ+1 puisqu’on cherche la fonction d’onde
∂ψ(x, t) h̄2 ∂ 2 ψ(x, t) à l’instant t + δt , la connaissant à l’instant t. Ainsi :
ih̄ =− + V (x)ψ(x, t)
∂t 2m ∂x2    
δi δi
Il est coutumier, dans ce genre de problème, de se placer 1 + i HD ψ ℓ+1 = 1 − i HD ψ ℓ (5.11)
h̄ 2 2
dans un système d’unités où h̄ = 1 et = 1. On peut
2m peut se résoudre à partir d’un système linéaire du type :
discrétiser le problème comme précédemment :

ψjℓ = ψ(j δx , ℓ δt ) Vj = V (j δt ) Aψ ℓ+1 = B

où j et ℓ sont des indices entiers, j pour l’espace et ℓ pour où A est une matrice tridiagonale n × n et B un vecteur
le temps. Soit : de n éléments :

∂ 2 ψ(x, t) ℓ
ψj+1 ℓ
+ ψj−1 − 2ψjℓ δi
≃ A = 1 + i HD
∂x2 δx2  2 
δi
et : B = 1 − i HD ψ ℓ
2
∂ψ(x, t) ψjℓ+1− ψjℓ
≃
∂t δt Un tel problème -qui suit le schéma implicite- se résout
Cela donne aisément : aisément à l’aide d’un sous-programme de bibliothèque
! adéquat (il s’agit d’une matrice triadiagonale, ce qui sim-
ℓ ℓ
ψj+1 + ψj−1 − 2ψjℓ plifie les choses), en prenant soin toutefois de travailler
ψjℓ+1 = ψjℓ + iδt − Vj ψjℓ
δx2 avec des nombres complexes (figures 5.4, 5.5 et 5.6). Un
des charmes de cette méthode est que la norme de la fonc-
que l’on peut écrire matriciellement : tion d’onde est conservée. . .

ψ ℓ+1 = (1 − iδt HD ) ψ ℓ (5.10) 10

3.16
1
où HD est l’Hamiltonien discrétisé : 1 0.316
0.1
0.9
HD = 0.8
  0.7
.. .. .. 0.6
. . . 0 0 0 0
 1 2 1
 0.5 X
 0 + Vj−1 0 0 0  0.4
 − 2
δx δx2
− 2
δx 
  0.3
 1 2 1 
 0 0 − 2 + Vj − 2 0 0  0.2
 δx δx2 δx 
 1 2 1  0.1
 0 0 0 − 2 + Vj+1 − 2 0  0
 δx δx2 δx 
.. .. .. 0 0.005 0.01 0.015 0.02
0 0 0 0 . . .
time
et :  
..
.  Figure 5.4 – Solution de l’équation (5.11) dans le cas

 ..  d’une barrière de potentiel qui va de x = 0.5 à x = 0.75.
 . 
  La condition initiale pour la fonction d’onde est un pa-
ψ =
ℓ
 ψjℓ   quet gaussien centré en x = 0.5. Cette figure montre les
 .. 
 .  premiers pas de la simulation : on voit la la densité de
 
.. probabilité de présence s’élargir de préférence du côté du
. puits de potentiel, mais une partie continue à passer de
Tout cela est fort beau. . . mais le défaut d’une telle l’autre côté. On voit également les réflexions sur les parois
méthode est qu’elle est instable ! On peut tenter de la (l’échelle des courbes de niveaux est logarithmique).
stabiliser en la symétrisant un peu mieux. En effet, on
a appliqué l’Hamiltonien discrétisé à la fonction d’onde à
l’instant t ; on aurait pu tout aussi bien l’appliquer à la 5.2.2.5 Critères de stabilité
fonction d’onde à l’instant t + δt :
Évidemment, la question est de savoir s’il existe des
ψ ℓ+1 = ψ ℓ − iδt HD ψ ℓ+1 critères permettant de savoir a priori si un algorithme est
stable ou non. Il s’agit malheureusement là d’un très vaste
Il s’agit de la même équation que (5.10), seulement HD
programme ! Les spécialistes de mathématiques appliquées
est appliqué à ψ ℓ+1 et non à ψ ℓ . Ni l’une, ni l’autre de ces
et ceux de mécanique démontrent de nombreux et fort
équations n’est entièrement satisfaisante, alors, on peut
beaux théorèmes de convergence ou de non-convergence :
faire un compromis en faisant une moyenne :
c’est hélas pour un physicien essentiellement préoccupé de
ψ ℓ+1
+ψ ℓ savoir si ≪ ça marche ≫ ou ≪ comment faire pour que ça
ψ ℓ+1 = ψ ℓ − iδt HD marche ≫, un monde quelque peu labyrinthique. . .
2
102 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

10 où z(x, t) est le déplacement de la poutre à l’abscisse x

3.16
1 et à l’instant t, ρ sa masse volumique, E le module d’Y-
1 0.316 oung du matériau dont elle est constituée et e(x) son
0.1
0.90.0316
épaisseur qui peut être soit constante soit variable le long
0.8
0.7 de la poutre 1 . On peut tenter de résoudre directement
0.6 l’équation ci-dessus à partir de conditions initiales ad hoc
0.5 X en utilisant les méthodes déjà exposées, mais on peut aussi
0.4 ne chercher que les mouvements périodiques en fonction du
0.3 temps. Dans ce cas, on cherche des solutions du type :
0.2
0.1 z(x, t) = u(x) eiωt
0
0 0.005 0.01 0.015 0.02
ce qui donne :
time
∂4u
− c(x)ω 2 u(x) = 0
Figure 5.5 – Même chose que la figure 5.4, seulement le ∂x4
paquet initial est centré en x = 0.35. On en voit passer avec des notations évidentes.
néanmoins une partie de l’autre côté par effet tunnel. En discrétisant de la façon habituelle, on obtient sans
difficulté, au bout de quelques lignes de calcul :
uℓ+2 − 4uℓ+1 + 6uℓ − 4uℓ−1 + uℓ−2
− δx4 ω 2 uℓ = 0
cℓ
Posons :
 
.. .. .. .. ..
 . . . . . 0 0 0 0 
10  
 0 .. .. .. .. ..
1
 . . . . . 0 0 0 
0.1  
+1 −4 6 −4 +1
0.01 A=
 0 0 0 0 
 cℓ cℓ cℓ cℓ cℓ 
0  .. .. .. .. .. 
0.002  0 0 0 . . . . . 0 
 
0.004 .. .. .. .. ..
0.006 0 0 0 0 . . . . .
1
0.008 0.9
time 0.7
0.8  
0.01
0.5
0.6 u1
0.012 0.4  .. 
0.3
0.014 0.1
0.2 X  . 
 
U= 
 uℓ 
Figure 5.6 – Même chose que la figure 5.5 en 3-D (l’échelle  . 
 .. 
verticale est logarithmique).
un
Les valeurs propres λp de A donnent :
Il arrive cependant qu’il faille en passer par là, quitte
à solliciter l’aide d’un spécialiste. Cependant, souvent un λp = ωp2 δx4
peu de flair suffit : on a vu avec l’équation de Schrödinger
que tenter d’écrire des équations aussi symétriques que soit, au coefficient δx4 près, les carrés des pulsations pro-
possible pouvait arranger des choses. Une autre précaution pres ωp du système harmonique, c’est-à-dire les pulsations
à prendre est d’essayer de faire que l’énorme matrice que auxquelles le système peut vibrer. Les vecteurs propres
l’on cherche à inverser ou diagonaliser soit ≪ aussi diago- Up donnent les déplacements de la poutre pour chaque
≪ mode propre ≫ de pulsation propre ωp .
nale que possible ≫ : autrement dit s’efforcer de rendre les
termes les plus éloignés de la diagonale aussi faibles que À l’aide d’un programme de bibliothèque approprié, rien
possible par rapport aux termes diagonaux, ou bien trou- de tout cela ne doit poser de gros problème. . . si ce n’est
ver des structures du type ≪ tridiagonale par blocs ≫ que que ce genre de programme ≪ préfère ≫ quand la matrice
certains algorithmes sont capables de traiter efficacement. est symétrique ! Il suffit de poser alors :
ζ(x) iωt
5.2.2.6 Systèmes harmoniques z(x, t) = p e
c(x)
Des systèmes harmoniques en mouvement oscillant peu- ce qui donne :
vent obéir à des systèmes similaires. Si l’on étudie, par
exemple, les oscillations harmoniques d’une poutre de sec- ζℓ+2 4ζℓ+1 6ζℓ 4ζℓ−1 ζℓ−2
√ −√ + −√ +√ −δ 4 ω 2 ζℓ = 0
tion variable, on doit résoudre l’équation suivante (ici l’on cℓ+2 cℓ cℓ+1 cℓ cℓ cℓ−1 cℓ cℓ−2 cℓ x
ne tient compte ni du champ de pesanteur, ni d’aucune
autre force extérieure) : Posons comme précédemment :

∂4z ρ ∂2z D=
+ =0 1. Voir par exemple G. Bruhat, Mécanique, Masson (1967) p. 653.
∂x4 Ee2 (x) ∂t2
Physique numérique, Philippe Depondt 103

 
.. .. .. .. et évidemment, les transformées inverses :
. . . . 0 0 0
  Z
 .. .. .. .. 
 0 . . . . 0 0  V (~r) = Ṽ (~q) e−i~q.~r d3 ~q
 +1 6 +1 
 0 −4 −4
0 
 √
cℓ−2 cℓ
√
cℓ−1 cℓ cℓ
√
cℓ+1 cℓ
√
cℓ+2 cℓ 
  Z
 .. .. .. .. 
 0 0 . . . . 0  ρ(~r) = ρ̃(~q) e−i~q.~r d3 ~q
 
.. .. .. ..
0 0 0 . . . . En utilisant les transformées inverses, l’équation de Pois-
  son se reécrit :
ζ1
 ..  Z Z
 .  ∇ 2
Ṽ e q .~
−i~ r 3
d ~r = − ρ̃ e−i~q.~r d3~r
 
Z=
 ζℓ  
 .. 
 .  soit après une dérivation sous l’intégrale :
ζn Z Z
2 q .~
r 3
−|~q| Ṽ e −i~
d ~r = − ρ̃ e−i~q.~r d3~r
Il suffit d’écrire explicitement quelques termes pour mon-
trer que D est symétrique. Cela ne change rien pour les
valeurs propres, celles de D sont les mêmes que celles de A, et :
ρ̃(~q)
seulement les vecteurs propres donnent les déplacements Ṽ (~q) =
|~q|2
pondérés par c(x) : il suffit d’en tenir compte (voir par
exemple la figure 5.7). extrêmement facile à résoudre. . . La méthode consiste
donc à calculer d’abord la transformée de Fourier de ρ(~r),
0.1
1 diviser le résultat par |~q|2 puis retransformer par Fourier
0.08 2
3 inverse pour obtenir le potentiel V (~r). Tout ceci est très
4
0.06 5
6 efficace et rapide. En ~q = 0, on a :
0.04 Z
0.02 Ṽ (~q = 0) = V (~r)d3~r
0
−0.02 il s’agit simplement de définir la constante arbitraire qui
−0.04 intervient dans le potentiel.
−0.06 Malheureusement, les choses sont parfois un peu re-
−0.08 torses comme on peut le constater sur la figure 5.8 puisque
−0.1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
les deux charges placées sur un axe horizontal donnent un
potentiel qui n’a pas la même symétrie, ce qui est fâcheux !
Figure 5.7 – Les six premiers modes propres de vibration
d’une poutre homogène fixée à une extrémité (à gauche)
et libre à l’autre, calculés avec 500 points de discrétisation.

5.2.3 Les méthodes spectrales

Les méthodes dites ≪ spectrales ≫ visent à profiter de
la remarquable efficacité des transformées de Fourier rapi-
des ou FFT. Elles seront donc utilisées pour des calculs
particulièrement lourds car elles ont aussi des défauts.

5.2.3.1 Un premier exemple simple

Prenons, par exemple, l’équation de Poisson de
l’électrostatique :

∇2 V (~r) = −ρ(~r)

où bien sûr, ρ(~r) est une densité de charges et V (~r) le po-
tentiel électrostatique correspondant. On peut introduire
les transformées de Fourier spatiales de ces quantités :
Z Figure 5.8 – Calcul par une méthode spectrale à deux
Ṽ (~q) = V (~r) ei~q.~r d3~r dimensions du potentiel électostatique produit par deux
charges.
où le symbole d3~r indique qu’il s’agit d’un intégration sur
En revanche, le même calcul par différences finies (figure
les trois coordonnées d’espace. De même :
5.9), bien qu’exigeant sensiblement plus de temps calcul
Z
(c’est un schéma implicite qui requiert la résolution d’un
ρ̃(~q) = ρ(~r) ei~q.~r d3~r système linéaire 4096 × 4096, puisque le carré de 64 × 64
104 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

passage à trois dimensions peut se faire dans tous les cas

comme indiqué à la fin du paragraphe 5.2.2.2. Il faut toute-
fois noter que cela suppose, en pratique, un découpage de
l’espace en petits parallélépipèdes rectangles de cotés δx ,
δy , δz . On peut imaginer de réécrire les équations dans
un autre système de coordonnées, mais cela reste relative-
ment limité. Beaucoup de problèmes peuvent être ainsi
résolus, mais quid, par exemple, de l’écoulement de l’air
autour d’une aile d’avion, de la recherche des modes de
vibration d’une carrosserie de voiture ou du refroidisse-
ment d’une bouteille en verre moulée au sortir du moule ?
Les géométries complexes de ces problèmes risquent de mal
s’accomoder du découpage, très rigide, en petits cubes ou
en éléments très simples.
Dans les problèmes de géométrie compliquée, la
méthode des éléments finis est plus adaptée, ce qui en fait
un outil très répandu dans le monde industriel.

Figure 5.9 – Calcul par une méthode de différences finies

du même potentiel électostatique que dans la figure 5.8.

donne 642 = 4096 mailles) fournit un résultat bien plus

satisfaisant.
L’on retiendra de cet exemple que les hypothèses
inhérentes à la tranformée de Fourier discrète (périodicité,
etc.) peuvent jouer des tours comme on le sait. Il reste des
cas pour lesquels, à cause, par exemple, du volume des
calculs mis en œuvre, l’on n’a guère le choix que d’utiliser
la vitesse de la FFT : des précautions s’imposeront alors !

5.2.3.2 L’équation de Schrödinger (encore !)

Celle-ci s’écrit une fois de plus :

∂ψ(~r, t) h̄2 2
ih̄ − ∇ ψ(~r, t) + V (~r)ψ(~r, t)
∂t 2m
Si l’on applique la même méthode que ci-dessus, on ob- Figure 5.10 – Un exemple de maillage à deux dimen-
tient après quelques calculs sans difficulté bien qu’un peu sions pour le calcul des caractéristiques d’une aile d’avion
laborieux (on a trois transformées de Fourier spatiales et (http://fun3d.larc.nasa.gov/example-20.html).
une temporelle) :
Z Au lieu d’approximer les dérivées partielles comme
h̄2 ψ̃(ω, ~q) ′ ′ ′ dans l’équation (5.4), on approxime la fonction f (x, y, z)
−h̄ω ψ̃(ω, ~q) = − + Ṽ (~q − ~q)ψ̃(ω, ~q )d~q
2m q 2 recherchée par un développement local sur une base de
fonctions. On fait ainsi un maillage de l’espace (voir la
avec des notations similaires à ce qui précède. On obtient figure 5.10), en général avec de petits tétraèdres de tailles
sans grande surprise un produit de convolution. Celui-ci variables de telle façon que la géométrie du maillage suive
peut être très rapide à calculer si Ṽ (~q) est bien localisé d’assez près celle du problème : dans le cas de l’aile d’avion,
(i.e. V (~r) varie lentement) et donc l’intégrale aisée à cal- par exemple, les ≪ mailles ≫ seront plus petites et plus
culer ; au contraire, si V (~r) est localisé, avec des variations resserrées près du bord d’attaque de l’aile, là où le flux
rapides, le produit de convolution dans l’espace réciproque d’air subit les déviations les plus brutales, les champs
sera extrêmement laborieux à obtenir. . . on retrouve ici la de vitesse et de pression présentent des variations impor-
bonne vieille propriété des transformées de Fourier : avec tantes.
des fonctions localisées, on a généralement intérêt à tra- Dans chaque maille Mp , la fonction recherchée fait
vailler dans l’espace direct (l’espace de ~r), au contraire, l’objet d’un développement sur une base de fonctions
s’il s’agit de fonctions ≪ proches ≫ d’ondes planes, l’es- ϕ (x, y, z) :
j
pace réciproque (l’espace des ~q) est plus efficace.
X p
f (x, y, z) ≃ vj ϕj (x, y, z), (x, y, z) ∈ Mp
5.2.4 Introduction aux éléments finis j

Pratiquement tous les exemples ci-dessus sont unidi- les vjp étant les coefficients du développement dans cette
mensionnels pour des raisons de simplification évidente. Le maille.
Physique numérique, Philippe Depondt 105

Comme les fonctions ϕj sont connues, choisies par l’u- 5.3 La matière comme une collec-
tilisateur, leurs dérivées partielles sont calculables et les
dérivées partielles de f s’écrivent :
tion de particules.
Tous les problèmes ci-dessus, à l’exception bien sûr de
∂f (x, y, z) X p ∂ϕj (x, y, z)
≃ vj l’équation de Schrödinger, reposent sur une modélisation
∂x j
∂x à une échelle suffisamment grande pour que la structure
atomique de la matière n’intervienne pas. Lorsqu’on se
Très souvent, les fonctions ϕj sont tout simplement des préoccupe de question se situant à une échelle plus petite,
polynômes de telle façon que leurs dérivées soient faciles il faut bien sûr adopter une modélisation appropriée où la
à obtenir. matière est considérée comme constituée d’atomes.
En général, on se retrouve avec un très grand système
d’équations à résoudre dont les inconnues sont les coeffi- 5.3.1 Matrice dynamique
cients vjp .
A titre d’exemple, le problème du paragraphe 5.4 est On a vu, à propos des problèmes de valeurs propres (§
traité ici, bien qu’il soit absurde d’utiliser les éléments fi- 4.5.4), que beaucoup de questions pouvaient se ramener
nis dans ce cas qui se résout facilement par différences à un problème de matrice dynamique dont on cherche
finies ! Il s’agit simplement de montrer ici le principe de la les valeurs propres et les vecteurs propres. Pratiquement
méthode. Dans ce cas, les mailles sont de nouveaux des pe- tous les problèmes d’oscillateurs harmoniques couplés peu-
tits intervalles d’indice p. Sur un intervalle, la température vent être avantageusement abordés de la sorte. Plusieurs
s’écrit : problèmes de cet ordre, suffisamment différents pour mon-
trer la force de cette approche, sont décrits ci-dessous.
T (x) = ap x2 + bp x + cp

si 5.3.1.1 La chaı̂ne unidimensionnelle désordonnée

δxp δx Considérons d’abord la dynamique d’une chaı̂ne uni-
xp − < x < xp + p , δxp = xp − xp−1
2 2 dimensionnelle harmonique d’atomes : le problème est
mathématiquement assez proche de celui du paragraphe
où xp est le milieu du p-ième intervalle. La température
5.2.2.6. La chaı̂ne est représentée en figure 5.11 ; l’équation
n’est donc pas considérée comme une constante dans
du mouvement en est bien connue :
l’intervalle comme c’était le cas avec la méthode des
différences finies. La base de fonctions est ici limitée à trois
mẍℓ = κ(xℓ+1 − xℓ ) + κ(xℓ−1 − xℓ )
monômes de degrés 0, 1 et 2. Les inconnues sont les coeffi-
cients ap , bp et cp . Dans le p-ième intervalle, l’équation de où m est la masse des atomes tous identiques, κ la raideur
diffusion de la chaleur (5.8) s’écrit en tenant compte des des ≪ressorts ≫ et xℓ le déplacement par rapport à sa posi-
expressions des dérivées : tion d’équilibre de l’atome ℓ. La distance entre les positions
d’équilibre des atomes est a.
∂κ(xp )
(2ap x + bp ) + κ(xp )2ap = −Q̇(xp )
∂x
m κ
Cependant, la température doit être continue aux jonc-
tions des intervalles, soit : Figure 5.11 – La chaı̂ne linéaire unidimensionnelle
d’atomes identiques
ap (xp + δxp+1 )2 + bp (xp + δxp+1 ) + cp =
Dans ce genre de problème, on cherche des solutions de
2
ap+1 (xp + δxp+1 ) + bp+1 (xp + δxp+1 ) + cp+1 type onde plane où ω est la pulsation de l’onde, q son
vecteur d’onde :
De même les dérivées premières :
xℓ = x0 ei(ωt−qℓa)
2ap (xp + δxp+1 ) + bp = 2ap+1 (xp + δxp+1 ) + bp+1 et l’on obtient l’équation de dispersion habituelle :
r
On obtient ainsi un système de 3n équations à 3n incon- κ qa
ω=2 sin
nues (puisque l’on à une base de 3 fonctions, cela n’a rien m 2
à voir avec la dimensionnalité) que l’on peut résoudre par
les méthodes habituelles. Mais si le système présente du désordre, par exemple
si l’on introduit des impuretés, c’est-à-dire des atomes de
Si le principe en est simple, l’écriture de programmes
types différents, κ et m dépendent du site ℓ : κ doit être
d’éléments finis est assez lourde. Le maillage à lui seul
remplacé par κℓ,ℓ+1 (la raideur entre les sites ℓ et ℓ + 1)
n’est pas simple. Il s’agit cependant d’un problème assez
et m par mℓ ,
modulaire sur le plan informatique : le choix du maillage,
par exemple, est pratiquement indépendant du traitement mℓ ẍℓ = κℓ,ℓ+1 (xℓ+1 − xℓ ) + κℓ−1,ℓ (xℓ−1 − xℓ )
à proprement parler des équations aux dérivées partielles.
Ainsi, les utilisateurs semblent préférer utiliser des pro- On peut tenter une résolution analytique par des
grammes déjà existants qui, en général, s’adaptent assez méthodes perturbatives, mais le cas d’un fort désordre
bien à chaque problème particulier. Point n’est besoin de paraı̂t difficile à traiter et la généralisation à trois dimen-
réinventer ce qui existe déjà ! sions problématique (car le problème est en général traité
106 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

à l’aide d’une méthode dite de ≪ matrice de transfert ≫ in- 40

20
trinsèquement unidimensionnelle.) 10
3 5
Toutefois, on peut aussi poser :
2.5
uℓ
xℓ = √ eiωt 2
mℓ
1.5 freq
on se débarrasse alors de la dépendance temporelle, 1
mais on ne postule plus la périodicité spatiale comme
précédemment, puisque uℓ dépend de ℓ, c’est-à-dire du 0.5
site. On obtient le système d’équations suivant : 0
0 0.5 1 1.5 2 2.5 3
q
κℓ,ℓ−1
ω 2 uℓ = −√ uℓ−1
mℓ−1 mℓ
Figure 5.12 – Facteur de structure dynamique d’une
κℓ+1,ℓ + κℓ,ℓ−1 κℓ+1,ℓ chaı̂ne désordonnée de 100 atomes. Cela revient à la courbe
+ uℓ − √ uℓ+1
mℓ mℓ mℓ+1 de dispersion d’une onde acoustique dans la chaı̂ne. On ob-
serve une branche ≪ normale ≫ pour les basses fréquences
La matrice dynamique D de dimension n × n composées et une composante à haute fréquence due au désordre (les
des coefficients du système s’écrit : impuretés dans cet exemple étant plus légères).

D=
 
.. ..
. . 0 0 0
 
 .. .. .. 
 . . . 0 0 
 κ κℓ+1,ℓ + κℓ,ℓ−1 κℓ+1,ℓ 
 0 − √ ℓ,ℓ−1 0 
 mℓ−1 mℓ mℓ
−√
mℓ mℓ+1 
 
 .. .. .. 
 0 0 . . . 
 
.. ..
0 0 0 . .

et le problème revient à chercher  les valeurs propres ω 2 ,

u1
 u2 
 
 .. 
 . 
et les vecteurs propres U =  
 uℓ  de cette matrice
 
 . 
.
 . 
un
dynamique.
Comme pour l’exemple de la poutre 5.2.2.6, il y a
des programmes de bibliothèque qui font cela très bien !
(surtout si la matrice est creuse, ce qui est toujours le cas
–à 1-D, elle est même tridiagonale–).
La matrice U donne les déplacements atomiques en
fonction du numéro du site, autrement dit de la position
ri = a×i : une transformée de Fourier spatiale des vecteurs
propres doit donc donner quelque chose qui dépend du
vecteur d’onde q, or il y a également dépendance en fonc-
tion de la pulsation ω. On obtient alors S(q, ω), le ≪ fac-
teur de structure dynamique ≫ dont les maxima four- Figure 5.13 – Deux vecteurs propres. En haut, un vecteur
nissent ce qui tient lieu de ≪ courbe de dispersion ≫ (fig- propre du début de la courbe de dispersion (ω ≃ 0,6), peu
ure 5.12) qui ressemble à ce que pourrait donner une affecté par le désordre. En bas, un vecteur propre non-
expérience, par exemple, de diffusion inélastique de neu- propagatif, localisé sur des impuretés (ω ≃ 2,2).
trons.
On peut également regarder, ce qui paraı̂t pour le moins
difficile à réaliser expérimentalement, les mouvements cor- 5.3.1.2 Dynamique d’une molécule
respondants à différents points de la figure 5.12 : par ex-
La dynamique d’une molécule unidimensionnelle à trois
emple, en figure 5.13.
atomes sera d’abord décrite pour préciser les principes de
Ainsi, l’on peut directement établir une relation entre
la méthode de façon schématique, puis on généralisera à
des résultats ≪ expérimentaux ≫ et des processus qui ont
des cas plus généraux.
lieu au niveau microscopique.
.
Physique numérique, Philippe Depondt 107
s !
5.3.1.2.1 À une dimension, trois atomes. Soient m 1 m 2 m 3 (m 1 + m 2 + m 3 )
donc trois atomes alignés, de masses m1 , m2 et m3 . Ils 1 ± 1 − 4kk ′
k(m1 + m2 ) + k ′ (m2 + m3 )
sont liés par un potentiel harmonique, de telle façon que
l’énergie potentielle d’interaction entre 1 et 2 s’écrive Il ≪ suffit ≫ de réinjecter ces solutions dans l’équation
aux valeurs propres pour obtenir les vecteurs propres et
1 2 les déplacements atomiques correspondant à chaque valeur
V12 = k(x1 − x2 )
2 propre.
où x1 et x2 sont les déplacements des atomes 1 et 2 par
rapport à leur position d’équilibre. De même, 5.3.1.2.2 À trois dimensions, N atomes. On
réalise, à la lumière de l’exemple ci-dessus, que dès que la
1 ′ matrice dynamique a une dimension qui dépasse 3, le cal-
V23 = k (x2 − x3 )2
2 cul devient inextricable, or la dimension de D est le nom-
bre de degrés de liberté du système : pratiquement toutes
k k’ les molécules échappent à cette analyse ! Évidemment,
comme cela a déjà été montré, la résolution numérique
est beaucoup plus aisée.
m1 m2 m3 Essayons de poser le problème de façon plus générale :
On néglige l’interaction entre 1 et 3. Les équations du soit une molécule de N atomes de masses mℓ situées
mouvement s’écrivent simplement : aux coordonnées ~rℓ . On suppose que l’on est capable de
calculer l’énergie potentielle du système V ({~rℓ )}, ℓ ∈
m1 ẍ1 = k(x2 − x1) [1, N ]. On suppose également que l’on connait les positions
(0)
m2 ẍ2 = k(x1 − x2) + k ′ (x3 − x2 ) d’équilibre des atomes ~rℓ . Afin de simplifier les notations,
on pose que :
m3 ẍ3 = k(x2 − x3)
qk = rℓ,α ℓ ∈ [1, N ], α ∈ [1, 3], k = 3(ℓ − 1) + α
De la même façon que pour la chaı̂ne linéaire d’atomes, on
pose : où α indice les trois coordonnées de l’espace. L’indice k
u1 varie de 1 à 3N , c’est-à-dire le nombre de degrés de liberté
x1 = √ eiωt du système. Les équations du mouvement 2 s’écrivent :
m1
u2 iωt ∂V
x2 = √ e mk q̈k = − ∀k ∈ [1, 3N ]
m2 ∂qk
u3 iωt
x3 = √ e
m3 Les dérivées sont prises en {qk } : comme on s’intéresse à
un système harmonique, on peut faire un développement
ainsi : (0)
limité autour de la position d’équilibre {qk },
√ u2 u1
− m1 ω 2 u 1 = k( √ −√ ) ∂V ∂V X ∂2V
m2 m1 ({qk′ }) =
(0)
({qk′ }) +
(0)
′′ ({qk′ })(qk − qk )
′′
√ u1 u2 u3 u2 ∂qk ∂qk ∂q k ∂q
− m2 ω 2 u 2 = k( √ − √ ) + k′ ( √ −√ ) ′′ k k
m1 m2 m3 m2
√ u2 u3 Les dérivées de l’énergie potentielle à l’équilibre
− m3 ω 2 u 3 = k( √ −√ ) ∂V (0)
m2 m3 ({qk′ }) sont nulles, et les équations du mouvement
∂qk
En termes matriciels : se reécrivent :
   k  X ∂2V
− √mk1 m2 0 (0) (0)
u1 mk q̈k = ′ ({qk′′ })(qk − qk′ )
m1 ′
 ′
− √mk2 m3 
′ ∂q ∂q
U =  u2  D =  − √mk1 m2 k+k
m2  k
′ k k
′
u3 k′
0 − √mk2 m3 m3 (0)
En posant xk = (qk − qk ) (les déplacements par rapport
et à l’équilibre), on obtient :
ω 2 U = DU X
mk ẍk = − Ck,k′ xk′ (5.12)
La recherche des valeurs propres revient à la recherche k′
des racines de |D − ω 2 I| = 0 : a priori, cela donne un
polynôme en ω 6 , mais compte tenu de la solution ω = 0 où Ck,k′ est la matrice des dérivées secondes de l’énergie
correspondant à la translation d’ensemble de la molécule potentielle, ce qui nous ramène à une forme familière : il
(car |D| = 0), on obtient une équation bicarrée en ω : reste à appliquer la procédure habituelle,
uk
xk = √ eiωt
′
k(m1 + m2 ) + k (m2 + m3 ) 2 m1 + m2 + m3 mk
ω4 − ω +kk ′ =0
m1 m2 m3 m 1 m2 m 3 2. Ici, les variables sont des variables spatiales (x, y, z), mais, fort
souvent dans les systèmes mécaniques comportant par exemple des
soit contraintes, la situation est plus complexe : on a alors souvent intérêt
1 k(m1 + m2 ) + k ′ (m2 + m3 ) d ∂L ∂L
ω2 = × à utiliser les notations Lagrangiennes : L = K − V et = .
2 m1 m2 m3 dt ∂ q̇ℓ ∂qℓ
108 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

et en notations matricielles. A priori, la matrice G n’est pas

X Ck,k′
2
ω uk = √ uk ′ carrée puisqu’elle est (3N − 6 × 3N ).
mk mk ′ Ainsi les ceofficients qui apparaissent dans l’équation
k′
(5.12) peuvent s’écrire :
soit, comme avant :
∂2V
ω 2 U = DU Ck,k′ =
∂xk ∂xk′
Il est aisé de vérifier que la matrice D est symétrique. X ∂2V ∂Sℓ ∂Sℓ′
=
Si le formalisme est nettemement plus lourd que ∂S ℓ ∂S ℓ ′ ∂x k ∂xk′
ℓ,ℓ
′
précédemment, la physique est sensiblement la même ; X ∂2V
cependant la méthode qui vient d’être exposée a le mérite = gk,ℓ gk′ ,ℓ′ (5.13)
d’être d’utilisation quasiment automatique, à partir de la ∂Sℓ ∂Sℓ′
ℓ,ℓ′
connaissance des potentiels d’interaction et des positions
d’équilibre 3 . La matrice G nous donne ainsi, non seulement le lien entre
les coordonnées cartésiennes (pour lesquelles les équations
sont simples) et les coordonnées internes (pour lesquelles
le calcul de l’énergie et de ses dérivées et ≪ naturelle ≫),
1 mais aussi celui entre les coefficients de couplage dans les
deux systèmes.
2 Il reste à définir les Sℓ .
0 Il y a déjà 4 variables internes évidentes : les élongations
3 des quatre liaisons radiales :

S1 = ρ1 − ρ
(~ ~0 ) · ~e1
S2 = ρ2 − ρ
(~ ~0 ) · ~e2
4 S3 = ρ3 − ρ
(~ ~0 ) · ~e3
S4 = ρ4 − ρ
(~ ~0 ) · ~e4
Figure 5.14 – Une molécule tétraédrique, par exemple
CH4 ou C Cl4 . L’atome central est numéroté 0 et les quatre où les vecteurs ~ei sont les vecteurs unitaires le longs des
autres : 1, 2, 3, 4. liaisons (0, i) : ~ei = (~ri − ~r0 ) /|~ri − ~r0 |. On obtient alors
assez aisément :
5.3.1.2.3 Calcul pour une molécule tétraèdrique.
Imaginons, par exemple, une molécule tétraèdrique ~si,ℓ = ~eℓ si i = ℓ ℓ ∈ [1, 4]
(fig. 5.14) : a priori, comme on a 5 atomes et trois degrés de ~s0,ℓ = −~eℓ ℓ ∈ [1, 4]
liberté par atomes, soit quinze degrés de liberté en tout, la ~si,ℓ = 0 sinon.
matrice dynamique est (15×15). Toutefois la translation et  
la rotation d’ensemble de la molécule ne nous intéressent sxi,ℓ
y
pas : 3 degrés de liberté translationnels et 3 degrés de lib- où ~si,ℓ =  si,ℓ .
erté rotationnels (pour une molécule tri-dimensionnelle) ne szi,ℓ
sont pas pertinents ; de façon générale, pour une molécule Les angles entre les liaisons paraissent aussi être des
à N atomes, on doit aboutir à 3N − 6 variables internes variables assez naturelles, mais c’est un peu plus com-
et une matrice dynamique (3N − 6 × 3N − 6), soit (9 × 9) pliqué puisqu’un simple dénombrement donne θ12 (l’angle
ici. Comme nous sommes dans une approximation har- d de sommet l’atome 0 qui se situe entre les liaisons 0−1
102
monique, on considère que les déplacements ρ ~i , ∀i ∈ [1, N ] et 0 − 2), θ13 , θ14 , θ23 , θ24 , θ34 , c’est-à-dire six angles, or
des atomes par rapport à leurs positions d’équilibre ~ri sont il n’en faut que cinq puisqu’on a déjà quatre variables S1
petits, ainsi on peut écrire une relation linéaire entre les à S4 et qu’on en attend 9 en tout : c’est que ces angles ne
variables internes Sℓ , ℓ ∈ [1, 3N − 6] et les déplacements sont pas indépendants. On peut poser
atomiques :
XN X ~i − ~r0 − ρ
~ri + ρ ~0 ~hi
Sℓ = sα α ~εi = =
i,ℓ ρi |~ri + ρ
~i − ~r0 − ρ
~0 | |~hi |
i=1 α=x,y,z

où α représente les trois directions de l’espace et les sα

i,ℓ
La différence entre ~εi et ~ei est que le premier comprend les
sont les coefficients de ce développement au premier ordre. déplacements ρ ~i : à l’équilibre ces vecteurs sont identiques.
Si l’on écrit comme précédemment k = 3(i − 1) + α et On a :
xk = ραi , alors cos θi,j = ~εi · ~εj
X
Sℓ = gℓ,k xk avec gℓ,k = sα On peut différencier cette expression :
i,ℓ
k
d (cos θi,j ) = − sin θi,j dθi,j = d~εi · ~εj + ~εi · d~εj
ou
S=G·x où
3. Voir par exemple : E. B. Wilson Jr., J. C. Decius, P. C. Cross, d~hi |~hi | − ~hi d|~hi |
d~εi =
Molecular vibrations (1955) reéd. Dover (1980), chap. 4. |~hi |2
Physique numérique, Philippe Depondt 109

q 
1 2~hi · d~hi (et non finie comme dans le § 5.3.1.2.1) avec p atomes
or d~hi = ρ
~i − ρ
~0 , et d|hi | = d |~hi |2 = =
2 |~hi | par maille, ces mailles étant indéfiniment répétées. Chaque
~ei · (~
ρi − ρ
~0 ) = Si , ainsi : atome est en principe repéré par 2 indices, ℓ le numéro de
la maille (qui va de −∞ à +∞) et k le numéro de l’atome
~i − ρ
ρ ~0 Si dans la maille ℓ (k ∈ [1, p]). La position d’équilibre de
d~εi = − ~ei
|~ri − ~r0 | |~ri − ~r0 | l’atome k, ℓ est donc

En posant que les éléments différenciels dθi,j = ηi,j sont les Xk,ℓ = ℓa + Xk
variations angulaires correspondant au mouvements dits
≪ de libration ≫, on obtient après quelques lignes de cal- où a est le paramètre de maille et Xk la position dans la
cul : maille. Les déplacements des atomes par rapport à ces po-
|~ei ∧ ~ej | ηi,j = sitions d’équilibre sont xk,ℓ ; les équations du mouvement
  s’écrivent alors
~0 − ρ
ρ ~i ~0 − ρ
ρ ~j Si Sj
· ~ej + · ~ei + + ~ei · ~ej
|~ri − ~r0 | |~rj − ~r0 | |~ri − ~r0 | |~rj − ~r0 | m1 ẍ1,ℓ = cp,1 (xp,ℓ−1 − x1,ℓ ) + c2,1 (x2,ℓ − x1,ℓ )
Si l’on pose, par exemple : mk ẍk,ℓ = ck−1,k (xk−1,ℓ − xk,ℓ ) + ck+1,k (xk+1,ℓ − xk,ℓ )
S5 = η12 , S6 = η13 , S7 = η14 , S8 = η23 , S9 = η24 , S10 = η34 mp ẍp,ℓ = cp−1,p (xp−1,ℓ − xp,ℓ ) + c1,p (x1,ℓ+1 − xp,ℓ )

cela permet d’obtenir, où mk est la masse de l’atome de type k et les ck,k′ les
constantes d’interaction entre les atomes k et k ′ . On s’est
 
~e1 − ~e2 1 1 limité ici aux interactions entre premiers voisins, mais
~s05 = − on peut généraliser sans difficultés. . . autres que ≪ tech-
|~e1 ∧ ~e2 | |~r2 − ~r0 | |~r1 − ~r0 |
niques ≫ !
etc. Comme les mailles se succèdent en restant identiques
L’énergie potentielle de la molécule peut s’écrire en fonc- les unes aux autres, notre système est périodique et nous
tion des variables internes : pouvons chercher des solutions de type onde plane :
4
1X 2 1X 2
uk
xk,ℓ = √ ei(ωt−q(ℓa+Xk ))
ρk })
V ({~ = ρi − ρ
ki (~ ~0 ) + cij ηij (5.14) mk
2 i=1 2
i = 1, 3
j = i + 1, 4
où q est le vecteur d’onde de l’onde plane. Jusqu’ici, nous
10
1X n’avons rien fait de nouveau par rapport à la chaı̂ne unidi-
= ki Si2 mensionnelle à un type d’atomes, sinon des aménagements
2 i=1
pour tenir compte du nombre d’atomes par maille, ce qui
ne fait qu’alourdir les notations sans apporter grand-chose
Dans l’équation (5.14), le premier terme correspond à de nouveau. . . Si l’on poursuit dans la même voie, on doit
l’allongement des liaisons et le deuxième aux oscillations injecter ces expressions d’ondes planes dans les équations
latérales, les mouvements de libration. Les coefficients ki du mouvement ; on obtient :
et cij correspondent aux dérivées secondes de l’équation  
(5.13). up u1 −iqX1
−ω 2 u1 e−iqX1 = cp,1 √ e−iq(Xp −a) − e +
On constate que, dans cet exemple, la difficulté ne tient m1 mp m1
 
pas tant à la méthode elle-même qui n’a rien de partic- u2 −iqX2 u1 −iqX1
ulièrement nouveau par rapport à ce que l’on a déjà vu c 2,1 √ e − e
m1 m2 m1
dans les paragraphes précédents, mais dans une mise en  
uk−1 uk −iqXk
œuvre de la géométrie de la molécule. −ω 2 uk e−iqXk = ck−1,k √ e−iqXk−1 − e +
mk mk−1 mk
 
5.3.1.3 Dynamique de réseau uk+1 uk −iqXk
ck+1,k √ e−iqXk−1 − e
mk mk+1 mk
Cette technique qui utilise la matrice dynamique est  
up−1 up −iqXp
extensible à un réseau périodique d’atomes, c’est-à-dire −ω 2 up e−iqXp = cp−1,p √ e−iqXp−1 − e +
mp mp−1 mp
un cristal. Elle recouvre que qu’on appelle la ≪ dy-  
namique de réseau ≫ et elle est très utilisée pour in- u1 up −iqXp
c1,p √ e−iq(Xp +a) − e
terpréter des expériences de spectroscopie optique ou neu- mp m1 mp
tronique qui servent à déterminer les modes de vibrations
présents dans des systèmes qui peuvent être assez com- Après quelques manipulations simples, cela donne :
pliqués. Sa limite cependant est que les interactions en-
cp,1 e−iq(Xp −X1 −a) cp,1 + c2,1
tre les atomes doivent pouvoir être traités dans l’approx- ω 2 u1 = − √ up + u1
imation harmonique ce qui impose plusieurs contraintes : m1 mp m1
que les positions d’équilibre soient déjà connues, donc la c2,1 e−iq(X2 −X1 )
− √ u2
structure microscopique du matériau établie et que les m1 m2
déplacements atomiques restent suffisamment petits pour
ck−1,k e−iq(Xk−1 −Xk ) ck−1,k ck+1,k
qu’un développement limité au premier ordre des forces ω 2 uk = − √ uk−1 + uk
soit possible. mk mk−1 mk
Prenons, pour simplifier les notations, le cas unidimen- ck+1,k e−iq(Xk−1 −Xk )
− √ uk+1
sionnel : nous avons une chaı̂ne unidimensionnelle infinie mk mk+1
110 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

cp−1,p e−iq(Xp−1 −Xp ) cp−1,p + c1,p f

ω 2 up = − √ up−1 + up
mp mp−1 mp
c1,p e−iq(X1 −Xp +a)
− √ u1
mp m1

On constate qu’une fois de plus on tombe sur un

problème aux valeurs propres, la matrice dynamique étant
maintenant p × p, donc a priori moins grosse qu’avant. . .
toutefois, comme le vecteur d’onde apparaı̂t dans la ma-
trice, il faudra résoudre le problème un grand nombre
de fois, soit une fois pour chaque valeur souhaitée du
vecteur d’onde. La matrice dynamique elle-même est dev-
enue complexe à cause des termes en eiqx , toutefois les ter-
mes symétriques par rapport à la diagonale sont conjugués
l’une de l’autre : la matrice est hermitique et il suffira de
choisir un sous-programme de bibliothèque approprié.
x
5.3.2 Simulations Monte-Carlo. Figure 5.15 – Quand on recherche numériquement le min-
Dans un autre ordre d’idées, on peut ne pas connaı̂tre imum d’une fonction, on part d’un point de départ et
la structure microscopique d’un matériau et donc la l’on fait une analyse locale de la fonction afin de trou-
chercher sans se préoccuper de la dynamique. Si l’on con- ver un point –meilleur– qui peut servir de nouveau point
nait les constituants de ce matériau, on peut rechercher de départ (flèche pleine). La plupart des algorithmes est
l’état d’équilibre de ce système d’atomes à condition de incapable de suivre la trajectoire indiquée par la flèche
connaı̂tre les potentiels d’interaction atome-atome : tiretée. . .

V ({~ri })

où V est l’énergie potentielle de l’ensemble des atomes

du système considéré en fonction des distances inter-
atomiques ~ri . On écrit souvent V comme une somme de
potentiels à deux corps :
X
V ({~ri }) = vi,j (ri,j ) (5.15)
<i,j>
X
où le symbole désigne une somme sur toutes les paires
<i,j>
d’atomes (i, j) (il y en a n(n−1) 2 ) et vi,j (ri,j ) est l’énergie
potentielle de deux atomes i et j connaissant leur distance
ri,j , mais il arrive que l’on doive faire des choses plus com-
pliquées pour tenir compte du fait, par exemple, que l’in-
teraction entre deux atomes puisse être perturbée par la
présence d’un troisième.
C’est un problème de recherche du minimum d’une fonc-
tion d’un grand nombre de variables, les positions atom-
iques ; il existe des méthodes pour faire cela (e.g. gradient
conjugué), mais lorsqu’elles convergent vers un minimum,
il est très difficile de savoir s’il s’agit d’un minimum local
Figure 5.16 – Système de spins posés sur un réseau
ou DU minimum de la fonction (figure 5.15) !
triangulaire, par simulation Monte-Carlo. Une structura-
Il existe cependant une solution : les tirages au sort ou
tion complexe en vortex s’établit (E. Yu. Vedmedenko,
Monte-Carlo comme on l’a vu au paragraphe 4.11.6.
A. Ghazali, J.-C.S. Lévy Phys. Rev. B 59 (1999) 3329).
Les applications en sont nombreuses, voir par exemple la
figure 5.16. Comme le résultat dépend de la température,
on peut étudier l’évolution du système en fonction de la
température, ses éventuels changement de structure, les puissant, la possibilité de traiter des ≪ gros ≫ systèmes,
transitions de phase. On peut également introduire dans jusqu’à environ un million d’atomes, ce qui est large-
l’énergie potentielle des contraintes comme la pression ment suffisant pour un nombre incroyablement élevé de
extérieure et faire des études en fonction de cela. problèmes.
Contrairement à ce que l’on pourrait penser, cette
méthode est relativement rapide par rapport à d’autres La restriction principale vient de ce qu’on n’a pas accès
méthodes microscopiques. On est, certes, dans le domaine aux mouvements atomiques en fonction du temps ou aux
du calcul lourd, les temps de calcul se chiffrent en heures fréquences des modes de vibration, ou seulement de façon
ou en jours, mais on a, avec un ordinateur moyennement très indirecte.
Physique numérique, Philippe Depondt 111

5.3.3 Simulations de dynamique molé- PBC

culaire.
Si l’on veut étudier la dynamique d’un système Substrate Adsorbate
d’atomes, le plus simple est de s’attaquer à la résolution
numérique des équations du mouvement (classiques) de ce
système :

PB
mℓ ~r̈ℓ = f~ℓ (~r1 . . . ~rℓ′ . . . ~rN ),

C
∀ℓ ∈ [1, N ]
où :  
∂V
 ∂xℓ 
 
  Figure 5.18 – Un exemple de simulation de dynamique
f~ℓ = −grad~ V = −  ∂V 
ℓ  ∂y  moléculaire pour étudier le frottement d’un adsorbat sur
 ℓ 
 ∂V  un substrat. La substrat est constitué de 18×18×4 mailles
cubiques à faces centrées. Chacune des deux surfaces libres
∂zℓ
est recouverte d’une monocouche de 288 atomes d’un autre
et, par exemple avec un potentiel d’interaction de paire de type (soit un total de 5760 atomes). L’on exerce des forces
type Lennard-Jones (figure 5.17) : extérieures opposées sur l’adsorbat et le substrat afin de
 12  6 ! les faire glisser l’un sur l’autre (Ph. Depondt, A. Ghazali,
1X 1X σij σij
V = V (~rij ) = εij −2 J.-C. S. Lévy, Surf. Science 419 (1998) 29).
2 i,j 2 i,j rij rij
(5.16)
On a perdu, par rapport à la méthode de Monte-Carlo,
deux ordres de grandeur pour le nombre d’atomes max-
1
imum que l’on peut inclure dans le système, mais en
contrepartie, comme on a la dynamique, on peut suivre
0.5 l’évolution temporelle du système, étudier les vibrations
(la gamme de fréquence accessible est celle des vibrations
0 acoustiques dans la matière condensée).
Le même type de simulation peut servir pour l’étude
de systèmes fort différents et très divers comme les grains
−0.5
d’un tas de sable ou les étoiles dans une galaxie !

−1
5.3.4 Simulations ab-initio.
0 1 2 3 4 5
Toutefois, la faiblesse des méthodes ci-dessus, simula-
Figure 5.17 – Le potentiel de Lennard-Jones de l’équation tion Monte-Carlo ou dynamique moléculaire, est qu’elles
(5.16), pour σij = 1 et εij = 1. Le potentiel est attractif supposent que les potentiels d’interaction soient connus
pour rij > σij , répulsif dans le cas contraire, la distance et modélisables avec une précision suffisante. Les expres-
d’équilibre étant σij . sions de type Lennard-Jones ou analogues ne sont que des
modèles dont on espère qu’ils rendent compte de la réalité
Il s’agit d’un très gros système d’équations de manière satisfaisante. Il arrive que ce ne soit pas le
différentielles dépendantes du temps que l’on peut cas, simplement parce que l’on ne dispose pas d’expression
résoudre numériquement par les méthodes habituelles (en analytique valide dans un domaine suffisant de distances
général Verlet). Cela suppose toutefois que l’on dispose interatomique, ou bien que l’interaction soit modifiée par
de modèles d’interaction entre les atomes, par exemple l’environnement :
Lennard-Jones comme ci-dessus. – quand on simule une surface, le nombre de voisins
Avec un ordinateur ≪ raisonnablement ≫ puissant, l’on d’un type d’atome donné n’est pas le même selon que
atteint sans difficulté majeure les ordres de grandeurs suiv- l’atome considéré est dans le cœur de l’échantillon ou
ants (voir par exemple les figures 5.18 et 5.19) : en surface : la forme de l’interaction de cet atome avec
nombre d’atomes : N ≃ 104 ces voisins peut en être affectée
longueurs d’onde accessibles : λ ≤ 10nm – des atomes ou des molécules dont les nuages
pas de temps d’intégration : δt ≃ 10−3 ps électroniques sont fortement modifiés par la présence
durée accessible : τ ≃ 103 ps ou non d’autres atomes,
fréquences accessibles : 10−2 tHz ≤ ν ≤ 10tHz – si l’on comprime le milieu de façon que les noyaux
A priori, on travaille à E = K + V = Cste et à vol- se rapprochent suffisemment pour modifier les nuages
ume constant, mais on peut aussi fixer P et T . Maintenir électroniques
la pression constante, plutôt que le volume est utile pour – ...
simuler des transitions de phase ou des changements struc- On peut introduire des potentiels à trois corps, voire
turaux, voire simplement tenir compte de la dilatation. plus, afin de tenir compte de l’effet que la présence d’un
Maintenir la température constante permet de traiter par troisième atome peut avoir sur l’interaction entre deux
exemple des phénomènes dissipatifs, tels que diffusion de autres atomes, on peut également introduire des charges
la chaleur à l’échelle microscopique. qui peuvent se déplacer dans certaines conditions : tous
112 Licence de physique L3 : PHYTEM,
Figure 5.19 – Vue de dessus de l’adsorbat (gris sombre) et d’une couche du substrat (gris clair) de la figure 5.18, à
gauche avant glissement, à droite après.
ces modèles restent cependant assez phénoménologiques.
Toutefois, dès que l’on s’intéresse, par exemple, aux liens sions : la discrétisation implique un triplet d’indices (i, j, k)
entre propriétés structurales et propriétés électroniques
d’un matériau, on peut aussi tenter de revenir aux
principes fondamentaux et faire ce que l’on appelle des
simulations ab-initio (à partir du début). Dans ce cas,
on ne fait pas d’hypothèse sur la forme des interactions et l’équation de Schrödinger se reécrit comme avant
mais on considère un ensemble de noyaux avec leurs nu-
ages électroniques. En principe, on doit alors résoudre
l’équation de Schrödinger de n noyaux de numéro atom-
Xn
ique Zi et Zi électrons en interaction.
i=1
5.3.4.1 Une petite contrariété
Malheureusement, on ne peut pas attaquer le problème
avec des méthodes comme celle étudiée dans le paragraphe
5.2.2.4 : il n’existe pas au monde d’ordinateur assez puis-
sant pour le faire ! Pour illustrer ce propos, revenons à
l’équation de Schrödinger indépendante du temps à une
dimension et à une particule dans un potentiel : c’est le
cas le plus simple. La fonction d’onde ψ qui décrit l’état du
système est une fonction à une variable, et l’on obtient 4 :
∂ 2 ψ(x)
Hψ = Eψ ≡ − + V (x)ψ(x) = Eψ(x)
∂x2
En discrétisant le problème de la façon habituelle,
xi = i δx, Vi = V (xi ), ψi = ψ(xi )
l’équation se reécrit :
ψi+1 − 2ψi + ψi−1
− + Vi ψi = Eψi
δx2
Il est aisé de se convaincre que, chercher E et ψi , i ∈ [1, n],
revient à chercher les valeurs propres et les vecteurs pro-
pres d’une matrice (n×n) : si n est de l’ordre de 100, voire
davantage, il n’y a rien de bien extraordinaire à cela.
h̄2
4. en posant = 1.
2m
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Imaginons maintenant le même problème à trois dimen-
xi = i δx, yj = j δy, zk = k δk
ψi,j,k = ψ(xi , yj , zk ) Vi,j,k = V (xi , yj , zk )
ψi+1,j,k − 2ψi,j,k + ψi−1,j,k
−
δx2
ψi,j+1,k − 2ψi,j,k + ψi,j−1,k
−
δy 2
ψi,j,k+1 − 2ψi,j,k + ψi,j,k−1
−
δz 2
+Vi,j,k ψi,j,k = E ψi,j,k
Le triplet (i, j, k) prend alors n3 valeurs 5 , ainsi la ma-
trice dont on cherche les valeurs propres est de dimension
n3 × n3 , soit 106 ×106 si n = 100 : le problème s’est brutale-
ment amplifié de façon démesurée. . ., et nous n’en sommes
encore qu’à une seule particule ! Passons à un problème a
priori simple, l’atome d’hydrogène : un proton et un neu-
tron, soit deux particules en interaction, à trois dimen-
sions, soit 6 variables. Le même raisonnement nous mène
à estimer l’ordre de grandeur du problème à 1012 × 1012
(toujours avec 100 points par variable) : même avec un
ordinateur très puissant, c’est sans espoir !
Conclusion : il ne suffit pas, pour résoudre un problème,
de ≪ le mettre dans l’ordinateur ≫ et d’attendre que la
force brute de la machine fasse son œuvre. Il faut donc
faire des approximations.
5.3.4.2 L’approximation de Born-Oppenheimer
La première étape consiste à découpler les mouvements
des électrons de ceux des noyaux beaucoup plus lourds
5. en général, on renumérote les sites pour n’avoir qu’un seul
indice ℓ = i + n(j − 1) + n2 (k − 1) dont on vérifie aisément qu’il varie
de 1 à n3 .
Physique numérique, Philippe Depondt 113

et beaucoup plus lents (c’est l’approximation de Born- de manière auto-cohérente : on choisit d’abord un ensem-
[0]
Oppenheimer). Pour le mouvement des noyaux, on se con- ble de fonctions d’onde d’essai ϕi (~ri ) qui permettent de
tente en général d’une dynamique classique. Cette dy- calculer les termes Ji,j . Cela permet de résoudre le système
namique est lente par rapport à celle des électrons, ainsi, [1]
d’équations qui donne de nouvelles fonctions ϕi (~ri ) et des
on fait l’hypothèse que le nuage électronique est toujours [1]
valeurs des énergies εi . De nouvelles valeurs de Ji,j sont
en équilibre, qu’il s’adapte instantanément à un change- [2]
alors calculées puis de nouvelles fonctions ϕi (~ri ) et ainsi
ment de configuration des noyaux. D’un point de vue
de suite jusqu’à ce que les solutions trouvées n’évoluent
quantique, il ne reste plus qu’à résoudre l’équation de
plus.
Schrödinger électronique : pour l’hydrogène, on revient à
C’est ce qu’on appelle la méthode de Hartree. Elle
un problème à une particule. Le problème reste cependant
présente un énorme défaut : a priori, les électrons sont
entier dès lors que l’on s’intéresse à, ne serait-ce qu’un
des fermions et leur fonction d’onde devrait être anti-
atome d’hélium isolé. Il faut donc encore aller quelques
symétrique, c’est-à-dire changer de signe par permutation
pas plus loin : il existe à ce titre plusieurs approches pos-
de deux électrons :
sibles.
ψ(~r1 , . . . , ~ri , ~rj , . . . , ~rn ) = −ψ(~r1 , . . . , ~rj , ~ri , . . . , ~rn )
5.3.4.3 Les méthodes de Hartree et Hartree-Fock
Si l’on choisit de remplacer cette fonction d’onde par un
Imaginons d’abord, pour simplifier, une fonction à deux simple produit de fonctions mono-électroniques, il est clair
variables ψ(x1 , x2 ) : on peut en faire un développement que cette propriété ne sera pas remplie. Pour régler cette
à un ordre quelconque par rapport à x2 , sur une base de question, on remplace ce produit pas un déterminant, ap-
fonctions appropriées ϕℓ2 (x2 ) : pelé déterminant de Slater :
X
ψ(x1 , x2 ) = cℓ2 ϕℓ2 (x2 ) χ1 (~r1 ) χ2 (~r1 ) ... χn (~r1 )
ℓ2 χ1 (~r2 ) χ2 (~r2 ) ... χn (~r2 )
ψ(~r1 , ~r2 , . . . , ~rn ) ∼
... ... ... ...
mais, évidemment, les coefficients du développement cℓ2 χ1 (~rn ) χ2 (~rn ) ... χn (~rn )
sont des fonctions de x1 , suscptibles d’un développement
analogue : X qui assure la propriété d’antisymétrie : si l’on permute
cℓ2 (x1 ) = aℓ1 ,ℓ2 φℓ1 (x2 ) deux électrons, cela revient à permuter deux lignes et
ℓ1 donc à changer le signe du déterminant. Ainsi corrigée,
et : la méthode s’appelle la méthode de Hartree-Fock : bien
X qu’assez lourde et nécessitant un travail non-trivial de
ψ(x1 , x2 ) = aℓ1 ,ℓ2 φℓ1 (x1 )ϕℓ2 (x2 )
modélisation des fonctions χℓ , elle est très utilisée, no-
ℓ1 ,ℓ2
tamment par les chimistes théoriciens, pour des calculs de
On peut, bien sûr généraliser ce genre de raisonnement fonctions d’onde moléculaires.
à un nombre quelconque de variables. Maintenant, l’ap-
proximation est faite d’entrée de jeu et elle est massive : 5.3.4.4 Théorie de la fonctionnelle densité
on remplace la fonction d’onde poly-électronique par un
produit de fonctions d’onde mono-électroniques, ce qui re- La théorie de la fonctionnelle densité (Density func-
vient à se limiter au premier ordre du développement : tional theory ou DFT 7 ) est, elle, une théorie, au départ,
exacte, mais dont la mise en œuvre pratique oblige à des
ψ(~r1 , ~r2 , ~r3 . . . , ~rn ) ∼ ϕ1 (~r1 ) ϕ2 (~r2 ) ϕ3 (~r3 ) . . . ϕn (~rn ) approximations.
L’idée qui sous-tend la méthode est que le détail des
On montre après quelques calculs 6 que le problème s’écrit : fonctions d’onde de tous les électrons n’est pas ce dont on a
  réellement besoin : la densité électronique ρ(~r) suffit bien.
X N X Le résultat de cela, si c’était possible, serait de substituer à
− ∆i Zi
+ < ϕj |
1
|ϕj > ϕi (~ri )
2 ~I| |~ri − ~rj | une fonction compliquée de 3n variables ψ(~r1 , ~r2 , . . . , ~rn ),
I=1 |~ ri − R j
une fonction de trois variables, ρ(~r) telle que
Z
= εi ϕi (~ri ) ∀i 2
ρ(~r) = n |ψ(~r, ~r2 , . . . , ~rn )| d~r2 . . . d~rn
où ∆i est l’opérateur laplacien relatif à l’électron i :
Il n’est pas évident a priori qu’une telle opération soit
∂2 ∂2 ∂2
∆i = + 2+ 2 possible, car en considérant l’équation de Schrödinger, si
∂x2i ∂yi ∂zi on essaye d’intégrer, en multipliant à gauche par ψ ∗ , sur
toutes les positions, sauf une, pour faire apparaı̂tre la den-
R~ I la position du noyau I, ~ri celle de l’électron i
sité électronique,
et εi l’énergie de l’état ϕi . On obtient un système Z Z
d’équations couplées par l’intermédiaire du terme d’in-
1 ψ Hψ d~r2 . . . d~rn = ψ ∗ Eψ d~r2 . . . d~rn = E ρ(~r)
∗

teraction électron-électron Ji,j =< ϕj | |ϕj > qui

|~ri − ~rj |
mélange les termes liés à i et j. On résout alors ce système le deuxième membre ne pose pas de problème parce que
E est un nombre scalaire, et la densité électronique vient
6. il n’est pas question ici de détailler ces méthodes, mais seule-
ment d’en donner a flavor, un parfum, comme disent les anglo- 7. à ne pas confondre avec l’autre DFT, la discrete Fourier trans-
saxons. form.
114 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

naturellement. En revanche, le premier membre comporte En effet, la densité électronique ne fait pas apparaı̂tre ex-
un opérateur (avec des dérivées, etc.) que l’on ne peut pas plicitement ces effets 11 , il faut les introduire explicitement
commuter avec la fonction d’onde 8 . ≪ à la main ≫ pour ainsi dire. . . C’est ici que se situent les

Des théorèmes dûs à Hohenberg et Kohn montrent que approximations de cette théorie : les différentes variantes
si, dans l’approximation de Born-Oppenheimer, on écrit (qui s’appellent pour les plus répandues LDA et GGA)
l’Hamiltonien comme partent en général de l’approximation que ρ(~r) est essen-
tiellement homogène, ou du moins, varie lentement.
H = Te + Vee + Vext Les méthodes ab-initio ne sont donc pas des méthodes
sans hypothèse mais elle permettent néanmoins d’attein-
où l’on a décomposé en énergie cinétique des électrons dre les interactions interatomiques très précisément en ten-
(Te ), énergie potentielle d’interaction électron-électron ant compte, par exemple, de la déformabilité des nuages
(Vee ) et interaction électrons-noyaux (Vext ), les deux pre- électroniques en fonction des positions de noyaux.
miers termes ne dépendent que du nombre d’électrons, ils Leur gros défaut est que, même s’il existe des méthodes
sont pour ainsi dire universels. Le dernier terme dépend de calcul efficaces, ces méthodes sont terriblement voraces
des noyaux et donc du système étudié. L’énergie de l’état en temps de calcul !
fondamental peut alors s’écrire comme une fonctionnelle 9 Ainsi des ordres de grandeurs réalistes seraient :
de la densité électronique
Z <
N ∼ 300
E(ρ) = F (ρ) + ρ(~r)Vext (~r)d~r
τ ≃ 1ps
où F (ρ) regroupe les deux premiers termes universels et ρ Malgré ces défauts, elles ont leurs lettres de noblesse,
est la densité électronique -que l’on cherche- de l’état fon- par exemple, les phases à haute pression de la glace (li-
damental. Pour obtenir ρ, il faut alors chercher la fonction aison hydrogène) ou la silice vitreuse. Ces méthodes font
ρ qui rend E(ρ) minimum avec, bien sûr, la contrainte que l’objet de programmes, soit commerciaux, soit libres, qui
Z se répandent assez rapidement dans les laboratoires pour
ρ(~r)d~r = N devenir des outils relativement standards.
Cependant, comme on l’a vu, ces méthodes se limi-
le nombre d’électrons dans le système. tent à l’état électronique fondamental. . . lorsqu’on veut
La petite difficulté qui subsiste et que l’expression de s’attaquer à des états excités, pour comparer les calculs
F (ρ), bien qu’universelle, est inconnue ! (c’est quelque avec des expériences de spectroscopies diverses, il existe
chose comme < ψ|Te + Vee |ψ > mais le but de l’opération d’autres méthodes plus complexes et plus coûteuses encore
était justement d’ignorer les fonctions d’ondes). en ressources de calcul ! Autant dire que c’est un domaine
La méthode de Kohn et Sham 10 consiste à réaliser que, dans lequel la recherche est active en ce début du XXIe
puisque ce qui nous intéresse est la densité électronique siècle. . .
et non les fonctions d’onde, n’importe quel jeu de fonc-
tions d’onde qui donne la même densité électronique
est acceptable ! Ainsi, on remplace un système de N
électrons en interaction par N autres particules fictives
mais indépendantes ; chacune de ces particules fictives est
soumise à un potentiel effectif qui contient le potentiel
extérieur Vext et l’effet des électrons. On en arrive à une
théorie similaire à celle de Hartree-Fock, mais elle n’est
pas le résultat d’une approximation, elle est, jusqu’à ce
point au moins, exacte.
Z
E(ρ) = Ts (ρ) + EH (ρ) + ρ(~r)V (~r)d~r + Exc (ρ)

où Ts est l’énergie d’un système sans interaction, EH

l’énergie de Hartree,
Z Z
1 ρ(~r)ρ(~r′ )
EH (ρ) = d~r d~r′
2 |~r − ~r′ |
Les trois premiers termes peuvent être calculés sans
problème particulier ; toutes les difficultés résident dans le
terme Exc , dit ≪ d’échange et corrélation ≫. Si on l’oublie,
ce sont les effets quantiques qui disparaissent de la théorie !
8. Parce que l’opérateur dérivation, par exemple, s’applique à ce
qui se trouve à sa droite et non à ce qui se trouve à sa gauche :
∂ ∂ ∂
f ∗ (x) ∂x f (x) 6= f ∗ (x)f (x) ∂x = |f (x)|2 ∂x .
9. Une fonctionnelle est une fonction dont la variable est une
autre fonction, E est une fonction de ρ, elle-même une fonction de 11. comme le principe d’exclusion qui rend la fonction d’onde
~
r. antisymétrique par permutation de deux atomes : cela n’apparaı̂t
10. Ces théories datent des années 1960. évidemment pas explicitement dans la densité électronique.
Chapitre 6

Optimisation de code.

L’optimisation de code n’est certes pas un sujet très ! les constantes sont calculees hors de la boucle
exaltant, surtout que les calculs décrits ci-dessus sont en pi = acos(-1.0)
général rapidement exécutés même sur un PC de puis- iomega = 2*pi*freq*(0.,1.) ! nbr complexe
sance médiocre. Il faut cependant être prudent : si l’on do it = itmin, itmax
ne fait pas attention, on arrive facilement à fabriquer des x = exp(iomega*it*dt)
problèmes très lourds ! Imaginons par exemple que l’on enddo
cherche, par Monte-Carlo-Metropolis, la structure d’un en-
semble de quelques dizaines de milliers d’atomes (un tout on imagine aisément que la seconde sera plus rapide !
petit échantillon) en interaction à diverses température
afin d’obtenir un diagramme de phase : la figure 4.49, 6.2 Utiliser les symétries.
par exemple, représente des journées de calcul. . . Les
méthodes ab-initio décrites dans le paragraphe précédent Le deuxième exemple est un peu plus élaboré : on doit
sont évidemment redoutablement voraces ! Il faut donc calculer, par exemple pour une simulation Monte-Carlo
utiliser des méthodes de programmation efficaces afin d’en l’énergie potentielle d’un ensemble d’atomes en interac-
réduire autant que possible le coût en ressources informa- tion :
tiques. Par exemple, si l’on arrive à optimiser un calcul de 1 X
V = vij (rij )
telle façon qu’au lieu de 24 heures, il n’en prenne que 15, 2
i,j,(j6=i)
non seulement le gain est appéciable dans l’absolu, mais
on peut espérer démarrer un calcul le soir avant de ren- soit sous forme de programme :
trer chez soi pour en récuperer les résultats le lendemain
v = 0.
matin : les ordinateurs sont des machines qui peuvent tra-
do i = 1, n
vailler la nuit sans inconvénient, leurs utilisateurs des hu-
do j = 1, n
mains qui préfèrent dormir. . .
if ( i /= j ) then
Une première précaution à prendre est d’utiliser les op-
rij = sqrt( (x(i)-x(j))**2 + &
tions d’optimisation du compilateur, par exemple avec
(y(i)-y(j))**2 + (z(i)-z(j))**2 )
g95 :
v = v + energie(rij)
g95 -O3 simul.f90 -o simul
endif
où l’option -O3 dit au compilateur de chercher à optimiser
enddo
le code proposé 1 . Le compilateur néanmoins, même s’il est
enddo
parfois étonnament efficace, ne peut pas tout faire et il est
v = v/2
prudent d’appliquer soi-même quelques règles simples.
ce qui donne n(n − 1) calculs d’énergie à faire. Or, on cal-
cule ici la même énergie deux fois : vij et vji , c’est inutile.
6.1 Éviter les calculs inutiles n(n − 1)
Si l’on s’y prend un peu mieux, il n’y a que paires
2
C’est une consigne qui paraı̂t stupide à première vue, (i, j) : en pratique, le programme ci-dessus fait deux fois
cependant, si l’on compare les deux séquences suivantes : trop de calculs !
Celui qui est donné ci-dessous est nettement meilleur :
! les constantes sont calculees dans la boucle
do it = itmin, itmax do i = 1, n-1
t = i*dt ; pi = acos(-1.0) do j = i+1, n
omega = 2*pi*freq rij = sqrt( (x(i)-x(j))**2 + &
x = exp((0.,1.)*omega*t) ! exp complexe (y(i)-y(j))**2 + (z(i)-z(j))**2 )
enddo v = v + energie(rij)
enddo
et enddo
1. il y a en général plusieurs degrés d’optimisation : -O1, -O2, Ainsi donc, la simple étude préalable de la symétrie d’un
-O3. Sur un PC avec un processeur Pentium, on peut tenter aussi :
-mtune=pentium4. Chaque compilateur a ses propres options, plus
problème permet parfois des gains considérables : point
ou moins adaptées à tel ou tel processeur : c’est parfois un peu n’est besoin de refaire plusieurs fois un calcul qui donnera
labyrinthique. . . toujours, pour des raisons de symétrie, le même résultat.

115
116 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

6.3 Stocker des résultats intermé- 6.4 Utilisation des caches

diaires. Dit ainsi, cela paraı̂t très savant, toutefois l’idée sous-
jacente est très simple. Un des goulets d’étranglement
Imaginons que nous devions faire le produit de trois
principaux d’un ordinateur est l’échange d’information
matrices n × n :
entre la mémoire vive où est stockée l’information, pro-
D=A·B·C gramme et données, et le processeur où s’effectuent les
soit : calculs. Sur certaines machines, cette communication est
X
di,j = ai,k bk,l cl,j améliorée grâce à du matériel performant, mais ce sont
k,l des technologies coûteuses. Sur la plupart des ordinateur
d’usage courant pour le calcul scientifique, les construc-
ce qui se programme aisément : teurs préfèrent utiliser une ≪ mémoire cache ≫, c’est-à-
do i = 1, n dire un espace mémoire, de plus petite dimension que la
do j = 1, n mémoire vive, très rapide et installée de façon que le pro-
d(i,j) = 0. cesseur n’ait pas besoin de passer par les moyens normaux
do k = 1, n de communication pour y accéder. Ainsi, pour optimiser
do l = 1, n les transferts, au lieu de transmettre les données une à
d(i,j) = d(i,j) + a(i,k)*b(k,l)*c(l,j) une, lorsque le processeur a besoin de quelque chose dans
enddo la mémoire vive, tout un bloc lui est transmis. De cette
enddo façon, les données contigües en mémoire de celle qui est
enddo requise sont également transmises au processeur.
enddo
La conséquence en est que si, idéalement, toutes les
Cela représente quatre boucles de n éléments, soit n4 cal- données nécessaires à l’exécution du programme se trou-
culs à faire. Si n vaut ne serait-ce que 100, on obtient vaient dans ce bloc, il n’y aurait plus besoin que d’une
la bagatelle de 108 (cent millions) de calculs. . . On peut requête au début et une autre à la fin du travail, résultant
cependant prévoir un tableau intermédiaire e(n,n) pour en une accélération considérable du calcul.
stocker le produit B · C. Le produit des trois matrices est Il est évidemment très difficile de faire que toutes
alors décomposé en deux : les données nécessaires soient rangées dans la mémoire
cache, cependant, on peut retenir de ceci qu’il est bon
E = B·C que les données nécessaires soient contigües en mémoire
vive : elle seront ainsi transférées par bloc au processeur
D = A·E
au lieu d’être transférées une à une. Pour faire cela, il
On obtient alors le morceau de programme suivant : suffit de se rappeler que les éléments des tableaux sont
rangés l’un à côté de l’autre en mémoire et que donc
do i = 1, n les transferts de tableaux sont plus efficaces que ceux
do j = 1, n de scalaires : cependant il est très rare que l’on ait à
e(i,j) = 0. transférer des scalaires en très grand nombre et le gain
do k = 1, n est faible : il n’est pas utile de fabriquer artificiellement
e(i,j) = e(i,j) + b(i,k)*c(k,j)
des tableaux pour regrouper des éléments disparates. En
enddo
enddo
revanche, cela a une conséquence très importante pour les
enddo tableaux multi-dimensionnels. Par exemple, en fortran,
do i = 1, n un tableau bidimensionnel x(m,n) est stoké comme suit :
do j = 1, n x(1,1),x(2,1),...,x(m,1),x(1,2),x(2,2),...,
d(i,j) = 0. x(m,2),x(1,3),x(2,3),...,x(m,n)
do k = 1, n c’est-à-dire que ≪ le premier indice va plus vite ≫ (c’est
d(i,j) = d(i,j) + a(i,k)*e(k,j) le contraire en langage C). Donc la séquence :
enddo
enddo do j = 1, n
enddo x(:,j) = .....
enddo
C’est un peu plus compliqué, ça prend plus de mémoire,
mais il n’y a plus que 2 × n3 opérations à faire (soit, dans sera sans doute plus rapide que :
le cas de n = 100, 2 × 106 , deux millions d’opérations, un
gain d’un facteur 50 par rapport au cas précédent !) Si l’on do i = 1, m
regarde d’un peu plus près le premier calcul, on s’aperçoit x(i,:) = .....
que le produit b(k,l)*c(l,j) ne dépend pas de i : or on enddo
refait le même calcul pour toutes les valeurs de i, n fois puisque, dans le premier cas, le processeur va travailler sur
trop souvent. . . les données dans l’ordre où elles sont rangées en mémoire
En fait, la version qui utilise les tableaux globalement et le compilateur n’aura aucun mal à optimiser les trans-
s’écrit beaucoup plus facilement : ferts de blocs.
d = matmul(a,matmul(b,c)) Exercice : dans le cas du produit de trois matrices ci-
dessus, constater que l’on ne peut pas appliquer directe-
qui est transparent de ce point de vue, bien que com- ment ce principe. Introduire un tableau supplémentaire
prenant le même nombre de calculs. s(k) qui permette de le faire (pour chaque i, copier
Physique numérique, Philippe Depondt 117

b(i,k) dans s(k) et utiliser s dans le produit, puis faire
la même chose pour a).
Évidemment, tout ceci suppose d’entrer un peu dans
l’architecture de l’ordinateur que l’on utilise, mais l’essen-
tiel des machines en service actuellement suit peu ou prou
la même logique et un programme efficace sur un PC a de
bonnes chances de l’être également sur d’autres machines
(j’ai écrit et optimisé des programmes sur un PC 486 -
déjà périmé à l’époque - sous DOS qui se sont révélés très
efficaces sur. . . CRAY, une machine vectorielle de concep-
tion très différente : seulement l’une et l’autre travaillaient
efficacement sur les tableaux de nombres contigus).
Ce qui est vrai des données l’est aussi pour les instruc-
tions du programme. Les instructions qui se suivent dans
un programme se suivent également en mémoire, mais l’ap-
pel à un sous-programme ou à une fonction brise souvent
cette séquence ce qui produit en général un appel à la
mémoire vive et donc un ralentissement. Afin de conserver
l’avantage considérable de la programmation structurée
permise par les sous-programmes et fonctions, les compi-
lateurs permettent en général ce que l’on appelle l’≪ in-
lining ≫, c’est-à-dire qu’ils recopient un sous-programme
beaucoup utilisé directement dans le programme appelant
de façon que les instructions se succèdent en mémoire.
Donc, si l’on a écrit une structure qui ressemble à :
do i = 1, beaucoup
call machin(arg1,arg2,...)
enddo
il peut être habile de consulter le manuel du compilateur
utilisé afin de chercher à invoquer l’in-lining.
6.5 Eviter les interruptions
Imaginons un calcul du champ magnétique subi par un
spin, dû à tous les autres spins :
X s’adresser à un centre de calcul disposant d’ordinateurs
~i =
H ~ ij
H puissants et s’attaquer à de la programmation parallèle,
j
j6=i
6.6 Ne pas réinventer ce qui existe
déjà
En général, les bibliothèques de calcul scientifique,
quand il y en a, implantées sur un ordinateur donné sont
optimisées pour l’architecture de cette machine. Donc,
sauf cas particulier, il est souvent plus efficace en termes
de temps de calcul (pour ne pas parler du temps de pro-
grammation) d’utiliser un sous-programme pris dans une
bonne bibliothèque installée par un professionnel que de
chercher à réinventer la roue. . . De même, en dehors de
toute considération d’optimisation suivant une architec-
ture donnée, il existe un bagage énorme d’algorithmes ef-
ficaces qu’il serait stupide de ne pas utiliser : ainsi la FFT
est considérablement plus rapide que :
do k = 1, n
s(k) = (0.,0.)
do l = 1, n
s(k) = s(k) + f(l)*exp((2*pi*i*k*l)/n)
enddo
enddo
et un programme de tri suivant un algorithme éprouvé sera
vraisemblablement plus efficace, parfois de plusieurs ordres
de grandeur, que ce que l’on aura pu inventer soi-même.
Il est vrai qu’il faut alors enquêter pour savoir ce qui est
disponible sur une machine donnée, les syntaxes d’appel
(nature, type des arguments, etc.). Il faut généralement
aussi indiquer lors de la compilation que l’on utilise telle
ou telle bibliothèque : la plupart des compilateurs utilise
l’option -lnom de la bibliothèque. Par exemple, pour lin-
pack (qui contient des FFT entre autres) :
g95 -O3 machin.f90 -llinpack -o machin
—
En fin de compte, si malgré tous ses efforts, un pro-
gramme prend à l’exécution un temps prohibitif, il reste
deux possibilités : 1o limiter ses ambitions ou 2o utiliser
une machine plus puissante, ce qui signifie en général
c’est-à-dire utiliser plusieurs processeurs simultanément.

Il faut évidemment éviter le terme i = j qui donnerait

l’infini. On peut imaginer une structure comme :

do i = 1, n
hij(:) = (expression)
h(i) = sum(hij(1:i-1)) + sum(hij(i+1:n))
enddo

ou quelque chose avec where. Toutefois, il est souvent plus

efficace d’écrire :

do i = 1, n
hij(:) = (expression)
hij(i) = 0.
h(i) = sum(hij)
enddo

la somme des hij se fait sans interruption ce qui fait gag-

ner plus de temps que n’en fait perdre l’introduction du
terme nul inutile. Cela dépend parfois du compilateur, du
(ou des) processeur(s), de l’adaptation de l’un et de(s)
l’autre(s) : il vaut parfois la peine de faire quelques essais.
118 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 7

Calculs très lourds : vectorisation et

parallélisation

High performance computing ! Calcul scientifique in- avec quatre processeurs en pipe-line, s’exécutera de la
tensif ! Teraflops ! Petaflops ! Exaflops ! Ce sont des façon suivante :
expressions-clefs que l’on voit apparaı̂tre de façon cycle proc 1 proc 2 proc 3 proc 4
récurrente pour dire que l’on calcule toujours plus, sur 1 lit b(1) . . .
des problèmes toujours plus gros. . . Or, si les puissances 2 lit b(2) lit c(1) . .
de calcul des processeurs croissent à une vitesse qui donne 3 lit b(3) lit c(2) b(1)+c(1) .
4 lit b(4) lit c(3) b(2)+c(2) écrit a(1)
le vertige, les besoins en calculs lourds croissent encore
- - - - -
plus vite. De plus, bien des raisons portent à croire que i b(i) c(i-1) b(i-2)+c(i-2) a(i-3)
la limite de ce que l’on peut faire en la matière n’est pas - - - - -
très loin : bien sûr, ce genre de prédiction est vouée à être De cette manière, au i-ième cycle, le premier processeur
démentie d’une façon ou d’une autre, toutefois, l’évolution va chercher en mémoire le i-ième élément de b, le deuxième
des stratégies d’équipement des centres de calcul semble le i-1-ième élémént de c, le troisième fera l’addition des
montrer que cette préoccupation est partagée. i-2-ièmes et le quatrième processeur écrira en mémoire
Une option séduisante est alors d’associer plusieurs le i-3-ième résultat : les quatre processeurs travaillent à
unités de calcul dans un même ordinateur ou de lier 100% ! On réalise aisément que le démarrage et la fin de ce
plusieurs ordinateurs pour qu’ils puissent joindre leurs processus ne seront pas optimum, ce qui fait que ceci n’a
forces sur un problème donné. Par exemple, la plupart des aucun intérêt sur des tableaux de, mettons, 3 éléments. . .
processeurs comportent des unités distinctes spécialisées mais avec des tableaux de quelques milliers d’éléments, on
dans les additions et multiplications de nombres réels. En a quasiment gagné un facteur 4.
général, lorsqu’on soumet une instruction complexe asso- On appelle cela une machine ≪ vectorielle ≫.
ciant additions et multiplications, ces unités peuvent tra-
Pour tirer partie efficacement d’une telle architecture,
vailler simultanément sur des morceaux différents de l’in-
l’effort n’est pas énorme : il faut travailler sur des tableaux
struction. On peut toutefois aller beaucoup plus loin.
avec des logiques assez simples, pour ne pas interrompre
le pipe-line. C’est assez similaire à ce qui a été dit du
7.1 L’architecture vectorielle bon usage des caches. L’expérience prouve qu’en général,
un code efficace sur une machine classique, donnera de
L’architecture dite ≪ pipe-line ≫ permet d’associer, pour bonnes perforances sur une machine vectorielle.
ainsi dire ≪ en tuyau ≫ plusieurs processeurs à la suite La facilité de programmation de ces machines a fait
les uns des autres qui travaillent en suivant le principe leur succès : certains CRAY des années 1990 en partic-
≪ je fais ma petite part de travail et je passe à mon ulier avaient des registres de très grande taille capable de
voisin ≫. Un exemple élémentaire est tout simplement stocker un grand nombre d’éléments de tableau afin de
l’existence de mémoires-tampon : si l’on envoie un texte tirer parti de la rapidité d’accès aux registres et l’on obte-
ou une image en impression sur une imprimante, celle-ci nait aisément ainsi de très bonnes performances de calcul
est très lente par rapport au processeur de l’ordinateur ;
pour l’époque.
donc en pratique, on envoie la tâche d’impression dans une
mémoire dite ≪ tampon ≫(ou buffer ) de telle façon que le Ce sont toutefois des technologies coûteuses dont les lim-
processeur puisse s’occuper d’autre chose pendant l’im- ites sont assez vite apparues : on verra ce que l’avenir
pression. Plus sérieusement, lorsqu’on travaille dans une réserve, mais il ne semble plus que cette voie continue à
boucle avec des instructions composites sur des tableaux, être activement explorée par les constructeurs, même si
chaque processeur fera quelque chose (une addition par des ordinateurs comportent une part de vectorisation.
exemple) sur un élément du tableau et passera le résultat
à son voisin, et sans attendre que ledit voisin ait fini son
travail, passera à l’élément suivant du tableau. Ainsi, tous 7.2 Parallèlisme
les processeurs travaillent en même temps sur des éléments
différents du tableau. Par exemple, la boucle :
Le parallèlisme consiste à tenter de répartir un cal-
do i = 1, n cul sur plusieurs processeurs différents de façon que les
a(i) = b(i) + c(i) données sur lesquelles ils travaillent soient différentes mais
enddo les instructions exécutées peuvent être identiques (Single

119
120 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Instructions Multiple Data) ou différentes (Multiple In- en proposer des centaines, voire des milliers (on commence
structions Multiple Data). En pratique, les problèmes sont à parler de calculs répartis sur des dizaines de milliers de
différents selon que l’on travaille avec un petit nombre de processeurs).
processeurs (ou plutôt de cœurs ; en gros 4 ou 8) qui parta-
gent le même espace mémoire (mémoire partagée ou shared 7.2.2 Mémoire distribuée
memory) ou un grand nombre de processeurs qui utilisent
chacun un espace mémoire propre (mémoire distribuée ou Une autre solution consiste à répartir explicitement
distributed memory) : dans ce cas la communication en- le travail sur les processeurs, tel processeur devant faire
tre processeurs se fait par un réseau qui est généralement tel morceau du programme sur telles données, tel autre
optimisé pour ralentir le moins possible les calculs. processeur faisant autre chose sur d’autres données. En
anglais, on appelle cela Multiple Instructions Multiple
Data ou MIMD. Chaque processeur fait son travail
7.2.1 Mémoire partagée
spécifique sur ses données. La difficulté est la synchronisa-
C’est une situation assez fréquente et qui le devient tion de ce beau monde, car il arrive que ce que doit faire
de plus en plus : un ordinateur contient plusieurs pro- un processeur dépende du résultat d’un calcul fait par un
cesseurs, parfois multi-cœurs qui partagent le même espace autre, sinon, il suffirait de prendre plusieurs ordinateurs
mémoire. On peut alors donner des directives de compila- indépendants qui feraient les calculs séparément. Il existe
tion, c’est-à-dire des instructions au compilateur, du type des bibliothèques de programmes de passage de messages
≪ parallélise-moi ce morceau de programme ≫, et le com- (comme MPI pour Message Passing Interface) qui perme-
pilateur, si on lui donne les bonnes options, parallélise. . . ttent de faire communiquer les processeurs entre eux et les
presqu’automatiquement. forcer à s’attendre les uns les autres pour s’échanger les
En pratique on utilise généralement OpenMP (pour données dont ils ont besoin. Ainsi, dans un programme,
Open MultiProcessing) qui est librement distribué : en on appelle des sous-programmes de bibliothèque, par ex-
fortran cela apparaı̂t comme des commentaires du type : emple :
!$OMP PARALLEL call MPI_SEND(....)
ou
pour envoyer des données d’un processeur à un autre. En
!$OMP END PARALLEL
de telle sorte qu’un compilateur ≪ non averti ≫ (c’est-à- effet, mettons que l’on soit en train de faire un calcul de
dire qui ne connait pas OpenMP ou auquel on n’a pas type Monte-Carlo-Metropolis, il faut calculer toutes les
fourni l’option de compilation appropriée) puisse compiler interactions i-j, or il faut répartir les atomes entre les
le programme sans tenir compte de ces directives. Au con- processeurs : un processeur donné doit donc disposer des
traire, le compilateur qui connait OpenMP va tenir compte positions de tous les atomes, et non seulement de ceux dont
de tout ce qui commence par !$OMP. On écrira alors des il a la charge. En fin de course, il faut additionner toutes
choses comme : les énergies et donc concentrer sur un processeur toutes
!$OMP PARALLEL
les énergies partielles calculées sur tous les processseurs :
do i = 1, n encore des communications entre processeurs.
... La gestion de ceci par l’utilisateur est plus difficile car il
enddo faut gérer explicitement par programme tous ces échanges,
!$OMP END PARALLEL et équilibrer les charges de travail des processeurs de façon
à ne pas perdre trop de temps dans les attentes.
et le compilateur répartit la boucle sur les processeurs
disponibles, chacun prenant sa part de données. Il faut
cependant être assez prudent : tous les processeurs
utilisent la même mémoire, il y a donc le risque qu’ils
écrasent le travail de leurs voisins ! Certaines variables
peuvent donc être déclarées comme privées, c’est-à-
dire qu’elles sont dupliquées en autant d’exemplaires
qu’il y a de processeurs, afin qu’elles soient utilisées
indépendamment par chacun :
!$OMP PARALLEL PRIVATE(X, Y, Z)
do i = 1, n
...
enddo
!$OMP END PARALLEL

Cette façon de procéder a l’immense avantage d’être très

simple à mettre en œuvre : très souvent, il suffit de repérer
les quelques boucles du programme qui prennent pratique-
ment tout le temps de calcul, mettre quelques directives
au bon endroit, compiler. . . et on fait travailler huit pro-
cesseurs au lieu d’un : division par huit du temps de resti-
tution !
Malheureusement, le monde réel est parfois contrari-
ant : certains algorithmes s’accomodent mal de ce genre
de traitement et l’on peut avoir besoin de plus que 8 pro-
cesseurs, d’autant que les centres de calculs se mettent à
Chapitre 8
Quelques éléments de C++
Le langage fortran est ≪ LE ≫ langage de program-
mation scientifique par excellence : il a été fait pour cela
et il a constamment évolué depuis les années 1950 pour
s’adapter. La version actuellement la plus utilisée a été
définie en 1990 et légèrement modifiée en 1995. Les com-
pilateurs correspondants sont progressivement apparus à
la fin des années 1990. Une norme 2003 a été définie et
de nouveaux compilateurs devront voir le jour également
dans quelques années (g95 commence à inclure des aspects
2003 en plus de la norme fortran95) : ainsi l’évolution
se poursuit.
Toutefois, il y a une maxime importante qui est que :
≪ le meilleur outil est celui que l’on maı̂trise bien ≫. Pour
des raisons diverses, le langage C est largement répandu
et enseigné : or tout ce qui est dit et fait dans le présent
polycopié peut être traité en C ; il faut bien sûr lui re-
connaı̂tre ses lettres de noblesse car le système Unix (et
par conséquent Linux) est écrit en C et c’est un succès re-
marquable. Le C en tant que langage de programmation
scientifique date des années soixante-dix et peut être con-
sidéré comme largement obsolète : le C++ a pris la suite.
Ce développement ne répond cependant pas ou mal aux
limitations du C pour ce qui est du calcul scientifique et
fortran95 reste plus commode à l’usage 1 , mais en vertu
de la maxime ci-dessus, ceux qui ont une bonne maı̂trise
du C peuvent vouloir rester dans un monde familier, d’où
les présents Éléments de C++ (qui ne remplacent pas
un vrai cours). Ce langage ne manque pas de charme : il
permet des exercices de voltige informatique admirables
d’élégance quoique souvent. . . périlleux !
8.1 Avant même de commencer
Il faut savoir qu’a priori C++ ≪ ne sait rien faire ≫ :
c’est un choix explicite, il faut lui indiquer que l’on a be-
soin de choses aussi élémentaires que les entrées-sorties, les
chaı̂nes de caractères et les fonctions mathématiques stan-
dards ! En pratique, tout programme commence donc par
des directives au préprocesseur marquées par un # (dièze) :
// Directives au préprocesseur
// inclure les entrées-sorties d’écran
#include <iostream>
1. Lors d’un colloque, quelqu’un qui simulait des problèmes de
combustion complexe dans des turbines aéronautiques, à qui on de-
mandait si ses programmes étaient en C++, répondit non parce que :
1o ≪ C++, ça rame ! ≫ (je cite) et 2o on pouvait laisser un nouveau
chercheur intervenir sur un code en fortran au bout de quelques
semaines de formation, ce qui était totalement exclu en C++. . .
121
// inclure les entrées-sorties par fichiers
#include <fstream>
// inclure les cha^
ınes de caractères
#include <string>
// inclure les fonctions mathématiques
#include <cmath>
Les symboles // indiquent les commentaires sur la fin de
la ligne ; si on veut mettre un commentaire sur plusieurs
lignes : /* ... */.
Toujours dans le cadre du ≪ je ne sais rien faire ≫,
C++ prévoit que l’on puisse avoir envie d’utiliser des
noms génériques de fonctions pour des usages particuliers,
d’où risque de conflit. On peut donc définir un namespace
(ou espace de noms) particulier pour éviter cela. Sinon (ce
qui est le cas général), on doit préciser que l’on veut utiliser
l’espace de noms standard : using namespace std ; (ne
pas oublier le point-virgule).
Avant donc le début du programme, de toute fonction,
ou de déclarations, il faut ces directives et cet espace de
noms.
S’il n’y a pas de variables globales ou de fonctions, on
peut alors attaquer le programme principal. Celui-ci s’ap-
pelle toujours main( ) et n’a pas de type ; en fait, on peut
aussi le mettre en int (entier). Le début du programme
est marqué par une accolade ouvrante et sa fin par une ac-
colade fermante. On obtient donc quelque chose qui peut
ressembler à :
#include <iostream>
#include <fstream>
#include <string>
#include <cmath>
using namespace std ; // espace de noms standard
// programme principal
main( )
// accolade : debut du ’bloc’ du programme principal
{
cout << "Hello world" << endl ;
} // accolade : fin du bloc du programme principal
On notera l’instruction cout d’écriture et sa syntaxe très
différente de celle du langage C (pour ne pas parler du
fortran. . .). endl signifie end of line (fin de ligne) : il
s’agit de passer à la ligne à la fin de l’écriture, ce qui n’est
pas le mode par défaut, il faut le préciser.
On notera que toutes les instructions se terminent par
un point-virgule ; : C++ ignore les espaces et les sauts
122 Licence de physique L3: PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

de lignes. Non seulement une même instruction peut être On peut aussi écrire des choses comme
répartie sur plusieurs lignes, mais on peut mettre autant for ( float x=x_min ; x<=x_max ; x=x+dx ) { in-
de sauts de ligne que l’on veut au milieu de l’instruction. . . structions. . .}
Ceci se compile de façon très classique par la com- ou encore
mande : while(condition) {instructions. . .}
c++ hello.cpp -o hello et
le suffixe cpp indiquant qu’il s’agit bien d’un programme do {instructions. . .} while(condition)
en C++.
8.3.2 Conditions
8.2 Déclarations On a évidemment :
if ( condition ) { instructions. . . } else { instruc-
Les variables doivent être déclarées : les types de base tions. . . }
sont int (entier), float (réel), double (double précision), Attention, pour les habitués du fortran, il n’y a pas de
char (caractère) et bool (booléen). En C++ comme then. . .
en C, le type complexe n’existe pas. Les noms Il y a une variante :
de variables obéissent aux règles habituelles, seulement, z = ( condition ) ? x : y ;
C++ distingue entre les lettres majuscules et minuscules qui équivaut à
(Resultat est différent de resultat, les mots-clefs du lan- if ( condition ) z = x ; else z = y ;
gage étant en lettres minuscules : float et non FLOAT ou Les conditions s’écrivent sans grande origi-
Float) nalité : x >= y, y != z (différent de), a == b ou
En revanche les déclarations peuvent être faites n’im- a < b && y <= u où && signifie et, et ou s’écrit ||.
porte où dans le programme à condition que ce soit
1o avant la première utilisation et 2o dans le même bloc. 8.3.3 Sauvegardes
Ainsi, dans le programme suivant qui comporte une boucle
faisant varier la variable entière step de 1 à 100 : Si l’on veut écrire des résultats dans un fichier, il faut
l’ouvrir, écrire, puis le fermer : ce n’est pas bien original,
#include <iostream> par exemple,
#include <fstream>
#include <string> // ouverture du fichier Calcul.res
#include <cmath> ofstream fichier("Calcul.res") ;
using namespace std ; for( int i = 0 ; i < i_max ; i++)
fichier << i<< " " << x[i] << endl ; // écriture
main( ) fichier.close() // fermeture
{
/* déclaration de 2 nombres réels
pour tout le programme */ 8.4 Tableaux
float t, dt=0.1 ;
8.4.1 Tableaux de taille fixe
// boucle et déclaration de step Il n’y a ici rien de très original :
for ( int step = 1; step <= 100; step++ )
{ t = step*dt ; cout << t << endl ; } #include <iostream>
// fin de la boucle et fin du ’bloc’ où step est défini #include <fstream>
#include <string>
/* si on met ici une référence à step, #include <cmath>
ça ne marchera pas ! */ using namespace std ;
// cout << step << endl ; // donc, NE PAS décommenter !
} int main( )
/* la taille du tableau doit ^ etre définie
la variable step n’est déclarée que pour la boucle qui par une constante entière */
constitue le bloc pour lequel elle est déclarée. Si on es- { int const n=100 ;
saie de compléter le programme en ajoutant la ligne float x[n] ; // déclaration du tableau
cout << step << endl ; entre l’accolade qui termine
la boucle et l’accolade finale, on obtiendra une erreur for ( int step = 0; step < n; step++ )
{ x[step] = step ; cout << x[step] << endl ; }
à la compilation. Le début et la fin de la boucle sont
}
évidemment marqués par les accolades.
On notera néanmoins quelques points importants : 1o on
ne peut pas délimiter les tableaux comme on veut (par ex-
8.3 Structures de base diverses emple x[-5:5] n’est pas permis), car on se borne à donner
le nombre d’éléments du tableau, et 2o le premier élément
8.3.1 Boucles du tableau est l’élément zéro (les bornes de la boucle sont,
dans l’exemple ci-dessus, 0 et 99, soit n-1).
On a déjà vu : Les tableaux à plusieurs dimensions existent, ce
for ( int i = debut ; i < fin ; i++ ) {instruc- sont simplement des tableaux de tableaux (on omettra
tions. . .} dorénavent dans les exemples les préliminaires #include
où debut et fin sont des entiers. et using) :
Physique numérique, Philippe Depondt 123

int main( ) l’époque où, pour gagner de l’espace mémoire, on pro-

{ int const n = 10, m = 5 ; grammait parfois en assembleur, des souvenirs d’écrans
float x[n][m] ; // tableau de tableau devenus soudainement tous noirs, ou d’ordinateurs qu’il
fallait débrancher du secteur pour les redémarrer ensuite,
for ( int step = 0; step < n; step++ ) tout simplement parce qu’un pointeur dans un de mes pro-
{
grammes était allé écraser une adresse mémoire réservée
for ( int i = 0 ; i < m ; i++ )
au système d’exploitation. . . La chasse à l’erreur, dans ces
{
x[step][i] = step+pow(i,3.2) ; conditions, était un exercice requérant une acuité intel-
cout << step << " " << i << " " lectuelle supérieure et dans lequel la fameuse loupe de
<< x[step][i] << endl ; Sherlock Holmes était un ustensile indispensable !
} C’est à ce genre de délices que C++ nous convie. . . Il
} est sans doute inutile de préciser que, quand on a le choix
} entre utiliser un tableau comme ci-dessus, et un pointeur,
on a tout intérêt à utiliser le tableau. Il arrive toutefois
Noter au passage 1o les deux boucles imbriquées, 2o l’usage
bien souvent que l’on n’ait pas le choix.
correspondant des accolades ainsi que 3o la façon d’éviter
Concrétement, imaginons que nous ayons déclaré une
qu’à l’écriture tous les chiffres soient accolés, en insérant
variable, scalaire pour commencer, par exemple, par :
des espaces et enfin 4o que la mise à la puissance du for-
float x ;
tran (x**y) n’existe pas plus en C++ qu’en C : il faut
Son adresse dans la mémoire vive s’écrit alors : & x
utiliser la fonction pow.
Déclarons alors une variable de type pointeur à l’aide de
Finalement, C++ ne connait pas la manipulation
l’astérisque * :
globale de tableaux : toutes les boucles doivent être
float * px ; // déclaration d’un pointeur
écrites explicitement, et les fonctions intrinsèques du type
On note que le type de la variable vers laquelle on pointe 2
sum, dot product ou matmul sont absentes.
est fourni, afin de donner le nombre d’octets qu’elle va oc-
cuper dans la mémoire. On peut alors écrire :
8.4.2 Les pointeurs : premiers pas px = & x ;
Les pointeurs font le charme sulfureux du langage C : L’adresse de x est stockée dans le pointeur px. Pour don-
ils permettent d’éblouissantes acrobaties et autorisent ner la valeur 1.414 à x, il y a maintenant deux façons de
l’artiste à donner libre cours à toute sa virtuosité. . . Ils procéder :
sont aussi la source de bugs particulièrement retors ! À x = 1.414 ; // méthode classique
manipuler avec une certaine prudence, donc. ou alors on stocke 1.414 à l’adresse pointée par px
Dans le principe, cependant, c’est assez simple. *px = 1.414 ;
Il faut savoir qu’un tableau -dans n’importe quel lan- Évidemment, dans le cas simple montré ici, la première
est de loin préférable. Imaginons cependant la séquence
gage, y compris fortran- est un pointeur masqué. Un lan-
suivante :
gage comme le fortran est fait de telle sorte que l’usage
explicite de pointeurs est en général inutile, dans le but float x; // variable réelle
évident de simplifier la vie de celui (ou celle) qui écrit les float * px ; // pointeur vers une variable réelle
programmes. En C et C++, au contraire, tout est fait
pour que toutes les potentialités de ces objets puissent px = & x ; /* initialisation du pointeur sur
l’adresse de x */
être utilisées.
px = px + 1 ; /* incrémentation du pointeur de quatre
Les pointeurs, c’est une vieille histoire, du moins à
octets : variable suivante */
l’échelle de l’histoire de l’informatique. En assembleur, *px = 1.414 ;
il n’y a pas de tableau, or un tableau, c’est simplement
un ensemble de cases dans la mémoire vive, rangées les on a placé la valeur 1.414 dans une nouvelle case mémoire
unes derrière les autres dans l’ordre. Ainsi, pour définir un située 4 octets (soit un réel) après x : il vallait mieux être
tableau, on doit fournir 1o l’adresse du premier élément, sûr qu’il n’y avait là rien de vital ! On réalise alors que l’on
2o le type de variable, c’est à dire en pratique le nom- peut, en quelque sorte, se promener en toute liberté dans
bre d’octets occupé par un élément (4, 8 voire 16) et 3o le la mémoire vive de son ordinateur et y faire toutes sortes
nombre d’éléments. C’est ce que l’on fait quand on déclare de choses exaltantes. . .
un tableau. L’adresse du p-ième élément du tableau est
donnée par : 8.4.3 Tableaux dynamiques
adresse du premier element+ On a vu précédemment que pour déclarer un tableau
statique, il fallait que la taille du tableau soit une con-
(p − 1)(nombre d’octets par element) stante : cela signifie que cette valeur ne peut pas être mod-
ifiée à l’exécution du programme ; en fait elle doit pouvoir
En assembleur, alors qu’on ne dispose pas de tableau, être établie à la compilation. Ainsi, même si la déclaration
c’est exactement cela qu’on fait : on définit une variable du tableau est faite au milieu des instructions exécutables
spéciale, appelée pointeur qui contient l’adresse du pre- (c’est permis), sa taille est prédéterminée lors de l’écriture
mier élément du tableau, variable que l’on incrémente de du programme, on ne peut pas, par exemple, l’entrer au
la quantité voulue pour accéder aux éléments du tableau. clavier. En fortran, on répond à cette question par des
Quand ça marche, ça marche très bien : j’en témoigne tableaux allocatable ; en C++, on utilise un pointeur-
bien volontier ! Quand ça ne marche pas. . . c’est une tableau :
autre histoire ! J’ai des souvenirs douloureux datant de 2. ça, c’est un progrès sensible par rapport à l’assembleur. . .
124 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

int main( )
{ int main( )
// variable qui doit contenir la taille du tableau {
int n ; cout << machin(5) << endl ;
// saisie de n }
cout << " Entrer la taille du tableau : " ; cin >> n ;
// déclaration du tableau dynamique // définition de la fonction après son appel
float * x = new float[n] ; int machin(int i)
for ( int i = 0; i < n; i++) {
{ return 3*i+1 ;
x[i] = i*i ; cout << x[i] << endl ; }
}
}
8.5.3 Passage d’arguments par valeur
Ici, la taille n du tableau est une vraie variable que l’on Imaginons que l’on tente de modifier la valeur de l’ar-
entre au clavier à la demande (voir au passage la syntaxe gument i dans la fonction :
de la saisie au clavier). Le tableau disparaı̂t dès que l’on
sort du bloc où il a été défini (dans cet exemple, c’est le #include <iostream>
programme principal, donc il ne disparaı̂t qu’au moment #include <fstream>
de la fin du programme). #include <string>
#include <cmath>
using namespace std ;
8.5 Fonctions
int machin(int) ;
C++ n’a pas le concept de subroutine, il faudra donc int main( )
utiliser quelques astuces ; de plus, les fonctions doivent être { int j = 5 ;
définies avant d’être utilisées sauf si l’on définit un proto- cout << j << " " << machin(j) << " " << j << endl ;
}
type.
int machin(int i)
8.5.1 Une fonction très simple {
i = 3*i+1 ; // ici, la variable i est modifiée
Voici un exemple élémentaire : return i ;
#include <iostream> }
#include <fstream>
ce programme répond : 5 16 5, autrement dit, la vari-
#include <string>
#include <cmath> able j du programme principal n’est pas modifiée par la
using namespace std ; fonction machin, alors que le calcul s’effectue bien dans la
fonction. C’est que l’argument j est passé ≪ par valeur ≫ :
/* début de la fonction entière machin la valeur de j est transmise à la fonction, mais j n’est pas
avec un argument entier */ modifiée.
int machin(int i)
{
return 3*i+1 ; // calcul de la valeur de la fonction 8.5.4 Passage d’arguments par référence
} // fin de la fonction Le passage par référence consiste à passer la variable
comme une valeur de pointeur, c’est-à-dire une adresse
int main( ) // programme principal qu’on ne peut pas modifier, alors que la la valeur vers
{ laquelle on pointe peut, elle, être modifiée :
cout << machin(5) << endl ; // appel de la fonction
} //prototype avec passage par référence
int machin( int &) ;
La fonction est définie avant le programme principal qui
l’appelle. int main( )
{ int j = 5 ;
cout << j << endl ; // écriture de j initial
8.5.2 Prototype
cout << machin(j) << endl ; /* écriture de la valeur
Le prototype permet de ne définir la fonction qu’après de la fonction */
son appel, il consiste simplement en une déclaration du cout << j << endl ; } // écriture de j modifié
type de la fonction et des types de ses arguments, ainsi :
// fonction avec passage par référence
#include <iostream> int machin(int & i)
#include <fstream> {
#include <string> i = 3*i+1 ;
#include <cmath> return i ;
using namespace std ; }

/* prototype de la fonction machin : Cet exemple répond

elle est de type entier et a un argument entier */
int machin(int) ; 5
Physique numérique, Philippe Depondt 125

16 Babar : 120.32
16 Céleste : 180.25

La variable j a bien été modifiée. L’intérêt est bien sûr de Définissons maintenant une fonction dans la classe :
généraliser ceci à plusieurs variables afin d’obtenir quelque
chose qui ressemble à une subroutine : class client
{
// prototype (type void) public :
void machin( float &, float &, float &) ; string nom ;
float montant ;
int main( ) void client_print() ; // fonction dans la classe
{ float p = 5, q =6, r ; } ;
cout << p << " " << q << endl ;
machin(p,q,r) ; // p, q, et r sont modifiés void client :: client_print() /* définition de la
cout << p << " " << q << " " << r << endl ; fonction : elle est de type void et se réfère à la
} classe client. Noter le :: */
{
// fonction de type void (c’est-à-dire, sans type) cout << nom << " : " << montant << endl ;
void machin(float & a, float & b, float & c) } ;
{ //---------------------------------------
a = a/2 ; b = 3*a- b ; c = a + b ; int main()
} {
client a, b ;
a.nom = "Babar" ; a.montant = 120.32 ;
8.6 Les classes b.nom = "Céleste" ; b.montant = 180.25 ;

C’est la grande nouveauté introduite par C++ par rap- // l’impression est devenue plus simple
port à C et c’est ce qui ouvre la voie vers la programmation a.client_print() ;
orientée objet. En pratique, l’idée est très proche de celle b.client_print() ; // noter la syntaxe
des types dérivés du fortran95, mais c’est conçu assez }
différemment. Les classes peuvent contenir des fonctions
et des opérateurs, ce qui les différencient des structures Puisque le type complex n’existe pas en C++,
(struct) du C. Voici une classe élémentaire : fabriquons-le. Il faut à la fois définir le type (c’est un objet
composé de deux nombres réels, les parties réelle et imag-
#include <iostream> inaire), des fonctions spécifiques (extraire la partie réelle
#include <fstream> ou la partie imaginaire, par exemple) et des opérations
#include <cmath> (addition, produit, etc.). Pour commencer, quelque chose
#include <string> de simple :
using namespace std ;
class complex // Definition de la classe complex
class client // définition de la classe {
{ public :
/* ces variables sont publiques // parties réelles et imaginaires
et donc accessibles de l’extérieur */ float RealPart, ImagPart ;
public : void Zprint() ; // fonction
string nom ; } ;
float montant ; /* client comporte donc
une chaine et un réel */ void complex :: Zprint() // fonction pour imprimer
} ; // attention, ici il y a un point-virgule {
cout << "(" << RealPart << "," << ImagPart << ")" ;
//-------------------------------------------- }
int main() //--------------------------------------------------
{ int main()
// déclaration de deux variables de type client {
client a, b ; complex z1 ;
// initalisation du nom du client a z1.RealPart = 1. ; z1.ImagPart = 2. ;
a.nom = "Babar" ; z1.Zprint(); cout << endl ;
/* initialisation du montant de la transaction }
pour le client a */
Il n’y a ici rien de nouveau. D’ailleurs ça répond :
a.montant = 120.32 ;
b.nom = "Céleste" ; // idem pour b (1,2)
b.montant = 180.25 ;
Maintenant, il faut définir des opérateurs d’addition et de
cout << a.nom << " : " << a.montant << endl ; multiplication :
cout << b.nom << " : " << b.montant << endl ;
} class complex
{
public :
Noter comment on accède aux composantes des variables. float RealPart, ImagPart ;
Après exécution, ce programme répond : void Zprint() ;
126 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

// Définition des opérateurs

complex operator + (const complex & a) // Addition
{
complex z ;
z.RealPart = RealPart+a.RealPart ;
z.ImagPart = ImagPart+a.ImagPart ;
return z ;}

complex operator * (const complex & a) // Multiplication

{
complex z ;
z.RealPart = RealPart*a.RealPart-ImagPart*a.ImagPart;
z.ImagPart = RealPart*a.ImagPart+ImagPart*a.RealPart;
return z ;}
} ;

void complex :: Zprint() // fonction pour imprimer

{
cout << "(" << RealPart << "," << ImagPart << ")" ;
}
//---------------------------------------------------
int main()
{
complex z1, z2, z3 ;
z1.RealPart = 0. ; z1.ImagPart = 1 ;
z2.RealPart = 0. ; z2.ImagPart = 2 ;

z3 = z1+z2 ; // somme de deux complexes

cout << "Somme : " ; z1.Zprint() ;
cout << "+" ; z2.Zprint() ; cout << "=" ;
z3.Zprint(); cout << endl ;

z3 = z1*z2 ; // produit de deux complexes

cout << "Produit : " ; z1.Zprint() ;
cout << "*" ; z2.Zprint() ; cout << "=" ;
z3.Zprint(); cout << endl ;
}

C’est assez subtil : les opérateurs (a priori binaires) ne

prennent qu’un argument. Ainsi par exemple, quand on
veut faire la somme des parties réelles, on fait la somme
de RealPart qui est considéré comme déjà résident en
mémoire et de a.RealPart qui est la partie réelle de l’argu-
ment. C’est un peu comme en assembleur, quand on écrit
ADDA $10C3, soit ≪ additionner le contenu du registre A
(déjà chargé) avec le contenu de la mémoire $10C3 ≫.
Ça répond :
Somme : (0,1)+(0,2)=(0,3)
Produit : (0,1)*(0,2)=(-2,0)

Il ≪ ne reste plus qu’à ≫ définir soustraction et division,

et les fonctions complexes diverses (norme, conjugué, ex-
ponentielle, etc.)

Le langage C++ est évidemment beaucoup plus riche

que ce qui est indiqué ici : le but de ce chapitre n’est
évidemment que de montrer la ≪ philosophie ≫ du lan-
gage. . .
Chapitre 9

La question du calcul formel.

Des logiciels comme Maple ou Mathematica sont des a*x+b=0

20
2
outils très puissants permettant de faire du calcul formel 0
−2
à l’aide d’un ordinateur. Quelle place ces outils tiennent-ils 60 −20
par rapport au calcul numérique tel qu’il a été développé 40
20
dans ce cours ? La réponse évidente est que l’on entreprend 0
un calcul numérique lorsque le calcul formel ne donne pas −20
−40
les résultats escomptés, cependant comme les démarches −60
de l’un et de l’autre sont assez différentes, il est bon de 4
préciser ce que l’on entend par là. 2
−4 0
−2 −2 b
0
a 2 −4
4
9.1 Calcul formel, calcul numé-
Figure 9.1 – Résultat de la résolution numérique de
rique : quelle différence ? l’équation ax + b = 0 par la méthode de la dichotomie.
Imaginons un exemple simpliste où l’on cherche à
résoudre l’équation :
la plus marquante du résultat. L’allure du graphe obtenu
ax + b = 0 dépend aussi fortement du pas de l’échantillonnage choisi.
Les points singuliers ne sont d’ailleurs pas repérés ex-
N’importe quel élève de 4ème sait (en principe) comment plicitement -on se demande comment- mais simplement
il faut procéder : sont entourés de zones où x prend, en valeur absolue, des
valeurs ≪ grandes ≫. Le résultat formel montre sans am-
ax + b = 0
biguı̈té que la divergence est en 1/a ce qui n’a aucun car-
ax + b − b = −b actère d’évidence dans le cas des résultats numériques ; on
ax + 0 = −b peut toutefois avoir l’idée de tracer, non pas x(a, b) mais
ax b le produit a × x(a, b), qui donnerait une constante ce qui
= − permet de dire, de même, que ça diverge comme 1/a 1 .
a a
b Ainsi, résolution formelle et résolution numérique d’un
x = −
a même problème donnent des résultats assez différents. . .
Autrement dit, il faut faire quelques manipulations
formelles de l’expression (retrancher b des deux cotés du
signe égal, diviser des deux cotés par a, faire les simplifica- 9.2 Quelques exemples
tions qui s’imposent) pour obtenir la solution qui s’écrit :
x = une expression. Les logiciels de calcul formel font 9.2.1 ax + b = 0
cela : ils manipulent des symboles en appliquant les règles
formelles de l’algèbre. Des logiciels de calculs formels comme Maple ou Mathe-
La force de cette façon de procéder est qu’elle est matica sont souvent capables de faire les deux ; avec Maple
générale : la solution obtenue de la sorte est valable pour par exemple :
n’importe quel couple de nombres a et b. solve(a*x+b=0,x);
Si l’on cherche à résoudre la même équation b
−
numériquement, par la méthode de la dichotomie ou par la a
méthode de Newton, le résultat sera un tableau de valeurs est la résolution formelle de l’équation, alors que :
de x pour un échantillonnage de valeurs prises par a et b, f := (a,b)->fsolve(a*x+b=0,x);
que l’on peut représenter sur un graphe comme la figure
9.1. f := (a, b) → fsolve(a x + b = 0, x)
Même si le graphe a des vertus esthétiques que n’a pas
la formule, on retrouve toutes les difficultés déjà évoquées plot3d(f,-5..5,-5..5);
au chapitre 4.4 : si l’intervalle de recherche choisi pour a et
b n’est pas bien choisi, on risque de ne pas voir les points 1. La simplicité de notre exemple est un peu trompeuse, car il
singuliers pour a = 0, ce qui est pourtant la caractéristique faudrait supposer que l’on ne connait pas la solution analytique.

127
128 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Ce n’est pas très digeste, alors essayons d’arranger un

peu le résultat :
expand(%);
(1/3)
%1 4ab 4 a2 2a
− (1/3)
+ (1/3)
+
3RT %1 3 R T %1 3 RT
2 2 2 2 3
%1 :=
r −36 a b R T + 27 a b R T + 8 a +
24 a b
3ab − + 81 b2 R2 T 2
RT
en est la résolution numérique 2 . On notera au passage la on n’a pris que la dernière des trois solutions, et :
différence (subtile) entre les commandes solve et fsolve simplify(%);
qui est illustrée ci-dessous :
solve(cos(x)=0,x); (2/3) (1/3)
%1 − 12 a b R T + 4 a2 + 2 a %1
1
π  3 R T %1
(1/3)
2
fsolve(cos(x)=0,x); %1 := a − 36 a b R T + 27 b2 R2 T 2 + 8 a2 +
r !
1.570796327 √ b (8 a − 27 b R T ) 2 2
3b 3 − R T
dans le premier cas, Maple ≪ sait ≫ que la solution 3 de RT
l’équation cos x = 0 est l’ensemble de symboles 12 π, alors
que dans le deuxième, il calcule la valeur numérique de la même remarque.
solution : ce n’est pas du tout la même opération, car il On a ici un pur produit du calcul formel automatique :
est probable qu’alors (même si Maple n’explicite pas ses le temps de calcul est très rapide, et la résolution de
méthodes) une méthode du type dichotomie est utilisée. l’équation de degré trois sans difficulté, mais le plus délicat
est d’obtenir des expressions utilisables par un humain ;
dans notre cas particulier, on a du mal à choisir parmi
9.2.2 Le gaz de Van der Waals les trois solutions, les deux qui donnent l’allure classique
Un gaz de Van der Waals est défini par l’équation d’état des isothermes de Van der Waals que l’on trouve dans
suivante tous les livres de thermodynamique. Si l’on veut travailler
a
(p + 2 )(v − b) = RT numériquement avec les expressions ci-dessus, Maple peut
v les traduire en fortran pour être introduites dans un
Imaginons que l’on cherche les extrema de la pression en programme sans avoir à tout recopier à la main !
fonction du volume. On entre donc l’expression de la pres-
sion :
p := R*T/(v-b)-a/v**2; 9.2.3 Modèle de Brillouin-Weiss
RT a Voyons maintenant un exemple plus sophistiqué :
p := − 2 on montre que l’aimantation d’une substance ferro-
v−b v
magnétique (dans l’approximation du modèle de Brillouin-
que l’on dérive par rapport au volume :
Weiss) est donnée par l’équation :
diff(p,v);
RT 2a Tc M M
− + 3 tanh( )=
(v − b) 2 v T M s M s

et l’on veut que cette dérivée soit nulle : où Ms est l’aimantation à température nulle et Tc la
solve(%,v); température au-dessus de laquelle l’aimantation est nulle.
(1/3) On peut tenter de résoudre cette équation à l’aide de
%1 4 a (−3 b R T + a) 2a Maple, afin d’obtenir une expression de l’aimantation M
+ (1/3)
+ ,
3RT 3 R T %1 3 RT en fonction de la température T . Cela donne :
(1/3)
%1 2 a (−3 b R T + a) 2a solve(tanh(Tc/T*M/Ms)=M/Ms,M)
− − (1/3)
+ +
6RT 3 R T %1 3 R!
T  2 
(1/3) RootOf( Z T (e Z )2 + Z T −Tc (e Z )2 +Tc)
1 √ %1 4 a (−3 b R T + a) Ms e −1
I 3 − (1/3)
,
2 3RT 3 R T %1
2
(1/3) eRootOf( Z T (e Z )2 + Z T −Tc (e Z )2 +Tc) + 1
%1 2 a (−3 b R T + a) 2a
− − (1/3)
+
6RT 3 R T %1 3 RT! On n’est guère plus avancé : ≪ RootOf ≫ signifie ≪ racine
(1/3)
1 √ %1 4 a (−3 b R T + a) de ≫ autrement dit, Maple ne sait pas répondre à la
− I 3 −
2 3RT 3 R T %1
(1/3) question. Tentons donc une résolution numérique, en nous
%1r := a (−36 a b R T + 27 b2 R2 T 2 + 8 a2 + plaçant pour simplifier dans un système d’unités dans
3 b (8 a − 27 b R T ) 2 2 lequel Ms = 1 et Tc = 1 :
3b − R T ) f:=T->fsolve(tanh(M/T)=M,M);
RT
2. On a commencé par définir une fonction de deux variables M
f := T → fsolve(tanh( ) = M, M )
f (a, b), puis on a demandé un graphe tri-dimensionnel. T
3. Au passage, on notera qu’il ne donne qu’une solution, alors
qu’il y en a une infinité. . . plot(f,0..1);
Physique numérique, Philippe Depondt 129

9.2.4 Le projectile
1

0.5 Imaginons un projectile se déplaçant dans l’air et

soumis, outre à son poids, à une force de trainée
0 0.2 0.4 0.6 0.8 1
aérodynamique proportionnelle à v 2 :

f~traine = −Kv 2 v̂ = −Kv~v

–0.5

où v̂ est le vecteur unitaire parallèle à ~v . Les équations du

–1
mouvement s’écrivent :
On obtient la solution nulle. . . C’est exactement comme 
mẍ = −Kvvx
lorsqu’on cherche à résoudre un problème à l’aide de la
mz̈ = −mg − Kvvz
méthode de la dichotomie ou Newton ! Reformulons alors
le problème pour éliminer cette solution nulle : soit : 
g:=T->fsolve(tanh(M/T)/M=1,M); 
 ẍ K p 2
= − ẋ ẋ + ż 2
m
   K p
M  z̈ = −g − ż ẋ2 + ż 2
tanh( ) m
 T = 1, M
g := T → fsolve  
M
9.2.4.1 Maple
Ceci se traduit en Maple par :
plot(g,0..1); eq1 := diff(x(t),t$2)=-k/m*diff(x(t),t)
sqrt(diff(x(t),t)**2+diff(z(t),t)**2);
–0.2
q
∂ ∂ ∂
∂2 k ( ∂t x(t)) ( ∂t x(t))2 + ( ∂t z(t))2
–0.4
eq1 := 2 x(t) = −
∂t m
–0.6

eq2 := diff(z(t),t$2)=-g-k/m*diff(z(t),t)
–0.8
sqrt(diff(x(t),t)**2+diff(z(t),t)**2);
q
∂ ∂ ∂
–1
0 0.2 0.4 0.6 0.8 1 ∂2 k ( ∂t z(t)) ( ∂t x(t))2 + ( ∂t z(t))2
eq2 := 2 z(t) = −g −
C’est mieux, mais on préfèrerait une solution positive ; im- ∂t m
posons alors le domaine de recherche des solutions (entre
dsolve({eq1,eq2},{x(t),z(t)});
0 et 1) :
h:=T->fsolve(tanh(M/T)/M=1,M,0..1); 
 Z Z Z 
2
z(t) = RootOf t− 1/RootOf − f m
  
M
tanh( ) Z
 T = 1, M, 0..1 Z
f m2 (3 m2 c 3 + 9 m2 g c 2 − 2 f 4 g k2 + 2 m2 g 3 + 8 m2 g 2 c)
h := T → fsolve   − d c Z2
M c 3 (5 m2 g c 2 − f 4 g k2 + m2 g 3 + 4 m2 g 2 c + 2 m2 c 3 )
 (
 !

− C1 Z 2 d f + C2 dt + C3 ,

plot(h,0..1); 
1 Z p
(m g + %1 − k ( ∂ z(t))2 ) (m g + %1 + k ( ∂ z(t))2 )
∂t ∂t
x(t) = dt + C1 ,
( ∂ z(t)) k
0.8
Z p ∂t )
(m g + %1 − k ( ∂ z(t))2 ) (m g + %1 + k ( ∂ z(t))2 )
∂t ∂t
x(t) = − dt + C1
0.6 ( ∂ z(t)) k
∂t
2
%1 := m ( ∂ z(t))
0.4 ∂t2

0.2
C’est plutôt indigeste (même réduit), mais on retrouve le
célèbre ≪ RootOf ≫ qui signifie que Maple ne sait pas
0 0.2 0.4 0.6 0.8 1
résoudre le problème !
Essayons numériquement :
Cela a bien l’allure attendue de l’aimantation en fonction
g:=9.81;
de la température avec la transition de phase pour T = Tc .
g := 9.81
En revanche, on constate deux choses : 1o Maple ne sait
résoudre formellement que les problèmes qui ont une solu- k := 1;
tion analytique, 2o le calcul numérique effectué par le logi- k := 1
ciel n’est pas magique : la procédure suivie et les difficultés
rencontrées sont les mêmes que lors du calcul numérique m := 1 ;
fait avec un programme personnel, Maple apporte simple- m := 1
ment le fait qu’il n’est pas besoin de programmer soi-même inc:={x(t),z(t)};
la recherche de zéro, ainsi que la convivialité de l’interface
graphique incorporée. inc := {x(t), z(t)}
130 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

0.9
condini:=x(0)=0,z(0)=0,D(x)(0)=10,D(z)(0)=10;
0.8
condini := x(0) = 0, z(0) = 0, D(x)(0) = 10, D(z)(0) = 10 0.7

0.6
s:=dsolve({eq1,eq2,condini },inc,type=
numeric); 0.5

z
0.4
s := proc(rkf45 x ) . . . end 0.3

0.2
fx := u->subs(s(u),x(t));
0.1
fx := u → subs(s(u), x(t)) 0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8
x
fy := u->subs(s(u),z(t));

fy := u → subs(s(u), z(t)) Figure 9.2 – Trajectoire du projectile z(x).

plot(’[fx(t),fy(t),t=0..10]’,x=0..2,y=-0.01..1);
1
est le pas de temps utilisé, 3o la syntaxe (les subs en par-
ticulier) n’est pas particulièrement limpide. On admettra
0.8 sans grande difficulté que pour un problème simple comme
celui-ci, ces défauts ne sont sans doute pas rédhibitoires.
0.6

0.4 9.2.4.3 Octave

On notera que l’on n’a utilisé finalement que les

0.2
capacités numériques de Maple et non les propriétés
de calcul symbolique. Ainsi, un logiciel comme Oc-
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2 tave (sensiblement moins coûteux, puisque gratuit. . .
x
voir http://www.octave.org) ferait parfaitement l’af-
On obtient sans surprise que le projectile n’a pas une faire. Les commandes (placées dans un fichier de comman-
trajectoire parabolique (qui serait symétrique par rapport des exécutable) ci-dessous permettent de résoudre le même
à l’apogée). problème :

9.2.4.2 Fortran
#! /usr/bin/octave -qf
Il est aisé de vérifier à l’aide de quelques lignes de pro-
function proj = f(x,t)
gramme que l’on obtient la même chose par les moyens
habituels : k = 1 ; m = 1 ; g = 9.81 ;
proj(1)=x(3); # 2 eqs du 2nd ordre
program projecti proj(2)=x(4); # donnent 4 eqs du 1er
implicit none proj(3)=-k/m*x(3)*sqrt(x(3)**2+x(4)**2);
real :: t, dt, vx, vz, x, z, w, c, gdt proj(4)=-k/m*x(4)*sqrt(x(3)**2+x(4)**2)-g;
real :: k = 1., m = 1., g = 9.81 ! parametres endfunction
integer :: step, nstep
x0=[0;0;10;10]; # conditions initiales
dt = 0.001 ! pas de temps
t = linspace(0,2,200);# intervalle de temps
nstep = 10./dt ! nombre de pas
c = k/m*dt ; gdt = g*dt ! constantes # et nbr de pas
x=0.; z=0.; vx = 10.; vz = 10.; t = 0. ! cond. init. x=lsode("f",x0,t); # resolution
open(1,file=’project.res’) gset nokey; # commandes gnuplot
write(1,*) t, x, z, vx, vz gset yrange[0:1]; gset xrange[0:2];
do step = 1, nstep ! verlet gset xlabel ’x’; gset ylabel ’z’;
t = step*dt gset title ’fait avec Octave’
w = 1.-c*sqrt(vx*vx+vz*vz) plot(x(:,1),x(:,2));
vx = vx*w ; vz = vz*w-gdt pause ;
x = x + vx*dt ; z = z + vz*dt gset term post color ; # fichier postscript
write(1,*) t, x, z, vx, vz
gset output ’projectile_oct.ps’ ;
if ( z < 0. ) exit
replot ;
enddo
close(1)
end
On obtient, évidemment, une fois de plus la même figure
Ce qui donne la figure 9.2. (fig. 9.3).
En termes de convivialité, Maple s’en sort plutôt bien Les commentaires en termes d’absence de choix de l’al-
grâce au graphisme intégré. Il a toutefois des défauts de gorithme seraient les mêmes qu’avec Maple. L’avantage
plusieurs ordres : 1o on n’a pas la maı̂trise de l’algorithme par rapport au programme fortran est la possibilité d’in-
utilisé (probablement Runge-Kutta), 2o on ne sait pas quel clure dans la liste des commandes graphiques.
Physique numérique, Philippe Depondt
fait avec Octave
1
0.8
0.6
z
0.4
0.2
0 fijx, fijy, fijz, f(n,3), fij, g, v, k, ms, dt, rij
0 0.5 1 1.5
x
Figure 9.3 – Trajectoire du projectile z(x) obtenu à l’aide
d’Octave.
9.2.5 Une ≪ grosse ≫ simulation : les an-
neaux de Saturne.
Les sondes interplanétaires américaines Voyager
(http://voyager.jpl.nasa.gov/) ont pris des pho-
tos magnifiques des anneaux de Saturne montrant des
structurations complexes qui ont plongé les astronomes
(et les non-astronomes aussi) dans l’émerveillement
(voir, par exemple http://pds.jpl.nasa.gov/planets/
welcome/saturn.htm ). Le problème physique sous-jacent
est, du moins dans le principe, d’une simplicité biblique !
Il y a n astéroı̈des en interaction gravitationnelle avec
Saturne et entre eux. En supposant que Saturne est
beaucoup plus lourd que les astéroı̈des, les équations du
mouvement s’écrivent sans complication majeure :
Gms mi X Gmi mj
mi~r̈i = − 2 r̂i − 2 r̂ij , i, j ∈ [1, n]
ri rij
j (j6=i)
avec des notations banales 4 , et où l’on n’a introduit
que des interactions gravitationnelles. Ce système n’est
évidemment pas aisé à résoudre analytiquement : il s’agit
de 3n équations différentielles du second ordre, non-
linéaires, couplées. . . mais l’algorithme de Verlet peut
traiter ce genre de problème sans difficulté.
9.2.5.1 Un programme de simulation.
Dans l’exemple de programme qui suit (écrit en for-
tran77) on a considéré 500 astéroı̈des dans le champ de
gravitation de Saturne (considéré comme beaucoup plus
lourd que les astéroı̈des et immobile). Les conditions ini-
tiales sont fixées dans un fichier dit ≪ de configuration ini-
tiale ≫ produit par un autre programme d’initialisation ;
on a d’ailleurs prévu de tester l’existence de ce fichier (in-
struction inquire). De même, un fichier de paramètres
de simulation (nombre de pas d’intégration, intervalle
d’écriture des résultats, valeurs du pas d’intégration)
est également lu : on n’a aucune information à fournir
au clavier ; pour un programme susceptible de tourner
plusieurs heures d’affilée, voire plusieurs jours, il n’est pas
inutile de conserver sous forme de fichiers, une mémoire
des paramètres de la simulation.
program saturn
!
4. la notation r̂ désigne le vecteur unitaire parallèle à ~
r.
131
! programme pour calculer les trajectoires de n
! asteroides qui tournent autour d’une planete,
! par exemple, Saturne
!
implicit none
integer :: n, i, j, step, nstep, iprint
parameter( n = 500 ) ! nombre d’asteroides
! positions, vitesses & masses
double precision :: r(n,3), vr(n,3), m(n)
logical :: ok ! variable logique multi-usage
double precision :: xij, yij, zij, rijsq, fijr, &
2
!
parameter( g = 1.0, ms = 1.0 ) ! constante de
! gravitation & masse de la planete
!
! initialisations
!
! verifier le fichier de config
inquire(file=’saturn.cnf’,exist=ok)
if( .not. ok ) stop &
’Il faut d’’abord creer le fichier de configuration’
!
! lire la configuration initiale
open(1,file=’saturn.cnf’)
read(1,*) r, vr, m
close(1)
!
! verifier le fichier de parametres
inquire(file=’saturn.inp’,exist=ok)
if( .not. ok ) stop &
’Il faut d’’abord creer le fichier de parametres’
!
! lire les parametres de simulation
open(1,file=’saturn.inp’)
! nombre de pas, intervalle d’impression
read(1,*) nstep, iprint
read(1,*) dt ! pas de temps
close(1)
Il faut ensuite prévoir des fichiers pour stocker les résultats
de la simulation : un fichier de positions où seront inscrits
les ~ri (t), la liste des positions des astéroı̈des au cours du
temps ; c’est a priori un fichier qui risque de se révéler assez
volumineux, donc pour gagner du temps il sera binaire 5 .
Un autre fichier sert à garder l’énergie : celle-ci étant un
invariant du mouvement, il sera prudent de vérifier après
coup qu’il en est bien ainsi !
!
! fichier de positions (binaire)
open(1,file=’saturn.pos’,form=’unformatted’)
!
open(2,file=’saturn.ener’) ! fichier d’energie
puis on démarre la simulation à proprement parler. Il y
a une boucle sur le temps, évidemment, et à chaque pas
de temps, on doit calculer les forces qui s’appliquent à
chaque astéroı̈de : d’abord la force exercée par Saturne,
puis les forces exercées par tous les autres astéroı̈des,
compte tenu, bien sûr, du principe de l’action et de
la réaction ! On notera au passage, l’introduction d’une
interaction répulsive en r−12 à très courte portée des-
tinée à tenir compte très approximativement des collisions
entre astéroı̈des : ces collisions sont considérées comme
élastiques dans ce cas, ce qui est d’un réalisme douteux,
mais on pourrait choisir autre chose.
5. cela fait gagner le temps de conversion binaire (en machine)
vers ASCII et réciproquement à la lecture.
132 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

! ! ecrire tous les IPRINT pas les positions

! simulation ! et l’energie du systeme
! if (mod(step,iprint) == 0 ) then
! la grande boucle commence ici write(1) r
do step = 1, nstep ! pour pouvoir verifier l’invariance de l’energie
! forces & energie potentielle write(2,*) step*dt, v, k, v+k
! endif
v = 0. ! initialisation de l’energie potentielle enddo
! ! la grande boucle s’arrete ici
! d’abord s’occuper de Saturne !
do i = 1, n close(1); close(2)
xij = r(i,1); yij = r(i,2) ; zij = r(i,3) end
rijsq = xij*xij + yij*yij + zij*zij
! fijr est fij/rij Il n’y a rien de bien exotique dans ce programme. . . et l’on
fijr = -g*m(i)*ms/(rijsq*sqrt(rijsq)) notera qu’il suffit de changer une instruction pour aug-
f(i,1) = fijr*xij menter ou diminuer le nombres d’astéroı̈des concernés :
f(i,2) = fijr*yij ça ne changera guère que le temps d’exécution et le vol-
f(i,3) = fijr*zij ume occupé par les fichiers de résultats ! Comme il s’agit
v = v + fijr*rijsq d’un programme très simple, il n’est pas divisé en sous-
enddo programmes : l’usage en la matière est plutôt d’isoler la
!
partie ≪ Verlet ≫ dans un sous-programme, le calcul des
! calculer les forces inter-asteroide et sommer
! les bornes des boucles tiennent compte de ce
forces et de l’énergie potentielle dans un autre, etc.
! que fji = -fij (action et reaction), donc
! on ne prend que les j > i 9.2.5.2 La conservation de l’énergie.
do i = 1, n-1
do j = i+1, n La figure 9.4 montre l’intérêt qu’il peut y avoir à
xij = r(i,1)-r(j,1) surveiller l’énergie du système. . . qui ne se conserve pas,
yij = r(i,2)-r(j,2) contrairement à ce que voudraient les lois de la mécanique
zij = r(i,3)-r(j,3) newtonienne !
rijsq = xij*xij + yij*yij + zij*zij
rij = sqrt(rijsq)
! forces gravitationnelles & terme repulsif
fij = -g*m(i)*m(j)/rijsq + 1.e-30*rij**-13
fijr = fij/rij
fijx = fijr*xij
fijy = fijr*yij
fijz = fijr*zij
!
f(i,1) = f(i,1) + fijx
f(i,2) = f(i,2) + fijy
f(i,3) = f(i,3) + fijz
! le principe d’action et de reaction s’applique
f(j,1) = f(j,1) - fijx ! ici
f(j,2) = f(j,2) - fijy
f(j,3) = f(j,3) - fijz
! energie potentielle
v = v - g*m(i)*m(j)/rij & Figure 9.4 – Energies potentielle (en rouge), cinétique (en
+ 0.083333333333333d-30*rij**-12
vert) et totale (en bleu) dans la simulation des anneaux
enddo
enddo
de Saturne.
!
! fin du calcul des forces et Les unités de temps et d’énergie de cette figure sont
! de l’energie potentielle des unités ≪ réduites ≫ données par le choix de G et
! de la masse de Saturne, l’un et l’autre fixés à un. Dans
! verlet commence ici ce système d’unités, le pas d’intégration temporel est de
do j = 1, 3 δt = 10−4 , et il y a 10000 pas pour ce ≪ run ≫ d’essai.
do i = 1, n La durée d’exécution dépend évidemment de la puissance
vr(i,j) = vr(i,j) + f(i,j)*dt/m(i) de l’ordinateur utilisé : sur un PC à 500MHz, il a fallu
r(i,j) = r(i,j) + vr(i,j)*dt
15mn, or le système n’a guère eu le temps, dans ses unités
enddo
de temps à lui, d’évoluer sensiblement (on le voit par la
enddo
! verlet finit ici faible variation de l’énergie potentielle), il faudra faire des
k = 0. ! energie cinetique simulations beaucoup plus longues. . . (voir la table 9.1).
do i = 1, n Il faut toutefois d’abord régler cette question de la
k = k + & (non)conservation de l’énergie : une simulation qui vi-
m(i)*(vr(i,1)**2 + vr(i,2)**2 + vr(i,3)**2) ole ainsi un principe fondamental de la physique doit
enddo obligatoirement avoir une raison valable pour le faire !
k = 0.5*k La première hypothèse qui vient à l’esprit est que le
Physique numérique, Philippe Depondt 133

verge pour r → 0 et que donc, lorsque deux objets s’ap-

Table 9.1 – Comment faire tourner des programmes qui prochent de très près, on peut s’attendre à une brusque
durent longtemps ? accélération de leur mouvement nécessitant alors un pas
— d’intégration sensiblement plus court. On a déjà par-
Lorsqu’on fait de grosses simulations, il peut être gênant de mo- tiellement traité cette difficulté en ajoutant un poten-
biliser un ordinateur plusieurs heures, voire plusieurs jours d’af- tiel répulsif en 1 qui représente le ≪ cœur dur ≫ des
r 12
filée : on peut avoir envie de consulter son courier électronique,
astéroı̈des (figure 9.5). Reste donc à traiter de la même
éditer un texte, tracer une courbe. . . Le système Unix/Linux
façon les interactions entre la planète Saturne elle-même
permet de faire tourner des programmes longs en tâche de fond,
sans gêne pour les autres activités. Il s’agit de lancer une tâche et les astéroı̈des, compte tenu du fait que la planète est
avec une faible priorité tout en ≪ gardant la main ≫ pour faire beaucoup plus grosse.
autre chose en même temps ; or Unix est un système d’ex-
ploitation multitâche, c’est-à-dire que le temps du processeur
est hâché en petites séquences très courtes et les différents pro-
grammes en cours d’exécution se partagent ce temps. Ainsi,
par exemple, lorsqu’un programme mouline tranquillement des
nombres en tâche de fond, si on appuie sur une touche du
clavier, le programme est interrompu afin que le processeur
puisse traiter ce nouvel événement, puis redémarre ensuite.
Il y a plusieurs façons de d’y prendre :
1. mogroprog &
où le symbole & rend la main sur la fenêtre concernée.
C’est exactement comme lorsqu’on tape une instruction
comme emacs machin.f &, la fenêtre n’est pas monopo-
lisée par emacs.
2. nohup mogroprog &
donne le même résultat sinon que nohup (no hang up)
empêche l’arrêt de l’exécution du programme si l’on se
déloggue. Ainsi, on peut lancer le programme, puis clore la Figure 9.5 – Energie potentielle gravitationnelle en − 1r
session, rentrer chez soi et revenir le lendemain pour voir −30

ce que le programme a fait pendant ce temps. . . Un autre
utilisateur qui aurait ouvert une autre session entre-temps
peut très bien ne pas s’apercevoir qu’il y a quelque chose
qui tourne en même temps que ses propres applications !
3. at 2
mongroprog
(en rouge), et celle en − 1r + 10r12 (en vert). Il est aisé
de calculer qu’avec 500 astéroı̈des et un rayon d’orbite
moyen r = 1, la distance moyenne entre deux astéroı̈des
est un peu plus grande que la distance à laquelle le terme
répulsif commence à intervenir : les astéroı̈des sont donc
≪ presque ≫ au contact, du moins au début de la simula-

^D tion si on les place sur un cercle.

c’est l’exécution différée : dans l’exemple ci-dessus, le pro-
gramme mongroprog démarrera à 2 heures du matin. Le
symbole ^D représente la touche contrôle (Ctrl) main- On obtient ainsi un résultat assez satisfaisant (figure
tenue enfoncée en même temps que la touche d : cela 9.6) : les énergies potentielles et cinétiques varient en sens
permet de marquer la fin de la séquence d’instructions opposés, la somme restant constante. Il faudrait ensuite
concernées par le lancement différé. bien sûr optimiser le pas d’intégration afin de conserver la
4. batch constance de l’énergie totale tout en réduisant autant que
mongroprog possible le nombre de pas d’intégration nécessaire pour
^D obtenir les événements recherchés.
le résultat est similaire à nohup, mais c’est plus commode
si l’on veut faire faire plusieurs choses à la suite :
batch
mongroprog
traite result
rm -f temp junk file*
grocalcul
^D

pas d’intégration choisi est trop grand : il faudrait donc

le réduire. Cependant, réduire le pas d’intégration est
coûteux en temps de calcul (puisque, plus le pas est pe-
tit, plus il faut faire de pas pour une même longueur de
simulation) et les variations de l’énergie n’interviennent
que de temps en temps : quelques événements rares per-
turbent le déroulement de la simulation et il paraı̂t dom-
Figure 9.6 – Évolution temporelle des énergies après in-
mage d’augmenter sensiblement le temps de calcul pour
troduction du terme répulsif.
quelques événements indisciplinés.
Il faut se rappeler que l’interaction gravitationnelle di-
134 Licence de physique L3 : PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

9.2.5.3 Utilisation des résultats.

Lorsqu’on a fait une simulation comme celle-ci et que
l’on a vérifié qu’elle se comportait de telle façon que l’on
puisse être raisonnablement convaincu que ≪ ça marche ≫,
le plus gros travail reste à faire. Il faut en effet commencer
à faire de la physique avec l’outil que l’on a fabriqué :
la première idée est de faire un film, représenter à l’aide
d’outils graphiques appropriés l’évolution temporelle du
système, les trajectoires des particules au cours du temps.
Mais comment suivre 500 trajectoires (ou plus) simul-
tanément ? Il y a alors un travail de réflexion théorique à
faire du type ≪ dans ce problème quelles sont les grandeurs
physiques pertinentes ? ≫. Ici, on peut, par exemple, cal-
culer la distribution des distances des astéroı̈des à Sat-
urne, ceci en fonction du temps. Si des anneaux se for-
ment, cette distribution doit présenter des pics marqués
pour les rayons des anneaux.
De fait, dans la simulation présentée ici, cette distribu-
tion devient très rapidement continue sans aspérité remar-
quable : pas d’anneaux, donc. Que faudrait-il faire pour
en obtenir ? Il semblerait qu’à ce jour (chercher le mot-
clef saturn sur internet ou voir J. Burns, D. Hamilton et
M. Showalter, Pour la science, Avril 2002, p. 78) la dy-
namique des anneaux reste encore un peu mystérieuse :
on invoque l’effet des satellites plus massifs de Saturne
ou celui des chocs inélastiques entre astéroı̈des et encore
le champ magnétique de la planète. . . Il y a donc là des
découvertes à faire !

9.3 Que peut-on en conclure ?

La diversité des problèmes que l’on peut traiter par
des moyens numériques est énorme, il n’y a donc pas de
réponse unique à cette question. En outre les habitudes des
chercheurs sont très variables : deux personnes différentes
attaqueront sans doute le même problème différemment,
sans que l’on puisse toujours dire a priori lequel a rai-
son. Le meilleur outil est d’abord celui que l’on maı̂trise
et dans bien des cas, fortran, C, Maple ou Octave sont
interchangeables, autant utiliser alors le plus simple.
Les cas extrêmes sont d’une part le calcul qui a une so-
lution analytique : le logiciel de calcul formel est alors
irremplaçable ; de l’autre, la grosse simulation du type
≪ anneaux de Saturne ≫ lourdement consommatrice de

temps de calcul : les logiciels sophistiqués (et gourmands

en ressources, CPU et mémoire) ne feront que rendre le
problème infaisable, alors qu’un langage de programma-
tion simple permet de limiter les dégâts. Entre les deux,
règne un continuum : à chacun de tenter de s’y retrouver !
—
Le but du présent cours est donc de donner quelques
points de repères pour tenter de permettre à chacun de
faire des choix informés : joyeuses computations à tous. . .
Chapitre 10

Bibliographie.

1. J. Bass, Cours de mathématiques, Masson (1956)

2. B. P. Demidovich, I. A. Maron, Computational Math-
ematics, MIR (1973), trad. angl. G. Yankovsky, MIR
(1987)
3. W. H. Press, S. A. Teukolsky, W. T. Vetterling,
B. P. Flannery, Numerical Recipes in Fortran Cam-
bridge University Press (1986, 1992, . . .)
4. D. Taupin, Probabilities data reduction and error
analysis in the physical sciences, les Editions de
Physique (1988)
5. M.P. Allen, D.J. Tildesley, Computer simulation of
liquids Oxford (1990)
6. J. F. Kerrigan, Migrating to Fortran90, O’Reilly
(1993)
7. J. R. Shewchuk, An Introduction to the conju-
gate gradient method without the agonizing pain,
www.cs.cmu.edu/~jrs/jrspapers.html (1994)
8. L. Sainsaulieu, Calcul scientifique Masson (1996)
9. T. Pang, An introduction to Computational Physics,
Cambridge University Press (1997)
10. B. W. Kernighan, D. M. Ritchie, Le langage C, Mas-
son (1997)
11. Ph. Depondt, Physique numérique, Vuibert (1998)
12. J. M. Thijssen, Computational Physics, Cambridge
University Press (1999)
13. Ch. Guilpin, Manuel de calcul numérique appliqué,
EDP Sciences (1999)
14. Y. Epelboin, Cours de méthodes numériques pour la
physique, http://physp6www.cicrp.jussieu.fr (2001)
15. J.-J. Chattot, Computational Aerodynamics and
Fluid Dynamics, Springer (2002)
16. K. Protassov, Analyse statistique des données
expérimentales, EDP Sciences (2002)
17. I. Danaila, F. Hecht, O. Pironneau, Simulation
numérique en C++, Dunod (2003)
18. M. Metcalf, J. Reid, M. Cohen, Fortran 95/2003 ex-
plained, Oxford University Press (2004)
19. J.-P. Demailly, Analyse numérique et équations diffé-
rentielles, EDP Sciences (2006)
20. Collectif, Dossier Pour la Science La modélisation in-
formatique, exploration du réel, (juillet/septembre
2006), voir également http://interstices.fr
21. W. Krauth Statistical mechanics : Algorithms and
Computations, Oxford University Press (2006)

135