La boı̂te à outils

de la
PHYSIQUE NUMÉRIQUE
Licence de physique L3
Physique fondamentale et PHYTEM
Université Pierre et Marie Curie Paris-6 — ENS-Cachan

Ph. Depondt1

Année 2008-2009

1
INSP (Institut des NanoSciences de Paris), CNRS UMR 7588 & Université P. et M. Curie Paris-6.
Contact : depondt@insp.jussieu.fr
2 Licence de physique L3 : Physique Fondamentale & 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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.1 Instructions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
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 : Physique Fondamentale & 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 L’équation logistique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.1 De la multiplication des insectes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.2 Étude préalable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.3 Étude numérique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
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 ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
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
4.10.3 Filtrage de données expérimentales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11 Les méthodes de Monte-Carlo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Physique numérique, Philippe Depondt 5

4.11.1 Processus stochastiques et chaı̂nes de Markov. . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

4.11.2 Les vicissitudes de π. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
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
9.3 Que peut-on en conclure ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
6 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

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-
trice1 , 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 impor-
tant aux décideurs (et aux payeurs) à la fois pour la re-
cherche 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 chi-
miques et énergétiques.
– La matière condensée, les matériaux et les nanos-
ciences en physique et en chimie offrent une variété
incroyable de problèmes mettant en jeu un grand
nombre (entre quelques dizaines et le nombre d’Avo-
gadro !) d’atomes : des calculs classiques ou quan-
tiques, 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 dispo-
nible ne peut toutefois être utile et profitable que s’il y a
des personnes compétentes pour s’en servir de façon per-
tinente et donc convenablement formées : il s’agit là d’une
double compétence à la fois scientifique dans la discipline
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 supposé ac-
quis ; 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 solution analy-
tique est connue : c’est qu’ici, justement, l’objectif est de
résoudre des problèmes pour lesquels il n’y a pas de solu-
tion analytique, c’est-à-dire l’immense majorité. . . L’infor-
matique 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 ensei-
gnants mais aussi souhaitons-le pour ceux qui le reçoivent,
une fois - répétons-le - l’outil acquis, est qu’il ne se can-
tonne pas à tel ou tel domaine de la physique, mais qu’il
pioche ses exemples dans des champs aussi variés que pos-
sible, 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 vo-
3 « Certains accompagnent le peloton tandis que d’autres traı̂nent
derrière. »
8 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

lontaire : à chacun de sélectionner ce qui lui paraı̂t utile, Un autre exemple, moins célèbre sans doute, est
les séances de travaux dirigés et de travaux pratiques étant l’ensemble des opérations qui, pendant la Révolution
de bons guides en la matière4 . Française, ont abouti à la définition du mètre, en rem-
placement 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
1.1 Des méthodes numériques, universel (on aurait certes put choisir comme référence
les unités en vigueur à Paris, mais l’idéal universaliste
pour quoi faire ? des 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 et
nateurs pour tenter de traiter des problèmes de physique
le soin avec lequel ils menaient leurs observations (Jean-
aussi variés que possible, afin, soit de se simplifier la vie
Baptiste-Joseph Delambre (1749-1822) et Pierre-François-
et gagner du temps en faisant faire par un ordinateur des
André Méchain (1744-1804)) équipés des instruments de
calculs fastidieux que l’on pourrait sans doute faire soi-
visée les plus élaborés, mesurer entre Dunkerque et Bar-
même, soit au contraire de s’attaquer à des questions que
celone 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 recouvre
façon qu’un calcul permette d’y répondre de manière sa- complétement l’arc de méridien compris entre les deux
tisfaisante, 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 mea-
1.1.1 Quelques jalons. . . sure of all things, Free Press (2002)) dura sept ans (1792-
1799) dans une France en proie à toutes sortes de vio-
Il ne faut cependant pas croire que les calculs numé- lences (les invasions, les guerres révolutionnaires, la Ter-
riques aient attendu l’invention de l’ordinateur pour voir
reur, Thermidor. . .) : dans les jours qui suivirent la fuite
le jour. Au XVIIe siècle déjà, l’invention des logarithmes de Louis XVI à Varennes, Delambre avec son attirail de
par John Napier (1550-1616) fut une révolution (Miri- longue-vues et d’instruments, et, pire encore, son ordre de
fici logarithmorum canoni descriptio, Edimbourg (1614)) : mission signé par le roi fugitif, fut arrêté à plusieurs re-
une multiplication se transformait en addition -beaucoup prises comme « espion » ; un peu plus tard, Méchain resta
plus aisée-, une extraction de racine carrée en division bloqué en Catalogne quand l’Espagne bourbonnienne et
par deux ! L’astronome Johannes Kepler (1571-1630) qui la France républicaine se trouvèrent en guerre ; Méchain
découvrit l’ellipticité des orbes planétaires, se livra à dut aussi lutter en permanence contre un état psycholo-
des calculs numériques vertigineux dans, par exemple, gique dépressif lié à son inquiétude quant à la qualité de
son œuvre principale, l’Astronomie Nouvelle (Astronomia ses mesures. Les deux hommes revinrent enfin à Paris en
Nova, (1609) ). Ainsi, par exemple, pour évaluer les posi- 1799 pour présenter leurs résultats : une conférence inter-
tions au cours du temps d’une planète alors qu’elle par-
nationale de mathématiciens devait : 1o vérifier et valider
court ce qui n’est encore qu’un « ovoı̈de » avec une vitesse la cohérence de leurs observations, et 2o en déduire la lon-
variable5 , il divise la trajectoire en 360 petits segments gueur du mètre.
et additionne les résultats obtenus pour chaque segment :
c’est ce que l’on appelle maintenant une discrétisation. Il fallait donc, pour la deuxième partie de ce travail, faire
Kepler, lui, appelait cela un « morcellement numérique » des calculs de trigonométrie sur une surface sphérique.
et se plaignait de ce que ce calcul fût « mécanique et en- On savait cependant qu’outre les montagnes dont il fal-
nuyeux » : comme son employeur, l’empereur Rudolf II., lait bien sûr tenir compte, la Terre n’était pas une sphère
ne payait son salaire qu’occasionnellement, il n’avait pas parfaite mais plutôt un ellipsoı̈de de révolution légèrement
les moyens d’employer lui-même un assistant pour l’ai- applati aux pôles : toutefois, le choix d’un arc de méridien
der. . . Il connaissait d’ailleurs les tables de logarithmes de situé à des latitudes intermédiaires (le 45˚ parallèle passe
Napier et en établit lui-même dans ses Tables Rodolphines à Bordeaux et donc coupe l’arc Dunkerque-Barcelone non
(Tabulæ Rudolphinæ, (1627) ). loin de son milieu) permettait d’espérer obtenir une va-
leur moyenne qui pût servir de référence. On fit alors une
4 Le chapitre 5, en particulier doit être considéré comme la suite découverte complétement inattendue : le géoı̈de n’était pas
logique du cours, mais n’en fait à proprement parler partie. régulier mais recouvert de bosses et de creux. La valeur
5 Jusqu’alors, on croyait, Copernic, Tycho Brahe et Galilée y com-
du rayon de courbure de la surface terrestre dépendait de
pris, que les mouvements planétaires étaient des mouvements cir-
culaires uniformes, ou des combinaisons de mouvements circulaires l’endroit où il était mesuré, or la précision magnifique des
uniformes, ce qui permettait un calcul facile des positions planétaires observations de Delambre et Méchain, le soin méticuleux
futures. Kepler, comme on le sait, introduisit, à cause d’un désaccord -voire obsessionnel dans le cas de Méchain- avec lequel
de 8 minutes d’angle dans la position de Mars, les orbes, d’abord
elles avaient été réalisées ne permettaient pas de mettre ce
ovoı̈des puis elliptiques, parcourues à vitesse variable ; les prédictions
en devenaient beaucoup plus difficiles : il fallut attendre Newton pour résultat sur le compte d’erreurs ou d’imprécisions de me-
voir la résolution de ce problème. sure. Après de longues tergiversations, on finit néanmoins
Physique numérique, Philippe Depondt
a b
Graduations logarithmiques
Fig. 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.
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 De-
lambre et Méchain : corrections pour l’altitude, la
réfraction atmosphè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 participant devait faire indépendamment
l’intégralité des calculs en utilisant ses propres méthodes !
On reste pantois devant la dextérité et l’acharnement cal-
culatoires 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 direc-
teur de l’observatoire de Berlin, Johann Galle, vit à l’en-
droit indiqué, le 23 septembre 1846, la nouvelle planète,
Neptune : un triomphe pour le valeureux calculateur !
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
9
Curseur transparent
Réglette
a.b
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 Byron6 , les réalisations pratiques ne donnèrent jamais
satisfaction, à cause semble-t-il des frottements excessifs
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 à vide7 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.
Rapidement, les banques, les compagnies d’assurance8
6 la fille du poète.
7 il n’y avait pas encore de transistors et encore moins de circuits
intégrés.
8 Du point de vue des constructeurs d’ordinateurs, ce genre de
10 Licence de physique L3 : Physique Fondamentale & PHYTEM,
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 puissants
du moment : cette histoire se poursuit actuellement, cer-
tains calculs quantiques, par exemple, se chargeant, par
leurs exigences en termes de puissance de calcul, de rame-
ner à une saine modestie les fabriquants des processeurs
les plus éblouissants !
Fig. 1.2 – Page de garde de la table de logarithmes Bou-
vart et Ratinet (édition 1957) en usage dans les classes
scientifiques des lycées jusque dans les années 1970.
À titre de témoignage de la rapidité avec laquelle la vie
des scientifiques a changé, rappelons qu’encore au début
des années soixante-dix, les élèves des classes préparatoires
passaient plusieurs heures par semaine à remplir des co-
lonnes de chiffres, stylo d’une main, table de logarithmes
(figures 1.2 et 1.3) de l’autre, un entraı̂nement jugé in-
dispensable à leur dextérité calculatoire. . . les calculettes
électroniques n’ayant détrôné l’invention de Napier qu’à
clients avait l’avantage d’être largement solvable, un encouragement
fort à faire les investissements nécessaires à la production de calcu-
latrices rapides et fiables !
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
la fin de la décennie. Un livre de « mathématiques com-
putationelles9 » 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 co-
lonnes 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 calculs scienti-
fiques étaient réalisés de la sorte jusqu’à un passé somme
toute récent à l’échelle d’une vie humaine10 .
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 Poin-
caré, é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évisible11 . 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 Lorenz12 se mit à résoudre sur ordinateur des
équations différentielles qui visaient à simuler le compor-
tement de l’atmosphère terrestre : il redécouvrit alors
des systèmes au comportement irrégulier similaire à
ce qu’avait prédit Poincaré. Le triangle simulation-sur-
ordinateur/théorie/expérience donna naissance à un do-
maine de recherches nouveau et toujours actif de nos
jours : le chaos, la turbulence, les fractals. . ., tout ce qui a
trait à la dynamique des systèmes non-linéaires. Il fallait
évidemment pour cela que l’on pût faire des simulations
sur ordinateur, car le calcul analytique est insuffisant :
d’ailleurs maintenant, la météorologie nationale est un 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
dans lequel le retard de l’Union soviétique était sensible.
10 Pour fixer les idées, précisons que l’espèce Tyranosaurus Rex
était déjà éteinte depuis quelques années. . .
11 Voir par exemple : David Ruelle, Hasard et chaos, Odile Jacob
(1991).
12 À ne pas confondre avec l’éthologiste autrichien Konrad Lorentz
et ses oies.
Physique numérique, Philippe Depondt 11

Fig. 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 !

plus gros consomateurs civils de calcul sur les ordinateurs
les plus puissants.
Dans un autre domaine, les expériences faites par
exemple à 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
positions 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 diffi-
cile, la « modélisation de données d’expérience » qui
consiste à ajuster un modèle théorique aux données expéri-
mentales connues, 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 ajus-
tant un nombre souvent élevé de paramètres (les positions
atomiques, la caractérisation de l’agitation thermique) et
ne peut pratiquement se faire qu’à l’aide d’un ordinateur.
L’étude des systèmes désordonnés est aussi grosse
12 Licence de physique L3 : Physique Fondamentale & 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
Tab. 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. . .
Tab. 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 se-
condes à 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 stations
disséminés aux quatre coins du monde, glanent quotidienne-
ment 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).
consommatrice de moyens de calcul. Par exemple, une
chaı̂ne linéaire harmonique d’atomes, tous de masse m,
est parcourue de vibrations de type onde plane xℓ =
u ei(ωt−kℓa) , où xℓ est le dépacement de l’atome ℓ par rap-
port à sa position d’équilibre et a est la distance inter-
atomique. Un calcul classique13 à 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 :
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)
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 ma-
trice n × n, appelée « matrice dynamique » où n est le
nombre 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
tenterait 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
r   cas bien connu, mais aussi les simulateurs de vol per-
C  ka  mettent à des pilotes d’essais de tester le comportement
ω(k) = 2 sin
m 2  d’un nouvel avion sans risquer leurs vies et des simulateurs
d’opérations permettent à des chirurgiens de s’entraı̂ner
où C est la constante de force entre deux atomes. Main- sans risquer celles de leurs patients ! Le dossier de la revue
tenant, si la chaı̂ne comporte des impuretés de masse Pour la Science (voir la bibliographie, ref. (20)) consacré
13 Voir, par exemple : Charles Kittel, Introduction to Solid State- à la modélisation informatique parcourt quelques thèmes
Physics, New York : Wiley, (1986). « à 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’apporte-
rait rien de plus à notre objectif, sans apporter la puissance
qu’offre fortran95 en particulier dans la manipulation
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 essayer 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 convi-
vial 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’« informatique
pour physiciens » mais un cours pratique de « Physique
numérique » c’est-à-dire des méthodes qu’utilisent les phy-
siciens pour résoudre un grand nombre de problèmes de
physique.
14 Licence de physique L3 : Physique Fondamentale & 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 rapidement
au lecteur la capacité d’écrire des programmes ; elles ne
remplacent pas, bien sûr, un cours systématique1. Il s’agit
ici d’un outil dont la maı̂trise est un préalable indispen-
sable à 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 rapidement
des programmes simples « qui marchent » car, sinon, les
séances de travaux pratiques destinées à faire de la phy-
sique que l’on espère intéressante avec cet outil, en devien-
draient suprêmement ennuyeuses pour tous, enseignants
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émoire2. 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équentiellement3 . Une ins-
truction 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 Neu-
mann s’est préoccupé de réalisations pratiques de la machine de Tu-
ring 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 convivial4 .
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
exemple :
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 va-
riables étant réelles, exp désignant évidemment l’expo-
nentielle 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 va-
riables pour produire un programme exécutable : cette
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 : Physique Fondamentale & 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.
Fig. 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.
Tab. 2.1 – Pour comprendre comment « ça marche » :
quelques éléments d’assembleur
L’unité centrale (CPU ou Central Processing Unit) d’un ordi-
nateur ne travaille pas directement dans la mémoire vive : elle
a ses propres emplacements mémoires appelés « registres ».
Elle doit donc aller chercher en mémoire vive les grandeurs
nécessaires à un calcul, les copier dans ses registres, faire les
opérations requises et stoker les résultats dans la mémoire.
Pourquoi toutes ces complications, pourquoi ne pas tout sto-
cker d’emblée dans les registres de l’unité centrale ? Tout sim-
plement 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 nombre 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’empla-
cement $B003 et place le résultat dans A. (Suite : table 2.2)
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 texte5 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 inutilisables en
l’état par l’unité centrale. On doit alors compiler le pro-
gramme pour obtenir un fichier exécutable, et enfin lancer
l’exécution de celui-ci. Bien, évidemment, à chaque mo-
dification du fichier source, il faut re-compiler et relancer
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.
Tab. 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
comparaison est positif (B veut dire branch et GE signifie Grea-
ter or Equal ), pour y lire une instruction. On obtient ainsi la
possibilité d’instructions soumises à condition ; reste toutefois
à espérer que l’emplacement en question contient bien une ins-
truction, c’est une source de « plantages » spectaculaires, mais
là réside une grande part du charme désuet de l’assembleur !
Si l’on souhaite un plat un peu plus corsé encore, on peut pla-
cer 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 sui-
vant : 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.
l’exécution6 !
6 il existe des environnements intégrés, en particulier sous Win-
dows, dans lesquels ces étapes sont plus ou moins automatiques et
Physique numérique, Philippe Depondt
Le fortran est le premier de ces langages évolués à
avoir vu le jour, mais beaucoup d’autres ont suivi : algol,
cobol, pl1, basic, pascal, forth, C, ada, occam. . .
Pour ce qui est de la programmation scientifique, 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 formules
de façon aussi proche que possible de ce que l’on fait lors-
qu’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 fortra-
nIV 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 à perfo-
rer7 a marqué un certain nombre de générations de pro-
grammeurs. . . À la fin des années soixante-dix et au début
des années quatre-vingt, les cartes perforées disparurent,
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 ») capables
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.
Deux normes officielles de fortran coexistent actuel-
lement : fortran77 qui reste assez classique et for-
tran90 (ou fortran95 quasiment identique), beaucoup
plus évolué, qui est appelé à le remplacer progressivement
et qui constitue la norme sur les gros calculateurs dédiés
aux calculs lourds.
Nous utiliserons ici la norme fortran95, principa-
lement pour sa capacité à travailler sur des tableaux
de nombres de façon très confortable et efficace8 . Le
compilateur g77 qui fait partie de toutes les distributions
Linux, librement diffusé par 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), est basé
sur fortran77, mais il intègre un grand nombre de
caractéristiques de fortran90 ce qui en fait un outil
puissant tout en gardant une grande simplicité. Toutefois,
de bons compilateurs fortran95 (g95 et gfortran9)
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 gfortran commence à
être disponible comme faisant partie de certaines distributions
17
commencent à être disponibles en libre diffusion et il n’y
a donc guère de raison de s’en priver. Des « nouvelles
du front » ainsi que des compilateurs téléchargeables,
peuvent être obtenus via le site :
http ://programming.ccp14.ac.uk/fortran-resources/~
cgp/fortran.html
Dans les notes qui suivent, nous suivrons le « format
libre » (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 :
g95 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 fortran10 . 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
machine11 . Evidemment, si l’on utilise un autre com-
pilateur que g95 (par exemple gfortran12, pgf9013 ou
xlf9014 ), il faut remplacer g95 par le nom du compila-
teur.
Le résultat de la compilation est donc, quand tout s’est
bien passé, un programme exécutable qu’il reste à faire
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).
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,
3. que l’on en fait la somme (cela suppose qu’il s’agit de
nombres)
Linux (Debian et Fedora au moment où ces lignes sont écrites) et,
convenablement installé, il paraı̂t plutôt plus efficace à condition
d’utiliser l’option -ffast-math.
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 : g95 $1.f90 -o $1. Ce fichier peut alors être rendu exécutable
par la commande : chmod +x gf95. Pour compiler un programme, il
suffira dorénavant de taper : gf95 monboprog. Selon les besoins, gf95
peut être modifié ensuite pour inclure d’autres options de compila-
tion comme -O3 (optimisation) ou des bibliothèques de calcul.
12 version gnu.
13 compilateur commercial de Portland Group.
14 compilateur ibm.
18 Licence de physique L3 : Physique Fondamentale & PHYTEM,
Edition : emacs monboprog.f90 &
Compilation : g95 monboprog.f90 −o monboprog
Exécution : ./monboprog
Fig. 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. . .
4. que l’on met le résultat dans l’emplacement a.
a = b + c
Ceci n’est pas un = sous-répertoires présents dans un répertoire. On peut créer un
Fig. 2.3 – Le signe = dans une instruction n’est pas une
égalité mathématique !
Il ne faut surtout pas s’imaginer que le signe = ci-dessus
soit une égalité mathématique ! Il s’agit d’une instruction,
d’un ordre que l’on donne à l’ordinateur : on lui « dit » de
calculer la valeur numérique de ce qui se trouve à droite
du signe égal et de le placer dans l’emplacement de la
mémoire désigné par le symbole qui se trouve à sa gauche.
On peut considérer le signe égal comme une affectation ou
une flèche :
a = b
peut être compris comme
a ← b
on met b dans a. Cela a quelques conséquences pratiques, (mettre a dans b) ne signifient pas la même chose et les
ainsi deux instructions :
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Tab. 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 cla-
vier, 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 ap-
paraı̂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 travaillent 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 utilisateurs.
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 travail « moyennes »
mais il a rapidement envahi le monde des ordinateurs des-
tiné au calcul scientifique. Le premier système d’exploitation
de Microsoft, dos (1981), est une version extrêmement sim-
plifiée d’unix, en particulier, il est mono-utilisateur, alors
qu’Unix est multi-utilisateur, c’est-à-dire que plusieurs per-
sonnes 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 ordinateurs per-
sonnels. 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
répertoire (que l’on choisit d’appeler par exemple td1) par la
commande mkdir td1 (make directory) par exemple et chan-
ger 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 !
a = b
(mettre b dans a) et
b = a
Physique numérique, Philippe Depondt
Tab. 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.
Tab. 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.
a = b
b = c
ne signifient pas que les trois nombres a, b et c soient
égaux ! Cela signifie : « prendre le contenu de l’emplace-
ment désigné par la lettre b et le mettre dans a, puis mo-
difer le contenu de b en y mettant le contenu de c ». Donc,
après coup, a et b peuvent être différents. De même, l’ordre
des instructions a une importance : mettons que l’on ait
affecté les valeurs, respectivement, 1, 2 et 3 à a, b et c. Les
deux instructions ci-dessus aboutiront à avoir 2 dans a et
3 dans b et c. Mais si l’on intervertit les instructions :
b = c
19
a = b
alors, a, b et c contiennent la valeur 3. . . Il s’agit donc bien
de deux instructions exécutées l’une après l’autre dans
l’ordre donné dans le programme. Finalement, l’instruc-
tion :
i = i + 1
n’a rien d’absurde : il s’agit simplement de l’ordre d’aug-
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 = 3*x + c ! ATTENTION, CECI N’A AUCUN SENS
est totalement dépourvu de sens pour l’ordinateur car l’ex-
pression a + b à gauche du signe = ne désigne pas un em-
placement 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 nombres réels : c’est ce qu’on appelle une déclaration.
Ainsi la déclaration :
real :: a, b, c
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 nombres
réels dedans15 . Comme on peut changer la valeur du
contenu de ces emplacements, on les appelle variables. Un
nom de variable peut être simplement une lettre comme
a ou x, ou alors une combinaison de lettres et de chiffres
à condition de commencer par une lettre, par exemple :
agecpt, y2, zmax, mais pas : 2pi ou s*3 (* est un ca-
ractère spécial désignant la multiplication). Le caractère
“ ” « blanc souligné » ou underscore est également auto-
risé : pere ubu ou nbr pas. La longueur peut aller jusqu’à
31 caractères : age du capitaine. Il ne faut pas utiliser
les lettres accentuées, cédilles, trémas, et autres signes dia-
critiques. Enfin, fortran ne fait pas la distinction entre
lettres majuscules et minuscules (Zmin est identique à
zmin) alors que le système d’exploitation unix le fait (les
fichiers resultats et Resultats sont distincts).
On peut déclarer des nombres entiers, par exemple :
integer :: i, m, nbrpas
ou des nombres complexes :
complex :: z, s
Toutes les déclarations doivent figurer au
début du programme, avant les instructions dites
« exécutables ». Une instruction du type a = 3*b - c
avec laquelle on « dit » à l’ordinateur de faire quelque
chose est exécutable, une déclaration où l’on réserve de
l’espace pour des variables ne l’est pas.
15 On utilise ici la forme fortran90 destinée à prendre assez rapi-
dement le relais de la forme fortran77 : real a, b, c, également
acceptée par g95.
20 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

L’affectation de valeurs initiales à certaines variables

Tab. 2.6 – Liste des types de variables : peut être faite directement dans la déclaration :
déclaration type des variables
integer entier program addition
real réel implicit none
double precision réel en double précision real :: a, b = 1.414, c = 1.732
a = b + c
complex complexe
write(*,*) a
double complex complexe en double précision end
character chaı̂ne de caractères
logical variable logique L’instruction end marque la fin du programme. L’ins-
truction program donne un nom au programme qui peut
être distinct du nom du fichier-source qui le contient.
En fortran, il existe ce que l’on appelle des
déclarations implicites, survivance des anciennes versions
de ce langage de programmation, qu’il est formellement Tab. 2.7 – Liste des opérations sur les nombres :
déconseillé d’utiliser16 . Pour les rendre inopérantes, on uti-
lise l’instruction : L’addition s’écrit : + e.g. : a + b
La soustraction s’écrit : - e.g. : 3. - x
implicit none La multiplication s’écrit : * e.g. : a*b
La division s’écrit : / e.g. : p/q
2.2.3 Opérations élémentaires sur les La mise à la puissance s’écrit : ** e.g. : x**p
nombres.
Un programme élémentaire pourrait donc être : On peut mélanger les types integer, real, double
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 2.3.1 Pour quoi faire ?
implicit none
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
0,1. On pourrait bien sûr écrire :
La décimale des constantes réelles est marquée par
implicit none
un point et non une virgule (1.414 et non 1,414). Une
real :: x = -10.0, y
constante réelle doit comporter un point : 1. est une y = x**3
constante réelle, mais 1 est une constante entière, 2./3. x = x + 0.1 ; y = x**3
est une constante réelle qui vaut 0,666667, alors que 2/3 x = x + 0.1 ; y = x**3
est 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 « scientifique » x = x + 0.1 ; y = x**3
(comme avec une calculette) pour les nombres réels, ...
1, 6 10−19 s’écrit : 1.6e-19, c’est plus économique qu’ali- etc. L’instruction x = x + 0.1 prend la valeur de x en
gner de nombreux zéros. . . La lettre e ne désigne pas ici mémoire, lui rajoute 0,1 et écrit le résultat dans le même
une variable mais indique l’exposant17 . emplacement : le contenu de x est donc augmenté de 0,1.
16 La raison en est que si l’on fait une faute de frappe en tapant le Donc, x commence par valoir -10, puis −10 + 0, 1 = −9, 9
nom d’une variable (par exemple nb pas au lieu de nbr pas), l’ordi- et l’on calcule y, puis 9,8 avec un nouveau calcul de y, etc.
nateur créera simplement une nouvelle variable, avec des résultats. . . On remarque cependant que la séquence :
imprévisibles ! Si l’on rend obligatoire la déclarations de toutes les
variables, alors le compilateur détectera en principe une variable x = x + 0.1 ; y = x**3
non-déclarée et produira un message d’erreur approprié.
17 on peut parfaitement écrire une instruction du type : e = doit être répétée autant de fois que l’on veut faire le calcul
1.6e-19, il n’y a aucune confusion possible. (ici, 201 fois).
Physique numérique, Philippe Depondt 21

2.3.2 Pratiquement. . . 2.3.3 Boucles imbriquées

Une façon plus élégante de procéder consiste à utiliser Les boucles peuvent être imbriquées les unes dans les
une boucle afin de répéter un grand nombre de fois le même autres :
calcul en faisant varier un paramètre, ainsi :
implicit none
integer :: i do k = kmin, kmax
real :: x, y ...
do i = -100, 100 do ix = ixmin, ixmax
x = 0.1*i ...
y = x**3 enddo
enddo ...
enddo
signifie que l’instruction y = x**3 doit être répétée pour
toutes les valeurs de l’indice i allant de -100 à 100 :
ainsi, la boucle interne sur x s’exécutera pour chaque va-
ainsi x prend successivement les valeurs -10., -9.9, . . .-
leur de k et les instructions qu’elle comporte se répéteront
0.1, 0., 0.1,. . .9.9, 10.18 et l’on doit calculer y pour cha-
donc (kmax-kmin+1)*(ixmax-ixmin+1) fois : cela peut
cune de ces valeurs. L’instruction enddo marque la fin du
faire beaucoup. Par exemple, si kmax=1000, kmin=1,
« bloc » : toutes les instructions comprises entre do et
ixmax=10000, ixmin=1, la boucle interne s’exécutera 107
enddo font partie du même ensemble qui doit être exécuté
fois, et si elle prend 10−3 seconde à l’exécution, le pro-
pour chaque valeur de i.
gramme, lui, prendra 104 s soit 2h45mn ! Si maintenant, la
Il faut remarquer au passage qu’à chaque tour de la
boucle la variable y est modifiée et que donc les anciennes boucle externe est elle-même imbriquée dans une autre
valeurs sont oubliées : à la fin, seule la dernière valeur boucle, on obtient très facilement un programme très
calculée reste. Il faut donc penser à faire quelque chose lourd. . .
des valeurs intermédiaires si on en a besoin : les écrire par
exemple. Ainsi,
implicit none 2.3.4 Boucles munies d’un nom
complex :: z, zim=(0.0,1.0)
integer :: i Quand plusieurs boucles sont imbriquées, il est parfois
real :: omega = 6.283185, t utile de leur donner un nom afin de clarifier le début et la
do i = 0, 1000 fin de chacune :
t = 0.1*i
z = exp(zim*omega*t) ; write(*,*) t, z
enddo boucle1 : do k = kmin, kmax
...
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 boucle2 : do i = imin, imax
du nombre imaginaire i dans la variable zim, dont la partie ...
réelle est nulle et la partie imaginaire égale à 1. ...
Un autre exemple : enddo boucle2
...
implicit none
...
integer :: k, s2 = 0
enddo boucle1
do k = 1, 10
s2 = s2 + k**2
enddo
calcule la somme des 10 premiers carrés. 2.4 Conditions.
Le pas de la boucle est implicitement égal à 1, mais on
peut le choisir explicitement :
Il arrive que l’on veuille que certaines instructions ne
do k = 1, 10, 2 s’exécutent que dans certaines conditions. Par exemple, si
s2 = s2 + k**2 l’on a calculé une quantité y, on peut en vouloir la racine
enddo carrée uniquement si y est positif :
calcule la somme 12 + 32 + 52 + 72 + 92 , et :
do k = 10, 1, -1 if( y > 0.0 ) then
... z = sqrt(y)
enddo endif

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.
18 On note au passage que l’expression 0.1*i mélange une
constante réelle et un entier : le résultat est réel.
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 lo-
giques, première et deuxième colonnes ci-dessous :
22 Licence de physique L3 : Physique Fondamentale & 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 souhaite19 .
Cependant si l’on a une série de possibilités à envisager,
.or. ou
l’instruction select case20 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 sou- write(*,*) 1000.*l*c/12.,’ mm’
mis à condition : 19 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 : 20 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. écrit dans le fichier resultats.
L’instruction :
de
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 nombre
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
Lorsqu’on a fini d’écrire on « ferme » le fichier à l’aide
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
exemple :
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 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

open(10, file=’donnees’) 2.5.3 Les formats.

read(10,*) a, b, c
close(10)
Pour une écriture en mode texte, fichier ou écran, on
peut préciser la façon dont on veut que les choses soient
On peut ouvrir plusieurs fichiers simultanément à condi- écrites. Ainsi,
tion de leur donner des numéros d’unité différents :
write(*,’(i5)’) k
open(10, file=’coefficients’) écrira le nombre entier (i pour integer ) k avec 5 chiffres.
open(11, file=’bornes’) On notera la syntaxe : la deuxième * du write est rem-
open(12, file=’polynome’) placée par : ’(...)’ où les trois points désignent la des-
read(10,*) a, b, c cription du format. De même :
read(11,*) xmin, xmax, dx
imin = xmin/dx ; imax = xmax/dx write(*,’(f10.3)’) r
do i = imin, imax
doit écrire le nombre réel (f pour float, c’est-à-dire à
x = i*dx
décimale flottante) r avec 10 caractères (y compris le point
y = (a*x + b)*x + c
de la décimale) dont 3 après la « virgule » : 123456.789 ou
write(12,*) x, y
1.414 (avec 5 espaces, représentés ici par le symbole
enddo
, pour compléter). Si l’on doit écrire plusieurs nombres
close(10) ; close(11) ; close(12)
à la suite de la même façon, il n’est pas utile de répéter
end
explicitement le format, il suffit de le faire précéder du
Caveat ! Imaginons que l’on ait écrit un programme nombre de fois que l’on veut l’utiliser :
dans un fichier-source calcul.f90. On compile avec la write(*,’(3f12.4)’) x,y,z
commande habituelle et on lance l’exécution. . ., or dans le
programme, il y a les instructions : écrira trois nombres réels sur 12 caractères (soit 36 co-
lonnes en tout, sachant qu’une feuille de papier ou un ter-
open(10,file=’calcul.f90’)
write(10,*) x, y, z minal font en général 80 colonnes) avec chacun 4 chiffres
close(10) après la décimale, par exemple :
1234567.8912 3.14161048576.4321
Question : qu’arrivera-t-il au programme-source ? attention, dans cet exemple, il y a bien trois nombres,
Ce sont des choses que l’on voit régulièrement arriver, mais le dernier occupe les 12 colonnes, et donc, il n’y a
au grand désarrois des victimes, car il ne reste plus alors pas d’espace qui le sépare du précédent.
qu’à tout retaper même si calcul.f90 comportait des cen- On peut mettre des chaı̂nes de caractères dans un for-
taines de lignes ! Un homme - ou une femme - prévenu(e) mat :
en vaut deux. . . write(*,’("L’’age du capitaine est : ")’)
write(*,’(i2," ans")’) age_captain
2.5.2.2 Fichier binaire
Dans ce cas, il vaut mieux, bien sûr, que le capitaine ne
L’écriture d’un fichier texte suppose que les nombres soit pas centenaire. . . Noter que l’apostrophe doit être re-
qui sont stockés en binaire dans la mémoire vive de l’or- doublée (sinon le compilateur interprête cela comme la fin
dinateur soient traduits du binaire en caractères alpha- de la chaı̂ne de caractères).
numériques : par exemple le nombre entier 19 s’écrit 10011 Le format exponentiel ( ou « notation scientifique ») est
en binaire et doit être converti en un caractère 1 suivi du une autre possibilité pour les réels, par exemple :
caractère 9 avant d’être écrit comme du texte. Il arrive ev =1.6e-19
que l’on ait à produire un très grand nombre de nombres write(*,’("eV=",e13.5)’) ev
et que cette conversion prenne un temps de calcul non
négligeable, sans compter la taille du fichier résultat. Dans donne : eV= 0.16000E-18, soit 13 caractères, dont 5
ce cas, on peut avoir intérêt à écrire directement du code après la virgule. Le format g (général) combine f et e
binaire dans le fichier. Evidemment, dans ces conditions on x = 1. ; ev = 1.6e-9
ne peut plus lire ce fichier avec un éditeur ou l’imprimer write(*,’("x=",g13.5," eV = ",g13.5)’) x, ev
sur une imprimante, mais cet inconvénient n’est pas très
important dans le cas présent : qui irait lire directement un donne : x= 1.00000 eV = 0.16000E-08. C’est assez
fichier de plusieurs centaines de kilo-octets de nombres ? commode lorsqu’on veut écrire des nombres dont on ne
Le but ici est de stocker des données en vue d’une utilisa- connait pas a priori l’ordre de grandeur, tout en contrôlant
tion ultérieure à l’aide d’un autre programme21. la place qu’ils prendront pour une mise en page.
La lettre x dans un format signifie un espace, le symbole
Lors de l’ouverture, il suffit de spécifier que le fichier
/ un passage à la ligne. Au contraire, $ inhibe le passage
doit être « non-formatté » : à la ligne après un write. Par exemple :
open(1,file=’nfich binaire’,form=’unformatted’)
Les instruction d’écriture et de lecture se passent alors write(*,’("Donnez l’’age du capitaine : ",$)’)
de spécification de format : read(*,*) agecpt
write(1) x, y, z Lors de l’exécution du programme, la question et la
read(1) a, b, c réponse apparaı̂tront sur la même ligne du terminal.
21 Il faut aussi signaler qu’un tel fichier est moins transportable Les chaı̂nes de caractères peuvent s’écrire avec le format
qu’un fichier texte : le codage binaire dépend du processeur et si l’on a:
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), salut = "Bonjour"
alors il est parfois indispensable de passer par l’étape texte. write(*,’(a7)’) salut
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
acos arccosinus va lire des valeurs de x dans le fichier tant que la dernière
tan tangente valeur de x reste positive, et à la première valeur négative
atan arctangente trouvée, l’on passera à l’instruction close.
int troncature d’un réel en entier –Exercice : trouver pourquoi l’on a mis le write avant
nint arrondi d’un réel (nearest integer ) le read.
real partie réelle d’un nombre complexe L’avantage de ce type de boucle est que l’on peut faire
aimag partie imaginaire d’un nombre complexe des choses assez sophistiquées ; c’est séduisant, souvent ef-
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 ....
Par exemple : x = 1.0
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-
dians, donc si l’on veut travailler en degrés, il faut faire la 2.7.2 Boucles infinies : exit et cycle.
conversion :
On peut aussi faire des boucles « infinies » dont on ne
real :: pi, angle sort que grâce à exit :
pi = acos(-1.0)
write(*, ’("Donnez un angle en degres : ",$)’) do
read(*,*) angle write(*,’("Entrer un nombre positif : ",$)’)
write(*,*) ’le sinus de ’, angle,’ degres’ read(*,*) x
write(*,*) ’est ’, sin(pi*angle/180.) if ( x >= 0. ) exit
write(*,*) "Apprenez a lire !"
La différence entre int et nint est que si x vaut, par enddo
exemple 1,6, alors int(x) donne 1 alors que nint(x) y = sqrt(x)
donne 2.
On peut utiliser une fonction comme argument d’une Tant que l’on entrera des nombres négatifs, on aura droit à
autre, ainsi, par exemple, le module d’un nombre com- l’aimable invitation d’apprendre à lire, mais dès le premier
plexe z s’écrit
√ : sqrt(z*conjg(z)), la transcription de nombre positif, le programme en calculera la racine carrée.
l’expression zz ∗ . L’instruction cycle permet de répéter une boucle par-
La commande info g77 permet d’accéder, après tiellement :
quelques manipulations, à la liste des fonctions in-
trinsèques connues par g77 (il y en a beaucoup) ainsi qu’à do
leur mode d’emploi. Ces renseignements sont donnés en write(*,’("Entrer un nombre positif : ",$)’)
anglais, mais il n’est pas mauvais de se frotter de temps read(*,*) x
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
le compilateur utilisé ne reconnait pas une fonction sup- enddo
posée intrinsèque22 , il faut alors consulter une documenta-
tion spécifique (Fortran95/2003 explained par exemple). type réel, et realpart(z), partie réelle d’un complexe, alors que la
norme fortran95 prévoit que real prenne justement la partie réelle
22 Par exemple, g77 fait la distinction entre real(z), conversion en si son argument est complexe si bien que realpart n’existe pas.
26 Licence de physique L3 : Physique Fondamentale & 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 on peut écrire :
de tenter de l’ouvrir en lecture,
write(1,*) ( x(i), i = 1, n )
! declaration d’une chaine de 40 caracteres La différence est que dans le deuxième cas tous les éléments
! qui devra contenir le nom du fichier du tableau24 sont écrits sur la même ligne, sauf si on le
character (len=40) :: n_fic ! nom de fichier précise par format. Plus concis encore, si x est un tableau :
logical :: ok ! variable logique
write(1,*) x
do écrit tout le tableau.
write(*,’(‘‘Nom du fichier de donnees : ‘‘,$)’) On peut faire la même chose avec read.
read(*,*) n_fic ! lire au clavier le nom du fichier
! inquire est une commande FORTRAN permettant de
! verifier l’existence du fichier 2.8 Tableaux.
inquire(file=n_fic,exist=ok) ! existe: ok = .TRUE.
if ( ok ) exit ! et on n’insiste pas Les tableaux de nombres sont l’équivalent informatique
! sinon, il faut recommencer des vecteurs et des matrices : on peut ainsi désigner plu-
write(*,’(‘‘Fichier non trouve’’)’)
sieurs nombres par une seule variable ; le vecteur V de
enddo
open(10,file=n_fic) ! ouverture du fichier
dimension n désigne l’ensemble de ses n éléments vi , i ∈
... [1, n], la matrice A de dimension (n, m) désigne tous les
n × m éléments aij , le tenseur T de rang 3 désigne tous les
Les boucles infinies, assorties de exit et cycle, tendent éléments tijk , et ainsi de suite. Comme dans ces exemples,
à remplacer le do while, souvent considéré comme ob- un ou plusieurs indices entiers servent à indiquer l’élément
solète. Le until du pascal n’existe pas en fortran : voulu du tableau. Avec les tableaux, on acquiert la capa-
de fait, exit et cycle sont beaucoup plus riches, puis- cité à traiter, comme s’il s’agissait d’une seule entité, un
qu’ils peuvent être placés n’importe où dans la boucle, et grand nombre de données, pour ainsi dire « d’un coup » !
non seulement au début comme while ou à la fin comme
until23. 2.8.1 Déclaration
Si les boucles ont un nom, exit et cycle en tiennent
compte : La déclaration d’un tableau est faite en indiquant les
valeurs extrêmes des indices de chacune des dimensions
l1 : do du tableau, par exemple :
...
real, dimension(1:100) :: x
l2 : do
... déclare un tableau à un seul indice qui va de 1 à 100, c’est-
if ( age_du_capitaine < 0 ) exit l1 à-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
if ( ok ) cycle l2 élément est désigné par x(i) ; i est bien entendu un entier.
... Par exemple :
enddo l2 real, dimension(0:100) :: x
... real :: pi = acos(-1.0)
enddo l1 integer :: i
Le exit l1 fait sortir de la boucle l1, la plus externe, alors
do i = 0, 100
que l’instruction se trouve dans la boucle la plus interne : x(i) = cos(i*pi/100.)
ça permet de sauter par dessus un niveau d’imbrication. enddo
23 L’intérêt de ces structures est réel, toutefois pour relativiser, no-
remplit un tableau de 101 éléments avec les valeurs prises
tons qu’en fortranIV, on pouvait très bien fabriquer des logiques si-
par cos θ avec θ ∈ [0, π] par pas de π/100.
milaires à ce que permettent exit et cycle, l’esprit était simplement
moins orienté « programmation par bloc » et il fallait s’astreindre à On peut faire des déclarations du genre :
un minimum de discipline, par exemple : real, dimension(-100:100) :: x
do 100 i = 1, 1000000
... ce qui donne dans ce cas un tableau à 201 éléments dont
c ici l’equivalent d’un ‘‘cycle’’ l’indice varie de -100 à 100, et alors, on peut accéder à des
if ( x .gt. y ) go to 100
... éléments comme par exemple x(-20).
c ici l’equivalent d’un ‘‘exit’’ La déclaration real, dimension(100) :: x est
if ( z .le. 0. ) go to 200 équivalente à real, dimension(1:100) :: x25 .
... Pour les tableaux à plusieurs dimensions, il faut spécifier
100 continue
200 ...
les valeurs extrêmes de chacun des indices :
Il était prudent d’éviter de placer l’étiquette 200 à l’autre bout du 24 voir les tableaux dans la section suivante.
programme, du moins si l’on avait l’ambition d’écrire un code « main- 25 à
la différence du langage C pour lequel les tableaux commencent
tenable ». . . avec l’élément 0.
Physique numérique, Philippe Depondt 27

integer, dimension(1:25,-2:2) :: a integer :: i

real, dimension(-2:2) :: x=(/ (2*i, i=-2,2) /)
déclare un tableau à deux dimensions d’entiers de 25 × 5.
Le premier indice va de 1 à 25, le deuxième de -2 à 2.
Un élément est donc désigné, par exemple, par a(i,j) ou 2.8.2 Manipulation globale de tableaux
a(12,-1).
L’exemple suivant : 2.8.2.1 n d’un coup ! (mieux que le petit tailleur)
integer :: i On peut faire des calculs en manipulant les éléments
complex, dimension(200) :: s de tableaux un à un dans des boucles comme dans les
complex :: im = (0.,1.)
exemples ci-dessus ; c’est d’ailleurs ce que l’on faisait jus-
real :: omega, t
qu’à l’apparition de fortran9026 . La manipulation glo-
omega = 2*acos(-1.0)
do i = 1, 200 bale de tableaux est sans doute l’apport le plus important
t = (i-1)*0.005 ; s(i) = exp(im*omega*t) de fortran90 par rapport aux langages qui l’ont précédé ;
enddo c’est aussi un ingrédient qui facilite beaucoup les calculs
numériques dès qu’ils deviennent un peu lourds.
déclare un tableau complexe de 200 éléments et le remplit. Admettons que les éléments du tableau c doivent être
Il peut être commode de remplacer une dimen-
la somme des éléments correspondants des tableaux a et
sion explicitement fixée à une certaine valeur, du type
dimension(100), par dimension(n) où n est un nombre b :
entier. Il faut alors déclarer n comme un paramètre, c’est-
à-dire un nombre dont on ne peut pas changer la valeur integer, parameter :: n = 1000
en cours d’exécution du programme. Ainsi : integer :: i
real, dimension(n) :: a, b, c
integer, parameter :: l = 20, m = 100, n = 30
!....
real, dimension(l,m) :: x
! il faudrait lire les elements de a et b
real, dimension(m,n) :: y
! dans un fichier par exemple.
real, dimension(l,n) :: z
do i = 1, n
integer :: i, j, k
c(i) = a(i) + b(i)
enddo
open(10,file=’fichier.x’) ! lecture x
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
enddo c = a + b ! ici on fait n additions.
close(10)
open(10,file=’fichier.y’) ! lecture y le compilateur se chargeant de vérifier que tous les ta-
do j = 1, n bleaux concernés ont bien la même dimension. . . On peut
do i = 1, m donner explicitement les bornes :
read(10,*) y(i,j)
enddo c(1:n) = a(1:n) + b(1:n)
enddo
close(10) ce qui a le même résultat que ci-dessus : ça n’a au-
do j = 1, n ! produit matriciel cun intérêt dans cet exemple, mais imaginons que l’on
do i = 1, l veuille additionner la première moitié du tableau a avec la
z(i,j) = 0. deuxième moitié du tableau b et inversement, la deuxième
do k = 1, m moitié de a avec la première de b :
z(i,j) = z(i,j) + x(i,k)*y(k,j)
enddo c(1:n/2) = a(1:n/2) + b(n/2+1:n)
enddo c(n/2+1:n) = a(n/2+1:n) + b(1:n/2)
enddo
ou bien que l’on ne s’intéresse qu’aux éléments impairs :
déclare 3 tableaux de 20 × 100, 100 × 30 et 20 × 30, lit les
valeurs des éléments de x et y dans des fichiers et fait le c = 0. ! initialisation de c
produit des deux matrices dans z (attention à la différence c(1:n:2) = a(1:n:2) + b(1:n:2)
entre le chiffre 1 et la lettre l).
Malgré son apparente complexité, l’avantage de cette le dernier indice étant le pas, comme pour une boucle do27 .
façon de déclarer les tableaux est que si l’on veut, dans une
26 Plus précisément, certains constructeurs d’ordinateurs à capa-
nouvelle version du programme, changer une dimension
cité vectorielle avaient commencé à produire dans les années 1980 des
d’un tableau, il suffit de changer la valeur du paramètre
compilateurs fortran8X spécifiques à leurs machines : fortran90
correspondant et toutes les boucles s’adaptent automati- est l’héritier de ces innovations.
quement. 27 Il faut toutefois faire un peu attention car la norme ne garan-

Finalement, il est possible d’initialiser un tableau dans tit pas que les opérations effectuées dans un traitement global de
la déclaration, comme un scalaire : tableau se fassent dans l’ordre des indices de sorte que si un calcul
dépend d’un résultat obtenu précédemment sur un élément d’indice
real, dimension(-2:2) :: x=(/-4,-2,0,2,4/) inférieur, il faut écrire explicitement une boucle. En revanche, cer-
tains ordinateurs sont optimisés pour ce genre de calcul et un trai-
ici, x(-2) = -4, x(-1) = -2, etc. Une boucle implicite tement global, quand il est possible, peut se traduire par un gain de
peut aussi être utilisée pour le même résultat : temps sensible.
28 Licence de physique L3 : Physique Fondamentale & 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 po-
positifs du tableau x, et l’on annule y pour les éléments sitifs 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

Tab. 2.8 – Quelques fonctions de manipulation globale de tableaux.

Noter que le résultat fourni par cette fonction est lui-même quelles on aimerait pouvoir modifier la taille d’un tableau
une matrice. en cours d’exécution : par exemple, si l’on a écrit un pro-
Un résumé (non exhaustif) de quelques fonctions que gramme qui calcule la moyenne des éléments d’un tableau
l’on est amené à utiliser assez souvent est donné dans la de nombres de longueur quelconque, il serait agréable de
table 2.828 . pouvoir entrer la taille du tableau, puis le dimensionner,
puis faire le calcul sans avoir à recompiler le programme
à chaque fois que le nombre de nombres dont on veut la
2.8.4 Allocation dynamique de mémoire moyenne a changé !
Une déclaration est, comme on l’a déjà vu, une L’allocation dynamique de mémoire permet de déclarer
un tableau sans en donner la taille, puis de lui donner
réservation d’espace dans la mémoire vive de l’ordinateur.
une taille en cours d’exécution, de le supprimer puis de lui
Ainsi, real :: x déclare une variable réelle x et, de ce donner une autre taille, etc. Par exemple :
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écision29 : ces ! declaration d’un tableau unidimensionnel
4 octets sont donc affectés à cette variable et ne peuvent ! sans taille fixe
pas être utilisés à autre chose. De même, lorsqu’on déclare real, dimension(:), allocatable :: x
un tableau, par exemple real, dimension(n) :: x, on integer :: n
réserve n fois 4 octets. On comprend donc que cette !...
réservation doive être faite avant l’exécution du pro- write(*,’(‘‘Entrer le nombre d’elements ‘‘,$)’)
gramme : si l’on veut changer la taille d’un tableau, cela read(*,*) n
! affectation d’une taille donnee au tableau
revient à modifier la taille de l’espace qu’il occupe en
allocate(x(n))
mémoire ; il faut arrêter l’exécution du programme, mo- !... ici on fait des calculs
30
difier le code source, recompiler et relancer l’exécution . deallocate(x) ! desaffectation
Il existe cependant des quantités de situations dans les- ! on recommence avec un tableau plus petit
28 NE
! qui commence en zero au lieu de un
PAS apprendre ce tableau par cœur !
29 pour la plupart des ordinateurs courants. L’usage de mots de 64 allocate(x(0:n/2-1))
bits commence toutefois à se répandre assez rapidement. !...
30 ou alors, en fortran77, en l’absence d’allocation dynamique deallocate(x)
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. On gère ainsi la mémoire occupée pour ainsi dire
30 Licence de physique L3 : Physique Fondamentale & PHYTEM,
« au vol », ou plutôt, dynamiquement dans le jargon real
consacré. . . s = 0.
2.9 Fonctions et sous-program-
mes.
Rien n’oblige à écrire tous les calculs que l’on veut faire
dans un même programme : c’est même assez déconseillé !
Pour des raisons, ne serait-ce que de lisibilité, on a très
souvent intérêt à découper un gros problème en plusieurs
petits pour lesquels les possibilités de se tromper sont plus
faibles31 . De plus, si le même type de calcul doit être
répété à plusieurs endroits du programme (par exemple
un calcul d’intégrale), ce n’est pas la peine de le repro-
grammer plusieurs fois. Si, enfin, on a déjà écrit (et testé)
un programme qui sait faire un certain type de calcul (par
exemple, calculer une intégrale numérique ou résoudre un
système linéaire d’équations), il est utile de pouvoir le
récupérer et l’insérer dans le programme que l’on est en
train de faire sans avoir à le reécrire. Il existe en outre, et
l’on verra dans ce cours un certain nombre d’exemples de
leur utilisation, des bibliothèques de sous-programmes et
de fonctions extrêmement riches, telles linpack, lapack,
nag, imsl. . ., dans lesquelles on peut puiser sans vergogne
et ainsi éviter de réinventer la roue.
Fonctions et sous-programmes sont donc des ingrédients
essentiels !
2.9.1 Les function.
2.9.1.1 Définir une function.
On peut écrire ses propres fonctions en plus des fonc-
tions intrinsèques. On les utilise de la même façon que
les fonctions intrinsèques mais évidemment, il faut aussi
les définir, alors que les fonctions intrinsèques sont bien
sûr prédéfinies. Pour cela, on place les instructions corres-
pondantes, par exemple dans le même fichier-source que
le programme lui-même, mais en dehors de celui-ci (avant
program ou après end. Par exemple, supposons que l’on
veuille calculer le barycentre, à une dimension, d’un en-
semble de nombres lus dans un fichier :
program calcul ! debut du programme principal
implicit none
integer, parameter :: n = 100
real, dimension (1:n) :: x
real :: bsom
open (1, file=’machin’)
read(1,*) x
close(1)
write(*,*) ’Le barycentre des elements de X est : ’
write(*,*) bsom(x,n) ! appel de bsom
end ! fin du programme principal
real function bsom(z,m) ! debut de la function bsom
implicit none
integer :: i, m
real, dimension(1:m) :: z
31 c’est ce que l’on appelle avec quelque pédanterie « l’analyse
descendante », c’est-à-dire que l’on divise un problème P a priori
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
tous les sous-sous-sous-. . .-problèmes sont tellement élémentaires
qu’il n’y a plus de problème !
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
:: s
do i = 1, m
s = s + i*z(i)
enddo
bsom = s/sum(z)
end ! fin de la function bsom
La première partie est ce qu’on appelle le « programme
principal », la seconde, la fonction32 . L’appel de la fonction
dans le programme principal est fait normalement, ici dans
une instruction
write(*,*) bsom(x,n)
mais cela pourrait être dans une expression comme
r = sqrt(2.0)*bsom(x,n) - k
l’usage d’une fonction est donc très similaire à celle des
fonctions intrinsèques du fortran, comme sin, exp, etc.
Dans la définition de la fonction, on doit écrire expli-
citement l’expression donnant la valeur de la fonction :
si l’on oublie l’instruction bsom = s/sum(z), il n’y aura
pas d’erreur détectée, le calcul sera fait normalement, mais
le résultat ne sera pas transmis au programme appelant.
La fonction doit se terminer par l’instruction end qui en
marque la fin, comme le programme principal.
2.9.1.2 Les arguments et les variables d’une
function.
Dans cet exemple, la fonction réelle bsom calcule le ba-
rycentre des éléments de z. Le tableau z est un argument
de la fonction ( function bsom(z,m) ). Dans l’appel de
bsom, le premier argument est le tableau x qui doit avoir
le même type et le même nombre d’éléments que z dans la
définition de la fonction : la correspondance entre les va-
riables du programme principal et celles de la fonction est
donnée par l’ordre dans lequel elles apparaissent dans l’ap-
pel et la définition de la fonction. En effet x est la première
variable qui apparaı̂t dans l’appel de bsom(x,n) dans le
programme principal et z est la première dans la définition
real function bsom(z,m). Ainsi, x dans le programme
principal et z dans la fonction désignent la même variable ;
de même pour n et m.
1er, 2e argument
write(*,*) bsom( x, n) appel, dans p. princ.
ll
← correspondance
real function bsom( z, m) définition
Attention ! Ce n’est pas parce qu’une variable a le même
nom dans une fonction qu’une autre dans le programme
principal qu’il s’agit de la même chose ; au contraire, ces
deux variables même si elles ont le même nom n’ont au-
cun rapport ! En revanche, une variable du programme
principal représente strictement la même chose qu’une
autre, même de nom différent, dans la fonction à condi-
tion d’avoir été transmise comme argument dans l’appel
et la définition de la fonction comme dans l’exemple ci-
dessus33 .
Ainsi, la variable x du programme principal est iden-
tique à la variable z de la fonction, mais la variable s de
32 ouplus précisèment la définition de la function.
33 Laseule chose qui soit transmise est l’adresse du premier é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 end

peut être déclaré dans le programme principal : il pourrait
très bien y avoir une autre variable s dans le programme Le sous-programme baryc utilise les données rx, ry, rz,
principal sans qu’il y ait la moindre interaction entre les et masse, ainsi que le nombre de masses impliquées, pour
deux. rendre les coordonnées du centre de masse et la masse
Lorsqu’on apprend à programmer, c’est une source d’er- totale.
reur classique et cela paraı̂t inutilement compliqué, mais à Noter la différence avec une fonction : on peut
l’usage c’est un grand avantage car ainsi la fonction bsom, insérer l’appel d’une fonction dans une expression,
une fois écrite et testée, est indépendante du cadre dans le- écrire : write(*,*) bsom(x,n)/pi ou bien : xtot =
quel elle est utilisée, on peut donc s’en servir dans un grand 3.*bsom(x,n) + w, mais un sous-programme doit être
nombre de circonstances sans se préoccuper du détail de la appelé par un call. Par ailleurs, une fonction doit être
façon dont elle est écrite. Par exemple, on peut très bien
déclarées car elle a un type : entier, réel, double précision,
avoir oublié qu’il y a des variables s et z dans 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 va-
gramme principal, s soit un tableau de m éléments et z un
riables 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 de
comme argument sont aussi valables dans le cas d’un sous-
variables globales, toutes les variables doivent être explici-
programme.
tement 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
totale (un quatrième nombre), on peut procéder comme un 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
ces grandeurs dans chaque programme et sous-programme,
32 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

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
entre le programme principal et B : on saute, pour ainsi
! definition de constantes trigonometriques
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
comme argument.
end
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 trans-
mais ce n’est pas obligatoire) et, le cas échéant, d’affecta- mettre comme argument, outre les bornes xmin et xmax
tions de valeurs. Dans un programme ou sous-programme de l’intégrale et la précision eps souhaitée, le nom de la
dans lequel on veut utiliser ces variables, il faut spécifier fonction à 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 sans si 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 diag-
en degrés : nostiquera que la variable sin n’est pas déclarée, et dira
quelque chose qui peut ressembler à : Error : Symbol
sin_theta = sin(deg_rad*theta)
’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 besoin
intrinsic :: sin
dans chaque sous-programme qui l’utilise, les dégats po-
34 ...
tentiels restent limités : on peut très bien imaginer des
xmin = 0. ; xmax = acos(-1.0)
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 programmes35.
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éclarations36.
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 mo-
dule 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 les fichiers correspondants à l’aide de directives include
peut très bien qu’il ait besoin d’autres grandeurs utilisées 35 Certains compilateurs plus anciens n’acceptent que l’ancienne

par le programme principal. Si l’on ne veut pas modifier A
34 De ce point de vue, on reste assez loin des variables globales du
C dont les auteurs du langage disent eux-mêmes que ce n’est pas
ce qu’ils ont fait de mieux ! (B. W. Kernighan, D. M. Ritchie, Le
langage C, Masson (1997), p. 33.)
syntaxe external mafct (sans les ::).
36 Cette affirmation est en fait un peu péremptoire. . ., on peut
imaginer des situations où cela peut être nécessaire, par exemple
si l’on a écrit soi-même un sous-programme dot product qui risque
d’entrer en conflit avec la fonction intrinsèque de même nom ; la
déclaration external résout alors le problème.
Physique numérique, Philippe Depondt 33

’nom de fichier.f90’, c’est d’ailleurs ce que l’on fait d’invoquer à la compilation par :
souvent. g95 mon big prog.f90 -llapack -o mon big prog
Toutefois, il arrive que ces sous-programmes aient eux- Cela suppose évidemment que l’on ait la documentation
même besoin d’autres sous-programmes pour fonction- qui va avec, mais c’est généralement facile à obtenir via
ner. Par exemple, les programmes de calcul de tran- Internet. C’est très souvent ainsi que l’on travaille dans
formée de Fourier vont tous utiliser le même algorithme, « 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 modifiant matrice, transformée de Fourier, valeurs propres, . . .) et
éventuellement un signe ; il faudrait alors inclure explici- l’on trouve le programme de bibliothèque convenable, on
tement les deux sous-programmes, ce qui suppose que l’on l’appelle et on compile l’ensemble avec l’invocaton de la
connaisse spécifiquement comment tout cela est organisé : bibliothèque idoine : un appréciable gain de temps !
autant dire que c’est rarement le cas quelques années après
l’écriture initiale. Une bonne solution est alors de consti-
tuer une bibliothèque (library en anglais37 ). 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 com-
et dans lequel le compilateur peut aller pêcher ce dont portent des commentaires. Pour cela, il suffit d’utiliser
il a besoin, par exemple un sous-programme de calcul de le symbole ! qui marque le début d’un commentaire qui
transformée de Fourier et tous les sous-programmes aux- ne sera donc pas interprété comme une instruction à
quels celui-ci fait appel : dans le programme principal, il exécuter :
suffira de faire un call du sous-programme voulu.
! ceci est un commentaire, mais la ligne
! qui suit est une instruction
2.9.6.2 Créer une bibliothèque personnelle. read(*,*) x
On a donc écrit un certain nombre de sous-programmes C’est très utile quand on veut pouvoir s’y retrouver dans
et de fonction (dûment testés, bien sûr. . .) placés dans des un programme écrit quelques temps avant, par exemple :
fichiers machin 01.f90, machin 02.f90, truc real.f90,
truc dbl prec.f90, etc. Si on compile tout cela par g95 !-----------------------------------------------
*.f90, le compilateur refusera de la faire parce qu’il n’y a ! Ceci est un programme ecrit le 06-11-98
! par Tycho Brahe
pas de programme principal : il faut donc inhiber l’éditeur
! Il comporte trois boucles imbriquees
de lien38 avec l’option -c et pendant qu’on y est, on peut !
demander une optimisation du code avec l’option -O3. ! Mise a jour (adaptation free form) le 18-12-01
Cela donne : ! par Johannes Kepler
g95 -c -O3 *.f90 !-----------------------------------------------
on obtiendra alors une série de fichiers machin 01.o, ....
machin 02.o, truc real.o, truc dbl prec.o, etc. Ces ! debut de la grande boucle
fichiers doivent alors être inclus dans un fichier d’archive : do i = 1, n
ar rv libmabib.a *.o ......
Le fichier libmabib.a contient la bibliothèque mabib. On ......
peut alors supprimer tous les fichiers intermédiaires : ! debut de la moyenne boucle
do j = 1, m
rm -f *.o
........
Pour utiliser cela, il suffit de compiler normalement ........
son programme principal, dans lequel il y a des call ! debut de la petite boucle
machin 01(arg1, arg2), avec la commande : do k = 1, l
g95 big prog.f90 -Lrepertoire de mabib -lmabib ......
-o big prog ......
où repertoire de mabib est le répertoire où se trouve ......
le fichier libmabib.a. Si l’on peut placer le fichier enddo
libmabib.a dans le répertoire /usr/local/lib39, ! fin de la petite boucle
l’option -L n’est plus nécessaire. ......
......
enddo
2.9.6.3 Utiliser une bibliothèque existante. ! fin de la moyenne boucle
.....
Il est toutefois assez rare que l’on ait à créer une
.....
bibliothèque de toutes pièces : l’essentiel des algorithmes enddo
courants a déjà été programmé, compilé, testé, etc., il ! fin de la grande boucle
est inutile -voire nocif- de les refaire ! Pour l’algèbre
linéaire, il y a par exemple lapack qu’en général, il suffit Si chaque série de points (.....) représente plusieurs cen-
37 attention aux faux amis : en anglais, library signifie bibliothèque
taines d’instructions, les commentaires qui en marquent le
(l’endroit où l’on emprunte des livres) alors que librairie (l’endroit
début et la fin ne sont pas de trop. . .
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 : Physique Fondamentale & 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 ca-
ractères, par exemple :
Les déclarations de variables sont souvent un bon en-
droit pour mettre des commentaires : i = len_trim(salut)
program capitaine donne le nombre de caractères remplis de la chaı̂ne (4 dans
implicit none le cas Ciao même si la chaı̂ne est déclarée avec 7 cha-
! ce programme calcule l’age du capitaine ractères).
integer, parameter :: n = 100 ! nbr de points de
! discretisation character (len=7) :: salut = ’Bonjour’
real :: age_captain ! age du capitaine character (len=3) :: c
real, dimension(n) :: work ! zone de travail c=salut(1:3)

donnera Bon dans c puisque l’on prend les caractères de

2.11 Une instruction sur plusieurs 1 à 3. Il est aussi possible d’ajouter des caractères à une
chaı̂ne en utilisant l’opération // :
lignes.
integer l
Il arrive qu’une instruction soit trop longue pour tenir character (len=40) :: nfichier1
sur une ligne : il faut donc la prolonger sur la ligne sui- character (len=20) :: nfichier2
vante. Pour cela, il suffit de placer le caractère & à la fin
de la ligne pour indiquer que la ligne suivante en est la write(*,’("Entrer un nom de fichier : ",$)’)
suite : read(*,*) nfichier1
write(*,*) ’L’’age du capitaine est ’, ag_cpt, &
’ mais on manque un peu de place ’, & l = len_trim(nfichier1) ! l = longueur reelle
’: d’’ailleurs, on est oblige’, & ! du nom de fichier
’ de s’’etaler sur plusieurs lignes’ nfichier2=nfichier1(1:l)//’.res’
! on prend la partie de la chaine nfichier1
Ici, l’instruction prend quatre lignes. Si l’on interrompt ! qui est remplie et on ajoute ’.res’ apres
une chaı̂ne de caractère, il faut mettre & à la fin de la ligne
et au début de la ligne suivante : write(*,*) "Fichier resultat : ", nfichier2
write(*,*) ’L’’age du capitaine est ’, ag_cpt, & open(1,file=nfichier1) ; open(2,file=nfichier2)
’ mais on manque un peu de place &
Ainsi, si l’on répond à la question « Entrer un nom de
&: d’’ailleurs, on est oblige &
&de s’’etaler sur plusieurs lignes’ fichier » par : machin, on obtiendra :
Fichier resultat : machin.res
comparer avec l’exemple précédent. . .
2.12.3 Conversion chaı̂ne ⇔ nombres
2.12 Les chaı̂nes de caractères. On peut donc fabriquer automatiquement des
noms de fichiers ; toutefois, il est utile de pouvoir
2.12.1 Déclaration insérer des nombres dans ces noms, par exemple
Une variable de type chaı̂ne de charactères doit être res calc dt0.001.dat pour signifier que ce calcul a été
déclarée avec le nombre de caractères qu’elle peut conte- fait avec dt=0.001. Il faut donc convertir ce nombre en
nir, par exemple : chaı̂ne de caractères. Il existe une fonction intrinsèque
char qui permet de partir du code ASCII d’un caractère
character (len=7):: salut pour écrire ce caractère : c’est assez lourd, car il faut
indique que salut peut faire 7 caractères. Par exemple : décomposer le nombre en dizaines, centaines, connaı̂tre
les codes ASCII. . . Il est beaucoup plus simple d’utiliser
salut=’Bonjour’ les instructions d’entrée-sortie qui font aussi ce genre de
conversion par le biais de ce qu’on appelle un « fichier
Mais rien n’empêche :
interne », qui consiste à remplacer l’unité d’écriture par
salut=’Ciao’ une chaı̂ne de caractères :
où seuls les quatre premiers caractères sont remplis. En integer :: i
revanche, character (len=21) :: nom_fich
salut=’Guten Tag’ ! initialisation de la cha^
ıne de caracteres
nom_fich = ’res_calc_dt_0.000.dat’
risque d’être un peu décevant, il serait judicieux de do i = 1, 8
déclarer salut avec 9 caractères au moins. . . ! completer les caracteres numeriques
On peut, dans un sous-programme ou une fonction, write(nom_fich(12:16),’(f5.3)’) 0.001*i
déclarer une chaı̂ne de caractères sans longueur définie, ...
à condition qu’elle soit transmise comme argument : enddo
subroutine char_process(str,a,b,c,d)
Evidemment, cela suppose un certain soin et il est pru-
character (len=*) :: str
dent de vérifier que le nom de fichier obtenu est bien ce
le sous-programme se débrouillera avec la chaı̂ne str que l’on attendait ! Ensuite, il est aisé de produire auto-
quelle qu’en soit la longueur. matiquement des noms de fichiers explicites.
Physique numérique, Philippe Depondt 35

Les fichiers internes fonctionnent aussi pour l’écriture, 2.13 Détection de fin de fichier.
par exemple, le programme metres ci-dessous lit les ar-
guments de la commande qui l’invoque, ainsi quand on Il arrive que l’on lise un fichier dont la longueur est
tape : inconnue : ainsi, on ne sait pas la longueur de la boucle de
lecture :
$ metres 6500 pieds
open(1,file=nfichier)
on obtient do i = 1, n ! mais quelle valeur donner a n ?
read(1,*) x
1981.200 metres
...
Le programme est aussi une illustration de select case : enddo

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

rij2 = (x(i)-x(j))**2 + (y(i)-y(j))**2 + & On peut faire la même chose avec des entiers :
(z(i)-z(j))**2 integer :: l
sigr6 = (sigma2/rij2)**3 code l sur 4 octets et permet d’utiliser des nombres entiers
epot = epot + sigr6*( sigr6 - 2.0 ) jusqu’à 109 , alors que
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
en fortran90 : est cité ci-dessus n’est vrai que pour les processeurs les
plus communément utilisés sur PC ; le programme suivant
do i = 1, n-1 permet de tester tout cela en cas de doute :
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 cer- enddo
tain, mais elles sont d’un intérêt moins immédiat pour le end
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 kind40 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 cas enfoui dans des dizaines de milliers de lignes de code ; il n’a
(ça dépend du processeur) un kind=4 codera un nombre pas forcément le temps ou le courage de relire tout le code
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
program yepee
sont (sur la plupart des ordinateurs) équivalents. De
même : interface
double precision :: x
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,
subroutine cp301_phln(a,h)
le réel est bien codé sur 4 octets, alors que sur un proces-
real, intent(in) :: a ! annee
seur à 64 bits (qui deviennent de plus en plus fréquents)
real, intent(out) :: h ! heures
il est codé sur 8 octets, ce qui en fait l’équivalent d’un end subroutine cp301_phln
double precision. . . La notion de kind a pour but de
clarifier les choses. end interface
40 Sorte ou espèce. Par exemple : the American bald eagle is a kind
of eagle found in Northern America. En américain « conversation- ! declarations du programme principal
nel », It’s kind of neat (prononcer : It’s kinda neat) : c’est super implicit none
chouette ; he’s kind of weird : il est assez bizarre. ...
Physique numérique, Philippe Depondt 37

Toutes les déclarations de tous les arguments de tous opérations sur les rationnels qui tiennent compte, en par-
les sous-programmes sont ainsi répétées au début du ticulier, de la réduction au même dénominateur :
programme principal (ou du programme appelant), avec
éventuellement des commentaires : le compilateur peut module rat
ainsi vérifer au passage la cohérence des appels de sous- ! definition du type rationnel dans un module pour
programmes et signaler d’éventuelles erreurs. ! eviter d’avoir a le refaire dans tous les
L’interface ne sert cependant pas uniquement à se rap- ! sous-programmes
peler la syntaxe d’appel d’un sous-programme, elle permet type rationnel
de résoudre un certain nombre de problèmes de déclaration integer :: n, d
de variables. Admettons que l’on cherche à faire une fonc- end type rationnel
! 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 prod_test program ratio ! programme principal

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)
! result permet de definir une variable qui contient ! il s’agit ici simplemement de faire le lien
! 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
real, dimension(3), intent(in) :: a, b use rat
real, dimension(3) :: c type(rationnel), intent(in) :: q1, q2
type(rationnel) :: q3
end
end interface end function ratmul
end interface operator (*)
! ---
real, dimension(3) :: x, y, z interface operator (+)
! meme chose pour l’addition
function ratadd(q1,q2) result(q3)
write(*,’("Entrer X ",$)’) ; read(*,*) x
write(*,’("Entrer Y ",$)’) ; read(*,*) y use rat
type(rationnel), intent(in) :: q1, q2
type(rationnel) :: q3
! appel de la fonction (ce sont des tableaux!)
z = cross_product(x,y) end function ratadd
write(*,*) "X x Y = ", z end interface operator (+)

! test pour verifier que le resultat est bien ! declaration de deux nombres rationnels p et q
! perpendiculaire aux deux vecteurs initiaux ! le numerateur de q s’ecrit q%n et
! son denominateur q%d
write(*,*) "Produit scalaire X.Z", dot_product(x,z)
write(*,*) "Produit scalaire Y.Z", dot_product(y,z) ! meme chose pour p
type (rationnel) :: q, p
end
write(*,’("Num, denom 1: ",$)’)
!----- definition de la fonction ----- read(*,*) q%n, q%d
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
c = cshift(a,1)*cshift(b,-1)-cshift(b,1)*cshift(a,-1) write(*,*) "somme ", q+p

end
end

-Exercice : étudier le fonctionnement des cshift dans function ratmul(q1,q2) result(q3)

! 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
2.14.3 Objets de type dérivé. implicit none
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)
38 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

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

Cela se programme sans difficulté à condition de spécifier les bases doivent être impérativement
que la function est récursive : apprises et maı̂trisées, car sans cela, on
s’expose à patauger sans grand profit
program factorielle dans un bourbier de détails informa-
implicit none tiques sans intérêt !
integer :: n, fact
write(*,’("Entrer un entier : ",$)’) ; read(*,*) n
write(*,*)"Factorielle", n," vaut ",fact(n)
end Ces remarques achèvent la partie langage de ce cours.
Dans la suite, les exemples seront donnés en fortran,
recursive function fact(n) result(f)
mais les algorithmes étudiés ne dépendent évidemment
implicit none
pas du langage de programmation choisi.
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 faci-
lite considérablement la tâche dans, par exemple, des
problèmes de logique tournant autour de la décidabilité
(Entscheidungsproblem 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 as-
sez 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,
40 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 3

Un prototype de TP

3.1 Introduction. 3.2.1 De la multiplication des insectes.

La physique numérique requiert sans doute quelques
connaissances dont le présent cours a pour but de four-
nir l’essentiel. Il s’agit toutefois d’une activité essentiel-
lement pratique : il faut écrire des programmes qui, non
seulement « marchent », mais aussi répondent aux ques-
tions posées de sorte que la physique du problème soit
traitée de façon satisfaisante ; il faut pour cela un mini-
mum d’expérience pour, bien sûr, maı̂triser le langage,
mais en outre avoir une familiarité suffisante avec l’en-
vironnement et les méthodes afin que ceux-ci deviennent
l’aide puissante qu’ils doivent être et non plus la gêne. . .
qu’ils constituent sans conteste au début ! C’est la raison
pour laquelle cet enseignement comporte une part impor-
tante de travaux pratiques.
Chacune de ces séances de TP est consacrée à un
problème de physique qui illustre l’usage que l’on peut
faire de telle ou telle méthode. Elle est précédée d’une
séance de travaux dirigés au cours de laquelle on présente
le problème, éventuellement on montre les limites du cal-
cul analytique et on décrit les méthodes numériques qui
seront utilisées pour le traiter. Si le problème présente des
difficultés particulières de programmation, celles-ci seront
également abordées.
Il est attendu des étudiants qu’ils arrivent en séance
de TP en ayant 1o pris connaissance du problème et
2o avec une bonne idée de comment le résoudre et qu’ils
en partent en rendant un compte-rendu qui compte pour
la note de contrôle continu.
La question est évidemment : « que doit-il y avoir dans
un compte-rendu de TP ? » Comme il s’agit d’un exercice
un peu particulier, on traite ci-dessous, à titre d’exemple,
la question de l’équation logistique « à la manière » d’un
TP. . .
Imaginons une population, par exemple, d’insectes,
comportant à la génération p, zp individus. Si chaque
individu donne lieu, en moyenne, à α insectes (par
exemple en pondant α œufs, pour mourir ensuite) à la
génération suivante, celle-ci comportera zp+1 = α zp in-
dividus. Évidemment, si α > 1, la population d’insectes
diverge exponentiellement, une perspective sans doute
quelque peu effrayante mais qui ne tient pas compte des
ressources disponibles, la nourriture en particulier : plus
les insectes sont nombreux, plus les ressources deviennent
rares pour chaque insecte qui aura donc plus de difficultés
à s’assurer une descendance. Le coefficient α doit alors
décroı̂tre lorsque le nombre d’insecte augmente ; on peut
alors prendre l’expression linéairement décroissante (c’est
le plus simple) suivante :
zp
α = r(1 − )
ζ
où ζ est le nombre d’insectes qui épuise toutes les res-
sources au point de ne pas pouvoir donner lieu à une
génération suivante. . . Cela donne :
zp
zp+1 = r zp (1 − )
ζ
On peut reécrire cette équation en prenant comme va-
riable
zp
xp =
ζ
de sorte que 0 < xp < 1, et :
xp+1 = r xp (1 − xp )
ce qui constitue l’équation logistique. Il s’agit donc de
déterminer comment se comportera la population d’in-
sectes en fonction du paramètre r.

3.2 L’équation logistique. 3.2.2 Étude préalable.

Il s’agit d’un grand classique de la physique du chaos1 , 3.2.2.1 Les points fixes.
c’est un problème qui ne nécessite pas de connaissances Existe-t-il des solutions stationnaires telles que xp+1 =
particulières en méthodes numériques et qui présente un x ? Si oui, elles doivent obeir à :
p
certain aspect ludique2 ce qui en fait un bon exemple d’une
façon de procéder. x = r x(1 − x)
1 Voir par exemple : Edward Ott, Chaos in dynamical systems, soit :
Cambridge University Press (1993), p. 31. 1
2 On pourra certes objecter que le caractère « ludique » de cette x=0 ou x=1−
r
activité dépend un peu des goûts. . . mais on postulera ici que le
public de physiciens auquel ce cours s’adresse sera sensible à ses On admettra que la solution nulle n’a guère d’intérêt
charmes. puisque dans ce cas il n’y a pas d’insectes. La solution

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

non-nulle, elle, n’existe que si r > 1 car on ne considère r = 4 n’a pas de comportement aisément caractérisable à
que les valeurs de x positives, s’agissant d’un nombre d’in- première vue.
sectes. Imaginons que l’on se trouve en xp à une distance δ,
Par ailleurs, comme xp+1 doit, comme xp , par définition, 1
petite, d’un point fixe 1 − tel que :
être inférieur à un, le maximum de la fonction f (xp ) = r
r xp (1 − xp ) doit être également inférieur à un. Il est situé 1
1 r xp = 1 − +δ
en xp = et vaut , autrement dit, r ≤ 4. Ainsi, on se r
2 4
restreindra à l’intervalle 1 < r ≤ 4 et les points fixes vont alors, en appliquant à xp l’équation logistique :
3
de 0 pour r = 1 à pour r = 4 (figure 3.1).   
4 1 1
xp+1 = r (1 − ) + δ 1 − (1 − ) − δ
0.8 r r
0.7 1
= (1 − ) + δ (2 − r(1 + δ))
0.6
r
0.5 Le point xp+1 est-il plus proche du point fixe que xp ?
Point fixe

0.4
L’écart s’écrit :
0.3 1
xp+1 − (1 − ) = δ (2 − r(1 + δ))
0.2 r
≃ δ(2 − r)
0.1

0
1 1.5 2 2.5 3 3.5 4
puisqu’a priori δ est petit devant 1. Alors :
r – si r = 2, on obtient un écart nul, le système a
convergé,
Fig. 3.1 – Point fixe de l’équation logistique. – si r = 3, on obtient −δ, l’écart n’a pas diminué mais
change de signe
– si r = 4, on obtient −2δ, l’écart a augmenté en valeur
3.2.2.2 Y a-t-il convergence ? absolue et l’on peut donc s’attendre à des ennuis !
Plus généralement, si 1 < r < 3, l’écart diminue en va-
L’existence de points fixes ne signifie pas automati- leur absolue près du point fixe, et donc on s’attend à une
quement que le système doive converger vers l’un d’eux. convergence sans problème, mais si r > 3, l’écart tend à
Un façon de s’en convaincre est de faire quelques essais augmenter.
comme sur la figure 3.2 sur laquelle on a tracé les fonc- Voici donc un premier tour d’horizon sur ce problème :
tions f (x) = r x(1 − x) pour plusieurs valeurs de r et cela peut constituer la matière du TD qui précède le
g(x) = x : les points fixes sont donnés par l’intersection TP. S’il doit y avoir des subtilités de programmation à
des deux fonctions. connaı̂tre ou des algorithmes particuliers à appliquer (ce
1
r=1
qui n’est pas vraiment le cas ici), ils seront également
r=2
r=3
traités en TD.
0.8
r=4
x
Rien de ce qui précède ne doit obligatoirement figurer
dans votre compte-rendu, sinon pour vos propres ar-
0.6 chives : l’idée est qu’une séance de TP de 4 heures est
bien courte pour perdre du temps à recopier des notes
x(p+1)

0.4 prises en travaux dirigés, mieux vaut faire cela chez soi !

0.2
3.2.3 Étude numérique.
0
0 0.2 0.4 0.6 0.8 1 En revanche, le programme utilisé pour résoudre le
x(p)
problème doit impérativement être fourni, de préférence
avec des commentaires, éventuellement manuscrits, qui
Fig. 3.2 – Étude graphique de l’équation logistique. Voir permettent de savoir ce que ce programme est censé faire
le texte. et comment il le fait.

Prenons, par exemple, le cas r = 2 et partons de x0 = program logistic

0, 2. Alors, x1 = 2 × 0, 2(1 − 0, 2) = 0, 32 est donné sur la implicit none
figure par l’intersection de la ligne verticale bleue avec la ! equation logistique
parabole correspondant à r = 2. Ce x1 doit être reporté en ! evolution de la population en fonction des
! generations
abscisse pour servir de nouveau point de départ : il suffit
real :: r, x, x0 = 0.01 ! condition initiale
de tirer une ligne horizontale jusqu’à l’intersection avec
integer :: p, n=1000 ! nombre de generations
la droite g(x) = x, puis de nouveau une verticale pour !
obtenir x2 , etc. La figure paraı̂t montrer une convergence write(*,’(" R : ",$)’) ; read(*,*) r ! lecture de r
vers x = 0, 5, ce qui est bien ce que l’on attendait pour open(1, file=’logistic.res’) ! fichier de resultats
r = 2. Pour r = 3, il semble que le système ne converge do p = 1, n ! calcul et ecriture de x(p)
pas, mais suive un cycle autour du point fixe, et finalement x = r*x0*(1.-x0)
Physique numérique, Philippe Depondt 43

write(1,*) p, x 0.5
r=2

x0 = x
enddo 0.4
close(1)
end 0.3

x(p)
Si le résultat du calcul est juste un nombre, ce nombre 0.2
doit être fourni dans le compte-rendu et ce résultat dis-
cuté. Si le programme sert à une mise au point ou à 0.1

un essai, la comparaison avec ce qu’on attend doit être

donnée. Quand le résultat est une figure, les axes de 0
0 5 10 15 20 25 30 35 40 45 50
celle-ci doivent être identifiés (on trace quoi en fonction 0.676
p

de quoi ?) et les conditions du calcul précisées (ici la r=3

0.674
valeur de r et de la condition initiale). Des commen-
0.672
taires sur le résultat obtenu (quelle est sa signification
0.67
physique ?) sont non seulement bienvenus mais attendus
car le but n’est pas simplement d’écrire un programme 0.668

x(p)
mais de faire de la physique à l’aide de ce programme. . . 0.666

0.664

La figure 3.3 montre l’évolution de la population d’in- 0.662

sectes pour quatre valeurs de r. 0.66

– pour r = 2 le système converge rapidement vers le 0.658
950 955 960 965 970 975 980 985 990 995 1000
point fixe x = 0, 5 comme prévu (on a supprimé la fin p
du graphe pour p > 50 car il ne s’y passe rien). 0.9
r=3.5
0.85
– pour r = 3 le système oscille périodiquement (on n’a
0.8
gardé que la fin du graphe (p > 950) correspondant 0.75
à ce qui s’apparente à un régime stationnaire) autour 0.7
1
du point fixe 1 − ≃ 0, 667 : cela paraı̂t compatible 0.65
x(p)

3 0.6
avec l’intuition que l’on en avait. 0.55
– pour r = 3, 5, le système est encore périodique, mais 0.5
deux « périodes » successives sont différentes, autre- 0.45
ment dit, la période est deux fois plus longue. 0.4

– pour r = 4 le système semble se comporter de 0.35

950 955 960 965 970 975 980 985 990 995 1000
façon irrégulière : on est dans une situation de chaos p
1
déterministe. 0.9
r=4

0.8
Lorqu’on modifie un programme, il faut expliquer ce que
0.7
l’on est en train de faire, et évidemment fournir le pro-
0.6
gramme modifié agrémenté des commentaires adéquats.
x(p)

0.5

0.4
On aimerait étudier le comportement de la population
0.3
d’insectes de façon plus systématique : pour cela, il suffit
0.2
d’ajouter au programme une boucle sur r et de tracer xp
0.1
non plus en fonction de p mais en fonction de r. On prend
0
soin de ne garder que la fin du calcul pour chaque valeur 950 955 960 965 970 975 980 985 990 995 1000
p
de r afin d’éliminer un éventuel transitoire.
Fig. 3.3 – Évolution de la population d’insectes pour r =
program logistic
2, 3, 3, 5 et 4. Condition initiale x0 = 0, 01.
implicit none
! equation logistique
! diagramme de bifurcations
real :: r, x, x0
integer :: i, p, n=2000, nsav
open(1,file=’logistic2.out’) do p = 1, n
! x = r*x0*(1.-x0)
do i = 200, 400 ! boucle sur r ! le calcul est identique au precedent, mais on
r = 0.01*i ! ecrit maintenant x en fonction de r
x0 = 0.01 ! reinitialisation de x0 if ( p > n-nsav ) write(1,*) r, x
! pour chaque nouvel r x0 = x
if ( r < 3 ) then ! quand le systeme enddo
nsav = 10 ! converge, on ne garde que !
else ! quelques pas mais quand ca enddo
nsav = 1000 ! devient irregulier, on doit !
endif ! en garder davantage close(1)
! end
44 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

1
Eq. logistique
0.9 Pt fixe

0.8

0.7

0.6
x(p)

0.5

0.4

0.3

0.2

0.1

0
2 2.5 3 3.5 4
r
Fig. 3.4 – Diagramme de bifurcations pour l’équation logistique. En bleu est représentée la courbe des points fixes
théoriques.

On obtient ce qu’on appelle un diagramme de bifurca- On constatera les poids respectifs de l’informatique et de
tions (figure 3.4). la physique (il est vrai qu’en l’occurence, il s’agit plutôt
d’éco-zoologie, mais peu importe) dans ce qui précède :
En premier lieu, on constate que pour r < 3 le résultat la balance penche fortement du côté de cette dernière et
coincide parfaitement avec la courbe des points fixes c’est ainsi qu’il doit en être. Parfois au cours d’un TP, on
théoriques, ce qui est rassurant quant au bon fonction- pourra rencontrer des aspects techniques plus délicats
nement du programme (mais ne démontre en aucun cas que dans cet exemple et il faudra s’assurer avec autant
qu’il est dépourvu d’erreur !). de soin que possible que la méthode utilisée est digne de
confiance, mais le principe de base reste : « n’oublions
jamais que nous sommes des physiciens ! »
On observe ensuite qu’à partir de r = 3 la courbe se di-
vise en deux : cela signifie que pour chaque valeur de r, xp
Toutefois, après cette belle déclaration de principes, il
oscille entre deux valeurs comme sur la deuxième courbe
faut quand même s’occuper des méthodes elle-mêmes. . .
de la figure 3.3. Puis, un peu avant r = 3, 5, on a un nou-
veau dédoublement et xp prend quatre valeurs distinctes.
On observe encore un autre dédoublement pour huit va-
leurs avant de tomber dans un continuum qui signifie que
xp prend toutes les valeurs entre 0 et 1. Au-delà, on ob-
serve quelques « fenêtres d’ordre » dans les zones moins
sombres qui correspondent au fait que xp n’explore pas
toutes les valeurs du domaine.

Une étude plus poussée permettrait peut-être de vérifier

si la séquence des dédoublements suit une suite de Feigen-
baum ou d’étudier l’invariance par changement d’échelle
en calculant les dimensions fractales des domaines explorés
par xp en fonction de r.

On peut aussi préférer, à une étude du chaos d’un point

de vue mathématique, se poser la question de la validité du
modèle en introduisant des ingrédients supplémentaires,
par exemple, le fait que les ressources ne se trouvent pas
forcément à proximité des insectes et que donc leurs façons
de rechercher ces ressources (leurs « stratégies ») n’est pas
sans effet. D’éventuels prédateurs peuvent également jouer
un rôle.
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 θ + 3
d’autres seraient sans doute mieux à même de réaliser, 4πε 0 mg [(ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 ] 2
chaque méthode est illustrée par un exemple de phy-
sique puisé dans la mesure du possible dans le bagage =0 (4.1)
d’un étudiant de licence de physique, quitte à anticiper ce qui n’est pas évident à résoudre analytiquement1 .
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)
Fig. 4.1 – Le pendule chargé
a x b
L’énergie potentielle de gravitation du pendule peut Fig. 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 : Physique Fondamentale & 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] Fig. 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 sui- est sûre, sans surprise. Elle nécessite une connaissance
vante : 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
Fig. 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
real, parameter :: eps = 1.e-5 ! precision requise
f (xn )
xn+1 = xn − real :: newton
f ′ (xn ) external :: trajet
real :: x = 0. ! condition initiale
jusqu’à ce que le critère de convergence que l’on aura choisi
! ce programme ne comporte qu’une instruction
soit vérifié.
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 dioptre end
en utilisant la loi de Descartes  (figure
 4.5) : le rayon part
−a subroutine trajet(x, f, df ) ! calcul de la fonction
d’un point de coordonnées dans un milieu d’in-
y   use params ! et de sa derivee
a implicit none
dice n1 pour arriver en un point de coordonnées real, intent(in) :: x
−y
dans un milieu d’indice real, intent(out) :: f, df
 n2 , en passant par le dioptre au
real :: r1, r2
x
point de coordonnées . L’inconnue du problème est r1 = (a + x)/y ; r2 = (a - x)/y
0
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
y real function newton(x,f,eps) ! methode de Newton
implicit none
i1 integer :: i, imax = 100 ! nombre max d’iterations
real :: x, eps, xp, y, d

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

newton = xp
end

Fig. 4.5 – Loi de Descartes : notations pour utiliser la Cela donne : 0.36264408 -0.000014537249. On laissera
méthode de Newton le soin au lecteur de vérifier que c’est correct. . .
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 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

0.8
de pouvoir se généraliser aisément à plusieurs dimensions 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
point de départ2 , 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, tanh(x)
Fig. 4.6 – Les courbes de tanh(x) − 0.3x et de −
enfin, l’algorithme ne converge pas, même si une solution x
existe, en cas de changement de courbure malencontreux 0.3 montrant que la deuxième permet d’éliminer la racine
par exemple : un choix plus judicieux du point de départ triviale pour x = 0 alors que les deux autres racines ne
peut régler le problème. 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 an-
−a=0
x glais. Un octet constitue généralement un emplacement
qui élimine la solution triviale si a 6= 1, puisque correspondant à 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
4.2 Représentation des nombres on aimerait pouvoir utiliser, d’une part, des nombres plus
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 à
Dans ce qui précède, on a introduit, sans trop insister, deux, soit, toujours sur un octet : 00000001 = 1 et
la notion de précision du résultat. Cette précision n’est 11111110 = −1 au lieu de 254. Ainsi de 00000000 = 0
jamais absolue pour plusieurs raisons. à 01111111 = 127 on code des nombres positifs et pour
2 Shot off to outer space comme disent joliment nos collègues les nombres négatifs, 11111110 = −1, 11111101 = −2,
américains. . . ., jusqu’à 11111111 = −128. On peut vérifier qu’avec
Physique numérique, Philippe Depondt
cette convention l’addition suivante est correcte :
−4 11111011
+2 00000010
= −2 11111101
Afin d’avoir une plage de nombres accessibles plus
grande, les octets sont généralement regroupés par en-
sembles de quatre (appelés mots), soit 32 bits3 . Ainsi les
nombres entiers peuvent aller de −231 = −2 147 483 648 à
231 − 1 = 2 147 483 647, ce qui est largement suffisant pour
la plupart des applications, mais, évidemment, pas infini.
4.2.2 Les nombres réels.
Parler de nombres réels est un abus de langage puisque
l’on
√ ne peut traiter que les nombres rationnels. Ainsi,
2 sera approximé par, par exemple, 1,414213562. De
plus, on est obligé de se restreindre encore davantage aux
nombres rationnels à un nombre fini de chiffres : 1/3 de-
vient par exemple 0,3333333333. Un tel nombre rationnel,
si l’on supprime la virgule, est un nombre entier : il suf-
fit de préciser l’emplacement de la virgule, par une puis-
sance de 10, par exemple. Ainsi, 1,414213562 peut s’écrire
1414213562 10−9 . Une autre façon de s’y prendre serait :
0, 1414213562 101 . L’avantage de la deuxième est que l’ex-
pression des chiffres composant le nombre est comprise
entre 0 et 1, chaque chiffre correspondant non plus à une
puissance positive de 10 mais à une puissance négative.
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
peut-être tout aussi bien fait en binaire.
Ainsi un nombre réel s’écrit, en général sur quatre oc-
tets, soit 32 bits : 1 bit pour le signe, 8 bits pour l’exposant
qui donne une puissance de 2 puisqu’il s’agit de nombres
binaires, 23 bits pour la mantisse ; or le premier bit de la
mantisse est toujours 1 (sinon, il faudrait diminuer l’expo-
sant de 1), donc on l’omet ce qui permet de gagner un bit
significatif.
Dans ces conditions, les nombres réels peuvent s’étendre
de ±1, 175494 10−38 à ±3, 402823 1038 avec sept chiffres
significatifs. Si cela ne suffit pas, on peut utiliser la double
precision sur 8 octets qui donne 15 chiffres significatifs
de 2, 225074 10−308 à 1, 797693 10308 . Certaines machines
acceptent aussi les real*16 sur 16 octets. . .
4.2.3 Conséquence.
La conséquence de tout ceci est que les calculs se font
avec une certaine précision intrinsèque (qui est a priori
bonne : sept chiffres significatifs. . .). Imaginons toutefois faisait à la récursivité. Dans le cas de la factorielle, il suffit
le programme, certes stupide, suivant :
implicit none
integer :: i
real :: s
s = 1000.
do i = 1, 1000000000
s = s + 1e-9
enddo
write(*,*) s-1000.
end
Le résultat obtenu est 0. et non 1. ! La raison en est
que l’on ajoute 1000 + 1 10−9 ce qui, compte tenu de la
3 Certaines machines, comme les Cray ou certaines stations de
travail, utilisent des mots de huit octets, soit 64 bits.
49
précision machine, vaut 1000 : peu importe que l’on répète
l’opération un milliard de fois ! Finalement 1000 − 1000 =
0. . . En déclarant s en double precision on obtient :
0.9999894254
Il faut donc être assez méfiant lorsqu’on traite des
nombres qui prennent des valeurs très différentes. Il est
aussi prudent de se rappeler que lorsqu’on fait des calculs
itératifs, ce qui est très souvent le cas, les erreurs peuvent
s’ajouter les unes aux autres pour ne plus être négligeables
du tout !
Un deuxième cas de figure classique est le suivant :
if( a == 0. ) then
où a est un réel. Le résultat d’une telle instruction est
aléatoire à cause des erreurs d’arrondi ! En effet, si a est le
résultat de calculs longs et compliqués, va-t-il tomber pile
sur zéro ou sur 0.1234567E-35 ? Il vaut bien mieux définir
a priori la précision souhaitée et donner l’instruction :
if( abs(a) < epsilon ) then
si la valeur absolue de a est plus petite que ε, alors. . .
Ainsi, une règle d’or à ne jamais oublier lors-
qu’on fait des calculs numériques est de vérifier
sur des cas dont on connait la solution que les
programmes que l’on a écrits donnent bien la so-
lution attendue. . . tout en sachant qu’il ne s’agit
en aucun cas d’une garantie !
4.3 Suites et séries.
4.3.1 Généralités et premières difficultés.
Une suite est définie par une relation de récurrence du
type :
un = f (un−1 , un−2 , . . . , un−p )
où un est une fonction de l’élément de la suite précédent
ou de plusieurs éléments précédents. Par exemple, la fac-
torielle :
n! = n(n − 1)! avec 1! = 1
Une série s’écrit comme :
n
X
sn = ui ou bien sn = sn−1 + un
i=1
Il n’est pas utile de faire un tableau contenant tous les
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
d’écrire quelque chose qui ressemble à
f = 1
do i = 2, n ; f = f*i ; enddo
en faisant croı̂tre i dans une boucle. Pour une série, cela
deviendrait :
s = ... ! expression du premier terme
do i = 2, n
s = s + .... ! expression du terme general
enddo
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
peut être judicieux d’essayer le même programme sur deux machines
différentes avec deux compilateurs différents.
50 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

4.3.1.1 Précision. désastreuses6. Ce serait d’autant plus impardonnable qu’il

existe une solution très simple au problème :
Il faut être prudent lors du calcul d’une suite car la
remarque du paragraphe 4.2.3 s’applique tout à fait et Pn (x) = (. . . ((an x + an−1 )x + an−2 )x + . . .)x + a0
l’on a parfois des surprises. Par exemple, la série :
et cela se programme sans difficulté à l’aide d’une boucle
x 2n−1 décroissante :
sn (x) = sn−1 (x) + (−1)n−1 , avec s1 (x) = x
(2n − 1)! real function polyn(x,a,n) ! schema de Horner
integer :: i, n
est simplement le développement de la fonction sinus li- real, dimension(0:n) :: a
mité à l’ordre 2n − 1. Le programme suivant est l’applica- real :: x, pn
tion 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 analyti-
s = s + l*x**p/f quement 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
est décrit par trois coordonées en fonction d’une abscisse
À l’ordre n = 17, ce qui correspond en fait à un curviligne s : (x(s), y(s), z(s)) et sa charge par une densité
développement limité à l’ordre 33 en x, on obtient pour linéique σ(s). Le potentiel électrostatique en un point de
x = π2 , le résultat s=0.9964 au lieu de un, un résultat coordonnées (x0 , y0 , z0 ) s’écrit :
un peu décevant pour un ordre aussi élevé. Pire, si l’on
tente d’aller plus loin, n = 18, on obtient -INF. . . C’est V (x0 , y0 , z0 ) =
simplement que l’on est en train d’additionner des termes Z s1
1 σ(s) ds
de signes opposés et que la différence des valeurs absolues p
est petite, donc ils se compensent en grande partie deux à 4πε0 s0 (x(s) − x0 ) + (y(s) − y0 )2 + (z(s) − z0 )2
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 par-
fois dangereux. La deuxième est que, lorsqu’on peut le
faire, il est bon de classer les termes que l’on doit som-
mer par ordre croissant de telle façon à éviter autant que
possible les additions de termes d’ordre de grandeurs très
différents. Fig. 4.7 – Un fil chargé.

Si l’allure du fil ressemble à celui de la figure 4.7, une

4.3.1.2 Polynômes : le schéma de Horner. intégration numérique sur ordinateur peut être une solu-
tion de bon goût !
Le calcul d’un polynôme est un bon exemple de ce qui
a été dit ci-dessus. Soit : 4.3.2.1 Méthode des rectangles.
n
X C’est la plus simple : il s’agit de remplacer une intégrale
Pn (x) = aℓ xℓ par une somme finie (voir la figure 4.8) :
ℓ=0
Z b n−1
X b−a
Ne pas tenter de faire la somme ci-dessus directe- f (x) dx ∼ f (a + iδx )δx avec δx =
ment ! En effet les puissances successives de x produi- a i=0
n
ront sans aucun doute des termes dont les ordres gran- 6 Numerical Recipes (voir bibliographie, référence [3]), qui n’y va
deurs seront extrêmement variables, avec des conséquences pas avec le dos de la cuillère, va jusqu’à menacer : « Come the (com-
puter) revolution, all persons found guilty of such criminal behaviour
5 Voir par exemple dans les Numerical Recipes, référence [3] dans will be summarily executed » ! L’humour est sans doute douteux,
la bibliographie. mais le message est clair.
Physique numérique, Philippe Depondt 51

on remplace le calcul de la surface par une approximation soit en regroupant les termes identiques :
constituée d’une somme de surfaces de rectangles. !
Z b n−1
X
1 1
f (x) dx ∼ δx f (a) + f (a + iδx ) + f (b)
a 2 i=1
2

on retrouve une formule très similaire à celle de la méthode

des rectangles, mais elle est symétrisée et les termes
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

Fig. 4.8 – Les deux variantes de la méthode des rectangles.

Une autre approximation tout aussi légitime serait :

Z b n
X
f (x) dx ∼ f (a + iδx )δx
a i=1

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
à évaluer la valeur de la fonction à droite de l’intervalle au Fig. 4.10 – Schéma équivalent à la méthode des 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.

4.3.2.2 Méthode des trapèzes. La grosse différence entre une intégration numérique et
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 va-
leur 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
Fig. 4.9 – La méthode des trapèzes. par deux, on obtient alors :
   
(b − a) f (a) a+b f (b)
La surface du i-ième trapèze s’écrit : S1 = +f +
2 2 2 2
1 S0
si = (f (a + (i − 1)δx ) + f (a + iδx )) δx = + R1
2 2
et donc : avec, en posant h = b − a :
Z b Xn  
1 h a+b
f (x) dx ∼ (f (a + (i − 1)δx ) + f (a + iδx )) δx R1 = f
a i=1
2 2 2
52 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

ce qui évite d’avoir à recalculer les deux points extrêmes. sp = s/2 + r*hm
On redivise le pas par deux, puis de nouveau encore, ! ---> le test force au moins quatre iterations
etc. Un calcul simple donne alors le terme général de la if( abs(s-sp) < eps .and. n > 3 ) exit
récurrence : s = sp
enddo
Sn−1 trapeze = sp
Sn = + Rn
2 end
2n−1  
h X h
Rn = f a + (2i − 1) n 4.3.2.4 Un exemple : le principe de Fermat
2n i=1 2
Imaginons un rayon lumineux qui circule dans une fibre
On arrête le calcul lorsque l’écart entre deux résultats suc- optique cylindrique, parallèle à x, dont l’indice dépend de
cessifs est inférieur à la précision requise : la distance à l’axe :
 
|Sn − Sn−1 | < ε r2
n = n0 1 − 2
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 à gra-
de danger : soit par exemple la fonction suivante (figure
dient d’indice qui permet de piéger, pour ainsi dire, le
4.11),
rayon 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
1 rayon lumineux revient à chercher la fonction y(x). Une
incursion dans le cours d’optique fournit l’équation de pro-
0.8 pagation d’un rayon lumineux :
 
0.6
d~r
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 à
Fig. 4.11 – Si l’on ne prend pas de précautions, l’intégrale dx. On obtient :
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 d2 y n0 y
et donc inférieur à ε : le programme s’arrêtera. La même n 2 =− 2
dx ρ
mésaventure arrive si l’on cherche
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 :
−π
2π
y(x) = a sin x
on trouve le résultat correct (soit 0), mais complètement λ
par hasard ! Il vaut mieux restreindre le calcul de 0 à π.
pour obtenir :
Comme souvent dans ce genre d’activités, un minimum de
λ = 2πρ
circonspection s’impose.
Un sous-programme pourrait donner quelque chose qui On obtient alors une trajectoire sinusoı̈dale de période
ressemble à : 2πρ indépendante de l’amplitude des oscillations : c’est
intéressant pratiquement, car ainsi le rayon, même si, ini-
double precision function trapeze(f, a, b, eps)
tialement, il n’est pas parfaitement dans l’axe, se bornera
implicit none
double precision :: f, a, b, eps, s, h, r, sp, hm
à osciller autour de celui-ci au cours de sa propagation.
integer :: n, m, i Tout ceci reste cependant un peu formel et entaché d’ap-
proximations.
h = b-a ; m = 1 Un cours d’optique normalement constitué affirme
s = h*(f(a)+f(b))*0.5d0 généralement -voire même démontre- que l’équation 4.2
do n = 1, 20 ! 20 iterations max est une conséquence du principe de Fermat qui veut que
m = 2*m ! 2**n le chemin optique ne dépende pas d’un petit changement
hm = h/m ; r =0. de trajectoire, soit :
do i = 1, m/2 ! de 1 a 2**(n-1) Z l
r = r + f(a+(2*i-1)*hm)
enddo L = n ds est un extremum
0
Physique numérique, Philippe Depondt 53

L
Pour le vérifier, calculons dans le cas de la trajectoire 4.3.2.5 Intégrales indéfinies.
λ
sinusoı̈dale ci-dessus : Dans toutes les discussions ci-dessus, seules les
Z λ 2
 intégrales définies ont été abordées. On ne peut pas calcu-
L n0 y
= 1 − 2 ds ler par ces méthodes des intégrales du type :
λ λ 0 2ρ
or Z ∞
s  2 f (x)dx
dy
ds2 = dx2 + dy 2 ⇒ ds = dx 1 + −∞
dx
On a essentiellement deux solutions :
soit l’intégrale suivante à calculer :
1. la fonction f (x) doit tendre vers zéro lorsque x →
L
= ±∞, sinon le résultat est infini, alors on peut faire
λ l’approximation :
Z λ !s  2
2 2 2πx
n0 a sin λ 2π 2πx Z ∞ Z b
1− 1 + a2 cos2 dx
λ 0 2ρ2 λ λ f (x)dx ∼ f (x)dx
−∞ a
(4.3)
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
λ e− σ2 dx ∼ e− σ2 dx
Z !  2 ! −∞ −5σ
n0 λ a2 sin2 2πx
λ a2 2π 2 2πx
1− 1+ cos dx n’est pas une mauvaise approximation.
λ 0 2ρ2 2 λ λ
peut ensuiteR éliminer le terme en a4 et sachant que 2. une méthode plus élégante est de découper l’intégrale
ROn2π 2 2π 2 Z ∞ Z a Z b Z ∞
0
sin x dx = 0 cos x dx = π, on finit par avoir :
  f (x)dx = f (x)dx + f (x)dx + f (x)dx
L a2 a2 π 2 −∞ −∞ a b
∼ n0 1 − 2 + 2
λ 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-
tribution linéique de charges sur une pelote de ficelle
ce qu’on avait déjà trouvé auparavent : l’intérêt du se-
de forme compliquée mais dont les extrémités vont à
cond calcul étant de montrer que le chemin optique ne
l’infini. Le potentiel créé à l’origine pourrait s’écrire :
dépendant pas de a, une source de lumière cohérente
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’abs-
0
cisse curviligne s. Admettons qu’une approximation
serait que lorsque s > b alors σ ∼ sς et que
−0.01 p
−0.02 x (s) + y 2 (s) + z 2 (s) ∼ s. On obtient alors,
2

−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
La même approximation pour s < a donnerait en fin
−0.07
de compte :
−0.08
" Z b #
−0.09
1 ς σ(s) ς
−0.1 V = − + p ds +
0 0.2 0.4 0.6 0.8 1 4πε0 a a x2 (s) + y 2 (s) + z 2 (s) b
a

Fig. 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 tion.
qu’on n’aurait probablement pas deviné sinon.
7 prendre par exemple ρ = 1 et n = 1.5. On calculera en double
0
On a vu, pour le problème de l’intégration, l’impor-
precision. tance du pas d’intégration : c’est déjà une première forme
54 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

d’échantillonnage puisqu’une fonction définie sur un mor- 4.4.1 Interpolation linéaire.

ceau de l’axe réel se trouve réduite à un ensemble discret
C’est la plus simple : si x est compris entre xℓ et xℓ+1 ,
de points.
on écrit la fonction approchée pℓ (x),
De même, lorsqu’on demande à un logiciel comme
gnuplot (ou à une calculette graphique, d’ailleurs) de tra- f (xℓ+1 ) − f (xℓ )
cer le graphe d’une fonction, sin x par exemple, il cal- pℓ (x) = f (xℓ ) + (x − xℓ ) (4.4)
xℓ+1 − xℓ
cule les valeurs de la fonction en un certain nombre de
points, reliés ensuite par des lignes droites ; en général, ce qui revient à considérer la fonction comme localement
les « options par défaut » permettent d’éviter de préciser linéaire. L’erreur est évidemment d’autant plus grande que
comment on veut que ce choix de points soit fait, ce la courbure de la fonction est grande.
qui donne une fausse impression d’évidence au choix de
l’échantillonnage. 4.4.2 Approximation parabolique.
1
0.8
0.6
0.4
0.2
0
−0.2
−0.4
−0.6
−0.8
−1
−10 −5 0 5 10

Fig. 4.13 – Le graphe de la fonction sin(100x) tracé sans

précaution particulière.
Fig. 4.14 – Approximation linéaire et approximation pa-
Il arrive toutefois, comme on peut le constater sur la rabolique autour du point situé en x=0.5.
figure 4.13, que le résultat ne soit pas à la hauteur des
espérances ! Dans cet exemple, en effet, on a tenté de tra- Pour tenir compte de la courbure, on peut remplacer
2π
cer une fonction périodique de période 100 à l’aide d’un l’approximation linéaire par une parabole qui, cette fois
échantillonnage de 100 points sur un intervalle de longueur doit passer par trois points. Ainsi :
20, soit un pas d’échantillonnage de 0, 2 plus grand que la
période de la fonction. . . échec assuré, encore fallait-il le pℓ (x) = aℓ x2 + bℓ x + cℓ
prévoir8.
de façon que :
Ainsi, une fonction9 y = f (x) pour un ordinateur est
toujours représentée en fin de compte par un nombre pℓ (xℓ−1 ) = f (xℓ−1 )
fini de points, c’est-à-dire par un nombre fini de couples
(xi , yi ). Dans le cas du sinus, bien sûr, on peut toujours pℓ (xℓ ) = f (xℓ )
calculer des points supplémentaires si l’aspect de la courbe pℓ (xℓ+1 ) = f (xℓ+1 )
n’est pas convenable. Cependant, ce n’est pas toujours
possible, soit parce que le temps de calcul à investir se- On obtient aisément :
rait trop long, soit parce qu’il s’agit de données obtenues (x − xℓ )(x − xℓ+1 )
autrement, expérimentalement par exemple, et qu’il n’est pℓ (x) = f (xℓ−1 )
(xℓ−1 − xℓ )(xℓ−1 − xℓ+1 )
pas question de refaire l’expérience avec, mettons, cent fois
plus de points. . . or il peut arriver que l’on ait besoin de (x − xℓ+1 )(x − xℓ−1 )
+ f (xℓ )
connaı̂tre la valeur de la fonction entre deux points. (xℓ − xℓ+1 )(xℓ − xℓ−1 )
On peut, bien souvent, s’en sortir quand même à l’aide (x − xℓ−1 )(x − xℓ )
+ f (xℓ+1 )
d’approximations moyennant quelques hypothèses. (xℓ+1 − xℓ−1 )(xℓ+1 − xℓ )

ceci est valable dans l’intervalle [xℓ − h2 , xℓ + h2 ] où, bien

8 le
logiciel gnuplot permet de définir le nombre de points que l’on
veut sur un intervalle : par exemple set samples 1000 indique 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 cette façon serait dans ce cas décevant parce qu’on obtiendra
selon toute vraisemblance un écran tout noir. . . Il est vrai que vou-
loir tracer une courbe de période 2π/100 ≃ 0,0628 sur un intervalle
[−10, 10], c’est chercher la difficulté.
9 Au sens mathématique, bien sûr, il ne s’agit pas de la function
fortran.
sûr, h est l’intervalle entre deux points successifs.
A priori cette approximation est meilleure que la
précédente, permettant une bonne description de la fonc-
tion avec un nombre de points plus faible ; il y cependant
une hypothèse importante derrière cela, c’est que la fonc-
tion ne se livre pas à des excentricités entre deux points
successifs, par exemple, qu’il n’y ait pas de point singulier
ou de variations énormes entre deux points connus.
Physique numérique, Philippe Depondt 55

4.4.3 Polynômes de Lagrange.

Il est aisé quoique rapidement fastidieux de généraliser
la méthode ci-dessus à un polynôme de degré n quel-
conque. On obtient un polynôme passant par les n + 1
points (x0 , f (x0 )), . . ., (xℓ , f (xℓ )) . . ., (xn , f (xn )) :

pn (x) =

n
X (x − x0 ) . . . (x − xℓ−1 )(x − xℓ+1 ) . . . (x − xn )
f (xℓ )
(xℓ − x0 ) . . . (xℓ − xℓ−1 )(xℓ − xℓ+1 ) . . . (xℓ − xn )
ℓ=0

dans les produits du numérateur et du dénominateur de la

fraction ci-dessus, manquent évidemment les termes x−xℓ
et . . . xℓ − xℓ !
Le choix du degré le plus approprié pour le polynôme
n’est pas facile. Une bonne règle est de ne pas essayer de
trop bien faire ! En effet le choix d’un degré trop élevé, bien
loin d’améliorer l’interpolation, risque de produire des os-
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
commence à manquer de données de références : peut-être
est-il temps alors d’envisager de faire quelques points de
mesure expérimentaux supplémentaires. . . L’informatique,
contrairement à la magie, ne peut pas tout faire, en par-
ticulier inventer des données numériques manquantes !
4.4.4 Dérivées.
Les mêmes méthodes permettent en principe une
évaluation des dérivées successives d’une fonction puis-
qu’à partir de l’expression d’un polynôme de Lagrange de
degré n on peut facilement obtenir des expressions pour
les dérivées jusqu’à la dérivée n-ième.
Par exemple, une expression de la dérivée première peut
être obtenue à partir de l’approximation linéaire, éq. (4.4) :
f (xℓ+1 ) − f (xℓ )
p′ℓ =
xℓ+1 − xℓ
En fait, il s’agirait plutôt d’un calcul de la dérivée en
xℓ+1 +xℓ
2 , au milieu de l’intervalle, et non en xℓ . Si l’on En combinant ces deux équations, on obtient facilement :
préfère une expression plus symétrique qui donne une
autre estimation plus précisément en xℓ :
grad
Fig. 4.15 – Derivée d’un sinus affecté d’un léger bruit. La
dérivée, elle, est affectée d’un fort bruit, même si l’allure
générale est convenable.
4.5 Algèbre linéaire.
4.5.1 Un exemple : la diffusion de la cha-
leur à une dimension.
La loi de Fourier de diffusion de la chaleur dit simple-
ment que le flux de chaleur en un point est proportionnel
au gradient de température :
~ r ) = −κ(~r) grad
φ(~ ~ T (~r)
où κ(~r) est la conductivité thermique qui dépend de la
nature du milieu. Si celui-ci est homogène, κ est une
constante, sinon κ dépend de la position ~r.
Si l’on produit de la chaleur en un point ~r donné (par
effet Joule ou par un apport quelconque, ou encore au
contraire par une perte dans l’atmosphère), cette chaleur
doit diffuser et cette chaleur diffusée par unité de temps
doit être égale à la quantité Q̇(~r) de chaleur produite par
unité de temps, ce qui donne :
~ r ) = Q̇(~r)
div φ(~
~ κ(~r) · grad
~ T (~r) + κ(~r) ∆T (~r) = −Q̇(~r) (4.5)

f (xℓ+1 ) − f (xℓ−1 ) Cette équation, alliée à d’éventuelles conditions aux

p′ℓ =
xℓ+1 − xℓ−1
On montre d’ailleurs aisément que cette dernière expres-
sion vient de la dérivation de l’approximation parabolique.
Il faut cependant être assez prudent. Outre la remarque
ci-dessus concernant la limite pratique sur le degré du
polynôme utilisé, il faut être conscient qu’un calcul de
dérivée va tendre à amplifier le bruit (figure 4.15). En ef-
fet, des fluctuations locales, de point à point, de la fonction
peuvent donner des valeurs numériques importantes pour,
mettons, la dérivée première, et ces valeurs risquent de
changer brutalement d’un point à un autre. En pratique,
on se limite donc à des dérivées d’ordre faible, un voire
deux, sur des données de très bonne qualité intrinsèque. pose,
On verra dans le chapitre 4.8 d’autres méthodes plus sûres
en présence de bruit.
limites, permet, en principe, de calculer la distribution
de température en régime stationnaire dans un objet,
connaissant Q̇(~r) et κ(~r). Autant dire que ce n’est pas
toujours 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
x = i δx
 56 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où i est un entier et δx un pas d’intégration, similaire à ce d’invoquer la bibliothèque lors de la compilation : c’est en
qui a déjà été vu dans le chapitre 4.3.2. On note alors : général une option de compilation11 : le compilateur ira
puiser dans la bibliothèque ce dont il a besoin. . .
T (x) = T (i δx ) = Ti 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 :
dT
La dérivée peut être approchée par : on se pose un problème de physique, puis on se demande
dx comment le traduire de façon à le traiter avec un pro-
dT Ti+1 − Ti gramme de bibliothèque déjà existant.
∼ Dans le cas présent, un système d’équations linéaires se
dx δx
présente de la façon suivante :
ou bien 
dT Ti − Ti−1 
 a11 x1 + a12 x2 + a13 x3 + · · · + a1n xn = b1
∼ 

dx δx 
 a 21 x1 + a22 x2 + a23 x3 + · · · + a2n xn = b2

a31 x1 + a32 x2 + a33 x3 + · · · + a3n xn = b3
ou encore :
dT Ti+1 − Ti−1 
 a41 x1 + a42 x2 + a43 x3 + · · · + a4n xn = b4
∼ 

dx 2δx 
 ···

an1 x1 + an2 x2 + an3 x3 + · · · + ann xn = bn
On préfèrera la troisième forme plus symétrique. La
dérivée seconde, la dérivée de la dérivée, s’écrit : où l’on cherche les xi . Le problème peut se reformuler en
termes matriciels :
Ti+1 − Ti Ti − Ti−1 A·x=b
−
d2 T δx δx Ti+1 − 2Ti + Ti−1
∼ = avec  
dx2 δx δx2 a11 a12 a13 · · · a1n
 a21 a22 a23 · · · a2n 
Cela donne donc, avec des notations évidentes :  
 a31 a32 a33 · · · a3n 
  A=  

dκ Ti+1 − Ti−1 Ti+1 − 2Ti + Ti−1  a41 a42 a43 · · · a4n 
+ κi = − Q̇ i (4.6)  · · · 
dx i 2δx δx2
an1 an2 an3 · · · ann
Si L est la longueur du barreau, alors n = δLx est le nombre et    
de segments sur le barreau : c’est a priori un nombre qui x1 b1
 x2   b2 
peut être grand, quelques centaines, milliers, voire plus ;    
 x3   b3 
or, l’équation (4.6) se reécrit aisément : x=   b=  
 x4 
  b4 

     ···   ··· 
1 dκ κi κi
+ Ti+1 − 2 2 Ti + xn bn
2δx dx i δx2 δx
    Pour ce qui est de la matrice A, il faut savoir que
1 dκ κi fortran stocke les matrices multicolonnes colonne par
− + Ti−1 = −Q̇i colonne : une colonne, puis une autre, puis une autre.
2δx dx i δx2
En mémoire, se succèdent ainsi : a11 , a21 , a31 , · · · an1
ou bien (première colonne), a12 , a22 ,. . .(deuxième colonne),. . . etc.,
c’est-à-dire que le premier indice « va le plus vite » (en
ai,i+1 Ti+1 + ai,i Ti + ai,i−1 Ti−1 = bi ∀i 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
où les ai,j sont connus et où l’on cherche à calculer les successifs en mémoire12 , et donc dans les boucles im-
Ti . On vient de reformuler le problème comme un système briquées, mettre autant que possible, le premier indice
linéaire de n équations à n inconnues (les Ti ) : si on peut dans la boucle la plus interne. Par exemple :
trouver des méthodes pour résoudre de très gros systèmes do j = 1, n ! boucles dans le bon ordre
d’équations linéaires, alors le problème ci-dessus peut être a(1:n,j) = ...
considéré comme résolu. enddo
et non l’inverse :
4.5.2 Systèmes d’équations linéaires. do i = 1, n ! boucles dans le mauvais ordre
Au delà de n = 2 ou 3, il ne faut surtout pas tenter de a(i,1:n) = ...
enddo
résoudre le système linéaire en procédant par élimination
comme on le fait d’habitude pour une résolution à la main : Pour résoudre le système d’équations, on pourrait ima-
les problèmes de stabilité numérique deviennent très vite giner qu’il suffise de calculer l’inverse de la matrice A et
cruciaux. Il vaut bien mieux utiliser des sous-programmes faire le produit :
de bibliothèque : ce sont des programmes déjà écrits, sou- x = A−1 · b
vent depuis longtemps, éprouvés, dont les qualités et les mais il se trouve que les algorithmes de résolution directe
défauts sont connus, compilés et rassemblés dans des bi- du système d’équations sont plus efficaces.
bliothèques. Il suffit d’appeller le sous-programme choisi 11 généralement,l’option -l (pour library=bibliothèque), par
par un call dans le programme que l’on a écrit comme exemple avec la bibliothèque linpack : g95 machin.f90 -llinpack
n’importe quel autre sous-programme, en suivant toute- -o machin.
fois les indications fournies dans la documentation10 puis 12 Parce que le compilateur gère mieux les transferts entre mémoire

et processeur de paquets de nombres connexes que des nombres pris

10 Souvent en ligne. dans n’importe quel ordre.
Physique numérique, Philippe Depondt 57

4.5.2.1 La méthode LU n(n + 1)

Il y a n2 équations, or L comporte éléments a
2
C’est le véritable cheval de bataille de tous ces priori non nuls, ainsi que U, soit n + n inconnues, et donc
2
problèmes (voir réf. [3] pour une discussion plus appro- n de trop. On fixe alors :
fondies des qualités et défauts des différentes méthodes,
par exemple Gauss-Jordan). lii = 1, ∀i
Imaginons que l’on ait décomposé la matrice A en un
produit de deux matrices : Pour i ≤ j, on obtient aisément :
i−1
X
A= L·U
uij = aij − lik ukj (4.8)
où L est une matrice triangulaire inférieure (L = lower ) k=1
qui n’a des éléments que sur et sous la diagonale :
Enfin, pour i > j :
 
l11 0 0 0 !
j−1
X
 l21 l22 0 0  1
L=  l31 l32 l33 0 
 lij = aij − lik ukj (4.9)
ujj
k=1
l41 l42 l43 l44
Tous les termes dans les sommes des équations (4.8) et
dans le cas où n = 4, et U est une matrice triangulaire
(4.9) sont déjà calculés à condition d’appliquer les deux
supérieure (U = upper ) qui n’a des éléments que sur et au équations par i croissants pour un j donné, puis changer
dessus de la diagonale :
de j. Il ne s’agit finalement que d’un réordonancement très
  simple du problème.
u11 u12 u13 u14
 0 u22 u23 u24  En général, les programmes qui appliquent cet algo-
U=  0
 rithmes détruisent le contenu de la matrice A en rangeant
0 u33 u34 
0 0 0 u44 les éléments de L dans la partie inférieure de A, et les
éléments de U dans la partie supérieure, sachant que les
Le système initial se reécrit : lii ne sont pas conservés, puisqu’ils valent 1. En outre,
afin de limiter les dégâts lors des divisions par ujj dans
L · (U · x) = b l’équation (4.9), un certain réarrangement des lignes et co-
lonnes du système d’équations doit être fait pour commen-
il reste à chercher y tel que :
cer par les éléments pour lesquels ujj est grand (une divi-
L·y =b sion par un nombre très petit donne parfois des résultats
imprévisibles). Les programmes de bibliothèque font cela
puis x tel que : et souvent fournissent en prime des diagnostics lorsque A
U·x =y est singulière, ou trop proche d’une matrice singulière.
L’avantage de procéder ainsi est que maintenant le système
est trivial à cause de la forme triangulaire des deux ma- 4.5.2.2 Amélioration itérative de la précision.
trices : Il faut néanmoins faire un peu attention à la précision du
1 1
b1 résultat obtenu, car les termes du type et dans les
y1 = lii uii
l11 équations (4.7) et (4.9) peuvent donner lieu à des surprises
1 si les diviseurs sont petits. Il y a plusieurs façons de s’en
y2 = [b2 − l21 y1 ]
l22 sortir. La première consiste à utiliser un sous-programme
1 de bibliothèque capable de détecter ce genre de problème :
y3 = [b3 − (l31 y1 + l32 y2 )]
l33 pratiquement toutes les bibliothèques en proposent. Un
··· (4.7) autre test possible est de comparer les résultats obtenus
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
′
yn x , et donc fausse, obtenue par, mettons, la méthode LU
xn = et de chercher à l’améliorer.
unn
··· Soit :
A · x′ = b + δb
Reste à faire la décomposition proprement dite.
Il s’agit d’un algorithme typique de ceux dont sont où δb est l’erreur qu’il faut réduire ; or :
friands les amateurs. Nous le détaillons ici pour le plai-
sir de ce genre de tourisme13 ! Cela s’appelle l’algorithme x′ = x + δx, et A · x = b
de Crout.
donc :
Le problème est de trouver lij et uij tels que :
A · δx = δb = A · x′ − b
min(i,j)
X qui est un système que l’on peut résoudre pour obtenir δx.
lik ukj = aij On peut alors corriger x′ et recommencer jusqu’à obtenir
k=1
la précision voulue, à condition évidemment que l’algo-
13 Et surtout pas pour l’apprendre par cœur. . . rithme converge. . .
 58 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Il faut savoir cependant que les bibliothèques pro- nuls. On écrit plutôt
posent généralement un très grand nombre de sous-  
d1 f1 0 0 0 ··· 0
programmes prévus pour des cas très divers : il est
donc conseillé de choisir le programme adapté. Toutefois,  e2 d2 f2 0 0 ··· 0 
 0 e3 d3 f3 0 0 
pour la plupart des problèmes « standards » du physi-  ··· 
 ··· ··· ··· ··· ··· · · · · ·· 
cien, la méthode LU est très satisfaisante, mais pour les A=  
 ··· 0 ei di fi 0 ··· 
problèmes exigeant d’énormes matrices creuses tels que les  ··· ··· ··· ··· ··· ··· ··· 
méthodes d’éléments finis (pour la résolution de problèmes  
0 0 · · · 0 en−1 dn−1 fn−1
de mécanique des fluides par exemple), des méthodes 0 0 ··· 0 0 en dn
spécialement prévues à cet effet doivent être utilisées.
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-
4.5.2.3 Matrice inverse. diagonale. Noter que e1 et fn ne sont pas définis.
Les équations (4.8) et (4.9) se réduisent à :
Une fois la décomposition achevée, il est facile de rem-
placer b par : i = j − 1 uj−1j = ej
  i=j ujj = dj − ljj−1 uj−1j
1
 0  fj
  i = j + 1 lj+1j =
 0  ujj
 
 .. 
 .  Les équations ci-dessus ne constituent pas en elles-même
0 l’intérêt principal de ce paragraphe : le but est ici d’atti-
rer l’attention sur le fait que pour un type de matrice,
ce qui donne la première colonne de A−1 dans x, puis on la méthode de résolution que l’on choisira n’est pas tou-
procède colonne par colonne en posant : jours la même que pour un autre type de matrice. Les
  bibliothèques sont parfois fort riches et il est de bon
0 ton de chercher un peu dans la documentation quel peut
 ..  être le sous-programme le plus adapté au cas particu-
 . 
  lier envisagé. Il existe des solutions pour des matrices
b=  1 

 .  « bande-diagonales » ou des solutions itératives par ap-
 ..  proximations successives pour des problèmes difficiles, des
0 décompositions en valeurs singulières quand le problème
se pose. . ., les ressources sont abondantes, parfois un peu
en plaçant le nombre 1 sur la i-ème ligne de b pour obtenir trop, même !
la i-ème colonne de A−1 .
4.5.3 Une généralisation de la méthode de
Newton à plusieurs dimensions.
4.5.2.4 Déterminant d’une matrice.
Au chapitre 4.1.2, on a mentionné le fait que la méthode
C’est encore plus simple : de Newton de recherche de zéro pouvait se généraliser à
plusieurs dimensions. Cela peut être utile, si par exemple,
Y n
au lieu d’un seul pendule comme dans l’exemple, on en
det A = ujj avait plusieurs couplés entre eux et non plus astreints à se
j=1
déplacer dans un plan : on aurait alors deux angles polaires
par pendule à trouver et donc un système de 2N variables
à rechercher.
4.5.2.5 Matrice tridiagonale.
C’est le moment de s’y attaquer. Soit donc n fonctions
Si l’on étudie l’équation (4.6), on s’aperçoit vite que de n variables
seuls les termes en i − 1, i et i + 1 sont non nuls. La
fj (x1 , . . . , xi , . . . , xn ), ∀j ∈ [1, n]
matrice A ne comporte alors que des termes diagonaux,
sous-diagonaux et sur-diagonaux : elle est donc tridiago- dont on suppose qu’elles possèdent un zéro et qu’elles sont
nale : raisonnablement « civilisées »14 : ces fonctions ne sont
  toutefois évidemment pas linéaires.
a11 a12 0 0 0 ··· 0
a21 a22 a23 0 0 0
On démarre la recherche comme avant à partir d’un
 ··· 
 0 a32 a33 a34 0 0  point de départ :
 ··· 
 ··· ··· ··· ··· ··· ··· ··· 
A=



(0) (0)
x1 , . . . , xi , . . . , x(0)
 ··· 0 aii−1 aii aii+1 0 ···  n
 ··· ··· ··· ··· ··· ··· ··· 
  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 14 Le terme civilisé pour une fonction signifie en gros que l’algo-

A avec ses n2 éléments puisque, pour la plupart, ils sont rithme que l’on va utiliser marche. . .
Physique numérique, Philippe Depondt 59

= ce qui donne :
(0) (0)
fj (x1 , . . . , xi , . . . , x(0) 
n )+  g C
 2
 ω a1 = a1 + (a1 − a2 )
∂fj ∂fj ∂fj ℓ1 m1 ℓ 1
dx1 + . . . + dxi + . . . + dxn
∂x1 ∂xi ∂xn 
 g C
 ω 2 a2 = a2 + (a2 − a1 )
où dxi = xi −
(0)
xi . On cherche le point {xi } tel que ℓ2 m2 ℓ 2
fj (x1 , . . . , xi , . . . , xn ) = 0, ∀j, donc les équations ci- et :
dessus se reécrivent :   
 g C 2 C
∂fj ∂fj ∂fj 
 + − ω a1 − a2 = 0
dx1 + . . . + dxi + . . . + dxn ℓ1 m1 ℓ 1 m1 ℓ 1
∂x1 ∂xi ∂xn  

 C g C
=  − a1 + + − ω 2 a2 = 0
m2 ℓ 2 ℓ2 m2 ℓ 2
(0) (0)
−fj (x1 , . . . , xi , . . . , x(0)
n )
ce qui se résout aisément en écrivant que le déterminant
C’est un système d’équations linéaires dont les inconnues du système est nul, etc.15
sont les {dxi } : Cependant, on peut reécrire le problème matricielle-
J · dx(1) = −f (0) ment :
avec des notations sans surprise. La matrice J des dérivées D · a = ω2a
∂fj
partielles, Jij = , s’appelle la matrice jacobienne. avec évidemment :
∂xi
On résout donc le système, ce qui permet de calculer les    
g C C
(1)
{xi } puis on recommence jusqu’à convergence, comme + −  
 ℓ1 m1 ℓ 1 m1 ℓ 1  a1
dans le cas à une dimension. D=   
 , a =
C g C a2
− +
m2 ℓ 2 ℓ2 m2 ℓ 2
4.5.4 Problèmes de vecteurs propres et de
valeurs propres ou eigenproblems. La matrice D s’appelle la matrice dynamique du système
et l’on s’aperçoit donc que ω 2 est une valeur propre de
Il s’agit de résoudre l’équation :
la matrice dynamique et que a en est un vecteur propre.
A · x = λx 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 ×
où connaissant A, on en cherche les valeurs propres λ et 100 ? Par exemple, une molécule qui comporte ne serait-
les vecteurs propres x. ce que quelques dizaines d’atomes. . . il suffit alors d’écrire
la matrice dynamique du système, une matrice n × n où
4.5.4.1 Un exemple : les modes propres d’un n est le nombre de degrés de liberté du système, et d’en
ensemble d’oscillateurs harmoniques chercher valeurs et vecteurs propres.
couplés. Il se trouve qu’il y a des algorithmes très efficaces pour
calculer numériquement les valeurs propres et les vecteurs
Prenons un cas très simple : deux pendules simples propres de très grosses matrices.
couplés par un fil de torsion. L’énergie potentielle du Ici encore, la façon de procéder dépend du type de ma-
système s’écrit : trice que l’on veut étudier, et ici encore, il faut faire appel
1 à des programmes de bibliothèque.
V = −m1 g cos θ1 − m2 g cos θ2 + C(θ1 − θ2 )2
2
4.5.4.2 Matrices tridiagonales symétriques : la
avec des notations évidentes. Les équations du mouvement
méthode QL.
s’en déduisent sans difficulté :
 La matrice dynamique du paragraphe 4.5.4.1 peut être
 g C √

 θ̈1 = − ℓ sin θ1 − m ℓ (θ1 − θ2 ) symétrisée √ en remplaçant a1 par α1 = m1 ℓ1 a1 et a2
1 1 1
par α2 = m1 ℓ2 a2 . De plus, si le nombre de pendules

 g C
 θ̈2 = − sin θ2 − (θ2 − θ1 ) est plus grand que deux, si les pendules sont alignés et
ℓ2 m2 ℓ 2 chaque pendule n’interagit qu’avec ses deux voisins les plus
Puisque l’on s’intéresse ici à un problème linéaire, on peut proches, la matrice D est tridiagonale symétrique. Il se
se restreindre à des oscillations de petite amplitude, et trouve que beaucoup de problèmes peuvent être ramenés
avec l’approximation habituelle, on obtient : au calcul des valeurs propres d’une matrice tridiagonale
 symétrique qui est justement le cas le plus simple.
 g C La plupart des programmes de bibliothèque utilise la

 θ̈1 = − ℓ θ1 − m ℓ (θ1 − θ2 )
1 1 1 méthode QL qui consiste à faire une série de transforma-

 g C tions orthogonales :
 θ̈2 = − θ2 − (θ2 − θ1 )
ℓ2 m2 ℓ 2 15 C’est d’ailleurs un exercice conseillé : le déterminant donne une

équation bicarrée en ω, on trouve donc deux solutions positives et

un système pour lequel on cherche des solutions station- donc deux fréquences propres ; à chaque fréquence propre correspond
naires périodiques du type : un couple (a1 , a2 ) d’amplitudes pour les deux pendules, c’est-à-dire
un mode propre. Le mouvement des pendules est une combinaison
θ1 = a1 eiωt , θ2 = a2 eiωt linéaire de ces deux modes.
60 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

l’équation stationnaire et l’on tentera une résolution en

As+1 = Ls · Qs développant la fonction d’onde ψ sur une base de fonc-
tions connues : c’est, a priori, une approximation car rien
où Ls est une matrice triangulaire inférieure et Qs une
ne dit que la « vraie » solution puisse être correctement
matrice orthogonale, c’est-à-dire que :
développée sur la base choisie, surtout si celle-ci est réduite
−1
Qs = Qs t à un nombre fini, voire un petit nombre, de fonctions.
La consultation d’un cours de physique quantique
Une série de théorèmes, que nous n’étudierons pas ici, montre que l’on peut poser le problème de la façon sui-
montrent que l’on peut décomposer Ls de la façon sui- vante : R ∗
vante ψ (X)H(X)ψ(X)dX
E = R (4.11)
t
Ls = Qs · As ψ ∗ (X)ψ(X)dX
écrire Qs comme un produit de rotations planes et que la où H est le Hamiltonien (connu) du système considéré,
séquence X désigne l’ensemble des variables du problème, ψ(X)
As+1 = Qts · As · Qs la fonction d’onde que l’on cherche et E l’énergie (que
l’on cherche également). Pour simplifier les notations, il
fera apparaı̂tre les valeurs propres sur la diagonale. est d’usage d’écrire la même équation comme suit :
Pour l’utilisateur, il suffit de fournir deux tableaux uni-
dimensionnels contenant la diagonale et la sous-diagonale < ψ|H|ψ >
de la matrice initiale A ou A0 . Au retour, on obtient les va- E=
< ψ|ψ >
leurs propres à la place de la diagonale en général classées
par ordre de valeur décroissante. Si l’on veut aussi les vec- L’énergie E dépend évidemment de la fonction d’onde et
teurs propres, il faut également fournir un tableau n × n l’on montre que si l’on modifie légèrement ψ, E doit être
et. . . bien lire la documentation pour déterminer si un vec- minimum par rapport à ce changement, si toutefois E et
teur propre donné occupe une ligne ou une colonne de la ψ sont solutions du problème.
dite matrice ! En général, les vecteurs propres obtenus sont On développe alors la fonction d’onde sur une base de
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 ortho-
où Rs est une rotation plane judicieusement choisie et là normé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
l’équation (4.12), on obtient alors :
4.5.4.4 Problèmes aux valeurs propres généra-
lisés. δE = !
Ce sont des problèmes du type : X X X
δc∗k 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
Physique numérique, Philippe Depondt 61

avec des notations sans surprise. On reconnait là une
équation aux valeurs propres : la résoudre donne à la fois
les énergies propres et les coefficients correspondants du
développement de la fonction d’onde.
Pour des raisons diverses, il peut arriver cependant que
la base de fonctions utilisée ne soit pas orthonormée : par
exemple, si l’on cherche des fonctions d’onde électroniques
dans le champ d’un ensemble de noyaux, on peut vouloir
utiliser des fonctions d’onde localisées sur les noyaux ato-
miques avec un certain recouvrement. Les produits sca-
laires :
< χℓ |χm >= sℓm
4.6 Problèmes autocohérents.
ou self-consistent problems en anglais.
4.6.1 Qu’est-ce donc ?
Imaginons, par exemple, un diélectrique constitué d’un
ensemble d’atomes polarisables qui, lorsqu’ils sont sou-
mis à un champ électrique, voient leur nuage électronique
déformé. Ils portent alors un moment dipolaire dont on
supposera ici selon l’approximation d’usage qu’il est pro-
portionnel au champ :

deviennent alors les éléments d’une matrice S qui n’est ~ ri )

p~i = α E(~
plus la matrice unité. Le problème se reformule légèrement
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~ dipj (~ri )
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 : où E~ dipj (~ri ) est le champ produit en ~ri par le dipôle porté
par l’atome j. Donc :
B−1 · A · x = λ x
 
−1 X
La matrice B · A n’est généralement pas symétrique ~pi = α E ~ ext + ~ dipj (~ri )
E (4.13)
même si A et B le sont. Les sous-programmes de bi- j, j6=i
bliothè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
les champs dipolaires, il faut connaı̂tre les moments dipo-
et le problème se re-écrit : laires : on tourne en rond.
t

t

On peut, certes, tenter de remplacer E ~ dipj (~ri ) par son
C· L ·x =λ L ·x
expression en fonction de ~pj et résoudre, par exemple, par
avec : la méthode de Newton le système d’équations :
−1


−1 t
C= L ·A· L
~pi − 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’utili-
sateur. ∂ 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.
[0]
surtout pas se priver de les utiliser quand le problème On peut toutefois partir d’une solution d’essai ~pi , 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]
de l’équation (4.13), de nouvelles valeurs ~pi , puis de nou-
bustes16 . En revanche, les bibliothèques de programmes [2]
veaux champs et p~i et ainsi de suite. La solution sera
sont souvent extrêmement riches et l’on a parfois du mal obtenue quand on aura atteint un « point fixe » tel que :
à déterminer quel est le sous-programme qui répondra le
mieux à la question posée : il faut prendre le temps de ~pi
[k+1]
≃ p~i
[k]
réfléchir, de lire la documentation disponible, hélas pas
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 !
16
xi = fi (x1 , x2 , . . . , xn ), i ∈ [1, n]
ce qui ne dispense pas bien sûr de vérifier sur des problèmes dont
la solution est connue que les programmes marchent convenablement,
et, comme d’habitude, ne pas oublier d’user de l’esprit critique du ou
physicien. . . x = f (x)
62 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où les lettres en caractères gras représentent des vecteurs de notre fonction tend vers 1 lorsque x tend vers zéro :
de n éléments. On part d’une solution d’essai x[0] et l’on on est à la limite de la condition de convergence |a| < 1,
construit la séquence : ainsi, dans ce cas, plus on s’approche de la solution, plus la
convergence devient difficile. On en concluera néanmoins
x[k+1] = f (x[k] ) que le critère ci-dessus, a priori valable pour une fonction
linéaire, l’est également pour une fonction non-linéaire à
Le point fixe sera considéré comme atteint quand les
condition d’en connaı̂tre la dérivée au point fixe, ou du
x[k] n’évolueront plus de façon significative à chaque
moins d’être capable d’estimer si elle est, en valeur abso-
génération.
lue, inférieure à 117 .
Ce genre de raisonnement est généralisable à des
4.6.3 Est-ce que ça converge ? systèmes linéaires du type :
Rien n’est moins sûr ! Prenons un cas très simple pour x = Ax + b
lequel n = 1 et :
f (x) = ax On obtient évidemment que :
La solution est évidemment x = 0. Si l’on veut résoudre

[0] x[k] = Ak x[0] + I + A + A2 + . . . + Ak−1 b
ce problème par la méthode ci-dessus, on part d’un x
choisi arbitrairement et Pour que cela converge, on montre18 qu’il suffit que :
x[1] = a x[0] , x[2] = a x[1] = a2 x[0] ||A|| < 1
et bien sûr : où ||A|| est l’une des normes de A :
x[k] = ak x[0]
n
X
Si |a| < 1, la convergence est acquise, mais sinon ça di-
||A||m = max |aij |
verge ! i
j=1
Étudions maintenant le cas :
ou bien
f (x) = tanh x n
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 u n X
n
||A||k = t |aij |2
implicit none
i=1 j=1
real :: x=1. ! point de depart de la recherche
integer :: k, kmax=100000 En particulier, si l’on a :
open(1,file=’autoco.res’)
write(1,*) 0, x 1
aij < , ∀ i, j ∈ [1, n]
do k = 1, kmax n
x = tanh(x)
if( mod(k, 10) == 0 ) write(1,*) k, x la suite converge.
enddo Pour un système non-linéaire, la matrice A devient la
close(1) matrice jacobienne J à proximité du point fixe : cela sup-
end pose que l’on soit capable d’évaluer cette matrice au point
fixe qui est justement ce que l’on cherche !
1 Afin de tempérer cette note apparemment pessimiste,
l’on mentionnera -et le lecteur est chaleureusement in-
vité à le vérifier- que le problème du diélectrique converge
0.1 de façon très satisfaisante en moins de 10 pas de cal-
cul à la suite d’un effort de programmation modeste. Ces
méthodes peuvent ainsi se révéler extrêmement précieuses
x

dans bien des cas, même si l’évaluation a priori de leurs

0.01
chances de succès relève parfois plus de l’astrologie que de
la science. . .

0.001
10 100 1000 10000 100000
k 4.7 Recherche des minima d’une
Fig. 4.16 – Convergence plus que médiocre de la recherche fonction.
autocohérente de la solution de l’équation x = tanh x (les
Il arrive bien souvent que l’on ait besoin, par exemple,
échelles sont logarithmiques).
du minimum de l’énergie potentielle d’un système qui
17 C’est un problème similaire à celui que l’on avait recontré à
Le résultat est malheureusement assez décevant (figure
propos de l’équation logistique (§ 3.2.2, la recherche des points fixes
4.16) : après 105 pas, on en est encore à quelques millièmes est en fait une recherche de zéros) où l’on avait vu qu’un système non-
de la solution ! On était habitué à mieux. . . Si l’on essaie linéaire pouvait être susceptible d’un comportement chaotique. . .
d’appliquer le critère ci-dessus, on s’aperçoit que la dérivée 18 Voir par exemple la référence [2], p. 322.
Physique numérique, Philippe Depondt 63

dépend d’une ou plusieurs variables pour en obtenir f (x) une fonction d’un ensemble de n variables désignées
l’équilibre stable : mettons, un ensemble d’atomes qui par x = (x1 , . . . , xn ). Un extremum est donné par :
composent une molécule dont on veut la conformation à
l’équilibre compte tenu des potentiels d’interaction atome- ∂f
di (x) = =0 ∀i
atome. ∂xi
Un autre exemple, qui sera étudié plus en détail dans le cela donne un système de n équations dont on cherche les
chapitre 4.8, est celui de la recherche du minimum d’écart zéros, or la variation δdi (x) de di pour des variations δxi
possible entre des données expérimentales et les prévisions s’écrit :
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 X ∂di X ∂2f
δdi (x) = δxj = δxj (4.14)
de ces paramètres qui donne l’écart le plus faible possible. ∂xj ∂xi ∂xj
j j
On pourrait aussi, dans un autre ordre d’idées, chercher
le chemin optique le plus court pour un rayon lumineux, La matrice H telle que
encore que la résolution d’une équation différentielle or-
dinaire selon les méthodes du chapitre 4.9 paraisse plus ∂2f
Hij =
facile dans un bon nombre de cas. ∂xi ∂xj

s’appelle la matrice Hessienne. C’est cette matrice qui

4.7.1 Du mouvement des amibes (mé- intervient dans le système linéaire (4.14) que l’on doit
thode du simplex). résoudre en δxi en suivant la méthode de Newton déjà
vue :
4.7.1.1 À une dimension H · δx = −d
On cherche donc le minimum d’une fonction f (x). On avec des notations évidentes. Le vecteur d donne les va-
pourrait imaginer quelques chose qui s’apparente à la riations qu’il faudrait imposer aux variables x (ou xi ∀i)
méthode de la dichotomie : on choisit un intervalle, on pour annuler l’écart dans l’approximation linéaire. Comme
prend le milieu, on regarde s’il est plus bas que les bords, la fonction f (x) n’est pas a priori linéaire, il faut recom-
etc. En fait, il suffit, dans un espace unidimensionnel, de mencer l’opération jusqu’à convergence.
prendre deux points : a et b. Mettons que f (a) < f (b), C’est souvent efficace et c’est extrêmement simple à
alors on cherchera un point c symétrique de b par rapport mettre en œuvre (à condition de pouvoir calculer les
à a : on va dans le sens où ça décroı̂t et cela s’appelle une dérivées secondes qui composent la matrice hessienne),
réflexion. Si f (c) < f (a) c’est sans doute qu’on pouvait al- mais il faut être conscient qu’on ne se donne, alors, pas
ler plus loin : on double alors le déplacement dans le même tous les moyens pour réussir. En effet, la méthode de
sens (dilatation) ; sinon, c’est qu’on est allé trop loin, alors Newton recherche les zéros d’un ensemble de fonctions
on divise le déplacement par deux (contraction). Puis on complètement indépendantes, alors que les dérivées d’une
recommence l’opération jusqu’à ce que l’intervalle entre les fonction ne le sont pas. En outre, la matrice Hessienne
deux derniers points soit plus petit que la précision voulue. n’est pas toujours disponible aisément.

4.7.1.2 À N dimensions. 4.7.3 Recherche à une dimension : inter-

Le principe est le même : si l’on est dans un espace à N
polation parabolique.
dimension, on part de N + 1 points de l’espace : la figure Admettons que l’on connaisse trois points x = a, b et c
obtenue s’appelle un simplex, par exemple, si N = 2, c’est avec a < c < b d’une part, et f (c) < f (a) et f (c) < f (b)
un triangle. On remplace alors le point du simplex qui de l’autre. La deuxième condition impose qu’il doit y avoir
donne la valeur la plus élevée de la fonction par un autre un minimum au moins dans l’intervalle [a, b].
obtenu en faisant une réflexion par rapport au centre de On assimile alors localement la fonction à une parabole
gravité du simplex, puis des dilatations ou des contractions passant par les trois points (figure 4.17) :
à la demande. Ainsi, le simplex se déplace en se déformant,
telle une amibe, en cherchant toujours à se concentrer sur (x − c)(x − b)
f (x) ∼ p(x) = f (a) +
point le plus bas. Quand il devient assez petit, le problème (a − c)(a − b)
est résolu.
La méthode du simplex a le mérite de ne nécessiter au- (x − a)(x − c) (x − a)(x − b)
f (b) + f (c)
cun calcul de dérivée et d’être simple à mettre en œuvre. (b − a)(b − c) (c − a)(c − b)
Autant dire, cependant, qu’elle est assez inefficace : elle est dont on cherche le minimum :
à réserver aux problèmes pas trop lourds numériquement
pour lesquels on n’a pas de raison de faire d’effort parti- p′ (x) = 0
culier.
soit :

4.7.2 Méthode de Newton 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)
Il y a une méthode évidente : puisque l’on peut cher-
cher les zéros d’un ensemble de fonctions par la méthode puis on recommence avec une procédure similaire à celle de
de Newton, il suffit, lorsqu’on cherche les minima d’une la dichotomie : si x ∈]a, c[ on prend les points a, x et c, si-
fonction, de chercher les zéros de ses dérivées. Soit donc non, on prend c, x et b et l’on calcule par la même méthode
64 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

f(b)
1X ∂2f X ∂f
f (x) ∼ xi xj + xi + f0 (4.16)
2 i,j ∂xi ∂xj i
∂xi

f(a) où l’on peut introduire la matrice Hessienne H et le gra-

f(c) dient g de f tel que
∂f
gi =
∂xi
L’équation (4.16) se reécrit en notations matricielles :
1
f (x) ∼ x · H · x + g · x + f0 (4.17)
2
et
f ′ (x) ∼ H · x + g = r
où r est le résidu qui devrait être nul si l’on était au point
a c x b x solution. C’est aussi le vecteur qui indique la direction
de plus grande pente, direction de recherche.
Fig. 4.17 – Recherche de minimum parabolique à une di- Mettons que l’on démarre la recherche d’un point x0
mension. avec une direction de recherche r0 , l’on écrira donc :
x1 = x0 + α0 r0
une nouvelle estimation x′ et ainsi de suite jusqu’à obtenir
il faut chercher α0 tel que f soit minimum sur la direction
la précision voulue. Il reste cependant la question de savoir
r0 , or en développant (4.17) et en écrivant la dérivée par
si le minimum de la parabole est bien un minimum et non
rapport à α0 , on doit chercher α0 tel que :
un maximum ! On peut vérifier si par exemple, f (x) est
bien inférieur à f (c) ; s’il ne l’est pas on peut prendre par α0 r0 · H · r0 + x0 · H · r0 + g · r0 = 0
exemple le point milieu de c et de x.
où l’on a tenu compte du fait que H est une matrice
symétrique19 , ce qui donne une expression de α0 :
4.7.4 Méthode du gradient conjugué. r0 · r0
α0 = −
Soit de nouveau une fonction f (x) où x est un vecteur r 0 · H · r0
dans un espace de dimension quelconque n. On cherche le Si l’on répète la même séquence, la nouvelle direction de
minimum de cette fonction. recherche r1 doit être orthogonale à r0 parce que justement
Une première idée qui pourrait venir à l’esprit serait de nous sommes déjà sur un minimum de la fonction dans la
suivre la ligne de plus grande pente (steepest descent ) : on direction r0 , donc :
suit une droite parallèle au gradient local de la fonction :
r1 · r0 = 0
~
grad(f )
δx = −α (4.15) ce que l’on vérifie facilement par le calcul.
~
kgrad(f )k À deux dimensions, l’on obtient donc les zizags de la
où α est un scalaire obtenu par exemple par la méthode figure 4.18 et avec un plus grand nombre de dimensions,
du paragraphe 4.7.3. ç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-
duire non pas le produit scalaire ordinaire x · y, qui est
bien adapté à une symétrie sphérique, mais le H-produit
scalaire adapté à la géométrie de H :
Fig. 4.18 – La « ligne de plus grande pente » dans une
vallée étroite. Il faut un grand nombre de pas pour at- x·H·y
teindre le fond de la vallée. Sans entrer dans les démonstrations20 ni dans le détail de
l’algorithme, il suffit alors de chercher une série de direc-
Il se trouve que c’est souvent assez peu efficace même
tions de recherches di qui soient H-orthogonales entre elles
si cela peut donner de bons résultats dans certains cas :
de telle façon que :
en effet, si l’on cherche un minimum au fond d’une vallée
étroite et si l’on part d’un bord de la vallée, on va partir xi+1 = xi + αi di
dans une série de zigzags plutôt inutiles (figure 4.18). 19 Parce que H ∂2 f ∂2 f
i,j = ∂x ∂x = ∂x ∂x = Hj,i , donc on se convainc
Pour trouver une meilleure solution, il faut étudier d’un i j j i

peu plus près la méthode de la plus grande pente : il s’agit aisément que x0 · H · r0 = r0 · H · x0 .
20 Volontiers confuses dans la littérature, en tous cas guère pas-
en fait d’une approximation de f par une fonction quadra- sionnantes. . . mais ce n’est qu’une opinion qu’il n’est pas obligatoire
tique : de partager ! On se reportera éventuellement à la référence [7].
Physique numérique, Philippe Depondt 65

en choisissant αi pour que la recherche donne un minimum or les dxi ne sont pas indépendants à cause de l’équation
sur la direction di , et (4.18) ; mais cette équation dit que g est une constante et
que donc sa différentielle doit être nulle :
di · H · dj = 0, ∀i 6= j
Xn
∂g
Il se trouve que contrairement aux apparences, on peut dxi = 0
i=1
∂xi
très bien se passer de la connaissance (et de l’espace
mémoire correspondant) de la matrice Hessienne en uti- ce qui introduit un lien entre les dx . Il suffit d’addition-
i
lisant le fait que les résidus ri doivent être justement les ner ces deux relations en multipliant la deuxième par un
gradients de f ! « multiplicateur de Lagrange » λ :
Moralité : une fois encore, ne pas chercher à réinventer
ce qui existe déjà, utiliser des sous-programmes de bi- X n  
∂f ∂g
bliothèque ! Ce qu’il faut retenir de ces méthodes, c’est +λ dxi = 0 (4.19)
i=1
∂xi ∂xi
qu’elles sont proches de la méthode de Newton déjà étudiée
pour la recherche de zéros et qu’elles ont les mêmes Choisissons alors, par exemple, λ pour que :
défauts. Ainsi, il s’agit toujours d’une recherche locale d’un
minimum d’une fonction assimilée à une fonction quadra- ∂f ∂g
+λ =0
tique qui ne possède qu’un seul minimum. La « vraie » ∂xn ∂xn
fonction n’est en général pas quadratique et si elle possède
plusieurs minima, on en trouvera au mieux un, sans savoir alors les n − 1 variables x1 , . . . , xn−1 sont indépendantes.
s’il n’y en a pas un nettement plus profond juste à côté ! La relation (4.19) est donc vraie pour tout jeu de variables
La méfiance et la circonspection sont les deux mamelles x1 , . . . , xn−1 , en particulier, si
du calcul numérique. . .
On verra toutefois, dans le chapitre 4.11, des façons dxi = 0, ∀i 6= k
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
4.7.5 Minimisation avec contrainte : les ∂xk ∂xk
multiplicateurs de Lagrange. une relation vraie pour tout k, puisqu’il a été choisi arbi-
Imaginons que l’on doive chercher comme auparavent trairement. C’est aussi vrai pour k = n puisqu’on a choisi
un minimum d’une fonction de n variables : λ ainsi : on retrouve ainsi la symétrie un instant perdue. . .
Le résultat de tout ceci est que si l’on définit la fonction :
min(f (x))
Q = f (x) + λg(x)
mais que les variables représentées par x ne soient pas
indépendantes mais reliées par une relation : le problème revient à chercher le minimum de Q avec
la contrainte (4.18), mais ce qui est nouveau par rap-
g(x) = 0 (4.18) 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-
c’est ce que l’on appelle une contrainte. Imaginons par siques.
exemple que l’on cherche la configuration d’équilibre d’un Prenons, par exemple, un système de pendules couplés
ensemble d’atomes mais que deux atomes donnés soient dont l’énergie potentielle s’écrit :
liés par une liaison très rigide, covalente par exemple, et
X 1 X
que la distance entre ces deux atomes soit connue. On a V =− mi gℓi cos θi + Cij (θi − θj )
2
ainsi un système de n − 1 variables indépendantes et l’on i
2 i,j>i
pourrait reécrire l’équation (4.18) :
avec des notations standards. Admettons que l’on cherche
xn = g̃(x1 , . . . , xn−1 ) l’équilibre d’un tel système (en dehors évidemment de la
solution triviale : certains angles peuvent être supérieurs
et l’on rechercherait le minimum d’une fonction à n − 1 à π) avec la contrainte que la somme des angles soit nulle
variables : (mettons qu’un système d’engrenages plus ou moins com-
plexe impose cela) :
min(f (x1 , . . . , xn−1 , g̃(x1 , . . . , xn−1 )))
X
Outre le fait que la recherche de la fonction g̃ n’est pas θi = 0
i
toujours facile, cette méthode est discutable en ce sens que
l’on a choisi d’éliminer la variable xn , mais pourquoi pas L’on écrira donc :
plutôt xn−1 ou xi ? Dans certains cas le choix est évident, X
dans d’autres non. Q=V +λ θi
Si l’on est à un extremum de f , alors pour tout ensemble i
de variations infinitésimales des xi on doit avoir :
et en exprimant les dérivées :
X n
∂f ∂Q
dxi = 0 =0
i=1
∂xi ∂xk
66 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

on obtient : Ainsi, cette théorie, si elle est juste, donne potentiellement

X également une information de type microscopique sur
λ = −mk gℓk sin θk − Ckk′ (θk − θk′ ), ∀k l’échantillon étudié : on aimerait bien savoir évidemment
k′ 6=k 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
soit en sommant :
  paramètre ajustable de la théorie parce qu’on n’en connait
pas la valeur a priori et l’on tentera donc d’ajuster ∆E aux
1 X X
λ=− mk gℓk sin θk − Ckk′ (θk − θk′ ) données expérimentales.
n Ainsi, il est important de comprendre que l’on est en
k k′ 6=k
train de poser, non pas une, mais deux questions dis-
que l’on peut réinjecter dans l’expression de Q pour faire tinctes :
ensuite une minimisation par l’une des méthodes habi-
1. est-ce la théorie marche ?
tuelles.
Tout ceci se généralise évidemment à un nombre quel- 2. quelles sont les valeurs (et les incertitudes) des pa-
conque de contraintes gℓ = 0, il suffit d’introduire autant ramètres ajustables ?
de multiplicateurs de Lagrange que de contraintes : Il se trouve que les logiciels courants répondent prati-
X quement toujours à la seconde question, mais pas à la
Q=f+ λℓ gℓ première : cela vaut donc la peine de regarder d’un peu
ℓ plus près comment ça marche !

4.8 Modélisation de données 4.8.1.2 L’hypothèse de départ.

expérimentales. En pratique, l’on relève, pour n points de mesures
{xi , i = 1, n}, les n valeurs {yi , i = 1, n} correspon-
Lorsqu’on fait des expériences, il est bien rare que dantes. Mettons que l’on ait une théorie qui donne y en
l’on n’utilise pas un logiciel d’acquisition et de traite- fonction de x et d’un certain nombre de paramètres ajus-
ment des données expérimentales. Ces logiciels proposent tables p1 , . . . , pm :
généralement des options intitulées par exemple smoo-
thing 21 ou curve fitting 22 ou least square fit 23 . L’objectif de y = f (x, p1 , . . . , pm ) = f (x, {pj })
ce chapitre est d’expliquer ce que font au juste ces options,
comment ça marche, et quelles sont leurs limites. En effet, Ce qui nous intéresse, ce sont les écarts entre les yi mesurés
il ne s’agit pas de magie, contrairement parfois à ce qu’il et les f (xi , {pj }) calculés à l’aide de la théorie. On définit
paraı̂t, mais de bons vieux algorithmes bien pédestres, fa- ainsi : n
X
ciles à comprendre et dont il vaut mieux connaı̂tre les hy- χ2 ({pj }) = (f (xi , {pj }) − yi )2
pothèses sous-jacentes et les petites manies, faute de quoi i=1
on a vite fait de faire dire à peu près n’importe quoi aux
On cherchera alors l’ensemble de paramètres {pj } qui
résultats d’expérience !
rendra χ2 le plus petit possible : c’est pour cela que
la méthode s’appelle « méthode de moindres carrés »,
4.8.1 Données et moindres carrés. puisque χ2 est la somme des carrés des écarts entre théorie
4.8.1.1 Quel est le problème ? et mesures.
On aurait pu choisir autre chose que la somme des carrés
Lorsqu’on fait une expérience, on mesure une grandeur des écarts, par exemple la somme des valeurs absolues ou
y en fonction d’une autre grandeur x, par exemple la pres- le sup des carrés. . . Le choix fait ici, ainsi que dans la
sion en fonction de la température p(T ), l’intensité lumi- quasi-totalité des programmes, repose sur une hypothèse
neuse en fonction de sa fréquence ou de sa pulsation I(ω), qu’il faut expliciter.
la position d’un objet en fonction du temps r(t). . . On peut Imaginons que l’on fasse un grand nombre de fois la
aussi bâtir une théorie qui prédise la loi y = f (x) et l’on mesure de y pour une même valeur de x : on ne trouvera
veut savoir si la théorie est juste : cette théorie repose sur pas la même valeur de y pour toutes les mesures mais
des hypothèses physiques qui sont ainsi validées ou non. une distribution parce que la mesure n’est pas parfaite, il
C’est ce qu’on appelle la modélisation, on fait entrer une y a des incertitudes, il y a des vibrations dans le sol, le
expérience dans le cadre d’un modèle. détecteur utilisé produit du bruit, l’électronique produit
En général, la loi issue de la théorie dépend aussi de également du bruit. . .
paramètres dits « ajustables ». Par exemple, on peut ima- L’hypothèse qui mène à l’expression de χ2 ci-dessus est
giner que si l’on mesure une pression de vapeur saturante, que cette distribution est gaussienne, centrée autour de y0
la pression puisse s’écrire en fonction de la température de avec un écart-type σ :
la façon suivante :
(y−y0 )2
∆E p(y) = e− 2σ2
P (T ) = P0 e− kT
à un coefficient de normalisation près24 . Il se trouve que
une loi d’Arrhenius où ∆E est l’énergie qu’il faut four-
pour un très grand nombre d’expériences, le théorème de la
nir pour arracher un atome à la surface de l’échantillon.
limite centrale (valable pour les grands nombres) impose
21 Lissage.
que cette condition soit vérifiée. Toutefois, il faut faire
22 Ajustement de courbe.
23 Ajustement de moindre carré. 24 √1 .
σ 2π
Physique numérique, Philippe Depondt 67

attention que des détecteurs très sensibles peuvent être On peut alors introduire le « facteur de confiance
capables de répondre à un nombre de « coups » très faible pondéré » ou weighed reliability factor :
pour lequel ce genre de théorème n’est plus valable. Les v
u
méthodes décrites ici ne sont alors plus en toute rigueur u χ2
directement utilisables. R w = u n
u X (f (xi , {pj }))2
t
i=1
σi2
4.8.2 Ajustement d’une fonction linéaire.
4.8.2.1 Sans les incertitudes. 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
Prenons pour commencer le cas le plus simple : y = exemple 10%, cela signifie en gros que la fonction théorique
ax + b où les deux paramètres ajustables sont a et b. On est éloignée de 10% des valeurs expérimentales, en unités
cherche donc a et b tels que de σ.
Xn Ce que l’on aimerait avoir, c’est l’incertitude sur a et b
2
χ2 = (axi + b − yi ) puisque ce sont les résultats de tous ces calculs. Posons :
i=1
ei = f (xi , {pj }) − yi
soit minimum. Il faut donc que les dérivées de χ2 par rap-
port aux deux paramètres soient nulles : c’est l’écart entre théorie et expérience pour le point i. Si
 n l’on estime que cet écart est entièrement dû au paramètre

 ∂χ
2 X
 2xi (axi + b − yi ) = 0 n˚ 1, on obtient
 ∂a =

i=1
Xn ∂ei ∂f (xi , {pj })

 ∂χ 2
ei = δp1 = δp1

 = 2 (axi + b − y i ) = 0 ∂p ∂p1
 ∂b 1
i=1
une majoration de l’incertitude δp1 sur le premier pa-
Quelques lignes de calculs sans difficulté donnent : ramètre, or
 n n n

 X X X n
X n 
X 2

 n x y − x yi 2 ∂f (xi , {pj }


i i i χ = e2i = )δp1

 i=1 i=1 i=1 ∂p1

 a = !2 i=1 i=1

 X n Xn

 2

 n xi − xi et en généralisant ceci à tous les paramètres pj :
i=1 i=1
Xn Xn Xn Xn v

 u


2
xi yi − xi yi xi u χ2

 δpj = u n

 i=1 i=1 i=1 i=1 u X ∂f (xi , {pj })

 b = !2 t

 X n X n
∂pj

 2

 n xi − xi i=1
i=1 i=1
C’est ce que l’on appelle « déviations standards estimées »
Lire dans un fichier les n valeurs de x et de y et faire ce (estimated standard deviations ou esd ) et ce sont des esti-
calcul pour obtenir l’équation de la droite est extrêmement mations de majorants aux incertitudes sur les paramètres.
simple (c’est d’ailleurs un petit exercice de programmation Dans le cas d’une fonction linéaire, évidemment, ces for-
conseillé25) : on comprend que les éditeurs de logiciels ne mules se simplifient aisément, mais elles s’appliquent26 aux
se privent pas de l’inclure dans leurs productions. 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 (f (xi , {pj }) − yi )2 fois par jour le temps écoulé depuis le début de l’expérience
2 et la masse indiquée par le pèse-lettre. Mettre ces données
χ ({pj }) = 2
i=1
σ i expérimentales dans un fichier.
-Étape n˚4 : faire une hypothèse physique. Puisque la
Dans le cas de la fonction linéaire cela s’écrit évidemment :
température du radiateur peut être considérée en première
Xn 2
(axi + b − yi ) approximation comme constante, la vitesse d’évaporation
χ2 = 2 de l’eau peut être considérée comme constante et donc
i=1
σi
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.
m(t) = ṁ t + m0
25 Il est prudent de travailler en double précision à cause des

dénominateurs. 26 On n’ose parler de validité !

68 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où, donc, ṁ et m0 sont des constantes. Ces nombres n’ont, bien sûr, aucun sens.
-Étape n˚5 : déterminer ṁ et m0 selon les méthodes Moralité : ce n’est pas parce qu’un programme d’ajuste-
ci-dessus, ainsi que les déviations standards. Tracer ment donne un résultat que le modèle est validé et que les
les courbes expérimentale et théorique sur un même paramètres qu’il donne sont bons.
graphe ainsi que les écarts entre courbe théorique et Il ne faut pas oublier d’être physicien : quand on ajuste
expérimentale. un modèle, c’est qu’on pense qu’il est adapté, puis on
-Étape n˚6 : s’interroger sur les résultats obtenus. doit discuter les valeurs obtenues pour les paramètres
-Étape n˚7 : changer la valeur affichée sur le thermostat et
en les considérant comme des grandeurs physiques et
recommencer l’expérience. en se posant par exemple la question des conséquences
-Étape n˚8 : tracer la courbe ṁ(T ) pour 253 < T < 333K. qu’entraı̂nent les valeurs obtenues. Si, par exemple, dans
le cas de la loi d’Arrhenius, on trouve ∆E ∼ 106 joules
4.8.2.4 Une généralisation possible. (au lieu de quelques eV), on est en droit de se demander
si l’on a bien mesuré de la sorte l’énergie pour arracher
Ces méthodes qui ont le grand mérite d’être simples et
un atome d’une surface comme on le pensait initialement.
faciles à programmer ne sont pas limitées strictement aux
fonctions linéaires. Reprenons l’exemple de la loi d’Arrhe-
nius : 4.8.3 Ajustement d’un polynôme.
∆E
P = P0 e− kT On peut généraliser facilement les équations du para-
Si l’on fait les changements de variable : graphe 4.8.2.1 au cas d’un polynôme de degré p :
p
X
1
y = ln P x=− P (x) = c0 + c1 x + c2 x2 + . . . + cp xp = cj xj
kT
j=0
on obtient
y = ∆E x + ln P0 On cherche, bien sûr, les p + 1 coefficients cj , et donc,
 !2 
où ∆E et ln P0 tiennent le rôle de a et b dans le problème p
X
précédent. Ainsi, si l’on peut exprimer le problème de la  n ck xki − yi 
∂χ2 ∂ X 
façon suivante :  k=0 
=  =0
g(y) = a h(x) + b ∂cj ∂cj  σi2 
 i=1 
où g et h sont des fonctions connues sans paramètre ajus-
table (ici, k est la constante de Boltzmann, connue), tout
ce qui est ci-dessus est utilisable sans difficulté. Il est aisé de se rendre compte que si l’on pose :
 Xn
4.8.2.5 Un caveat. 
 xj+k
i

 Ajk = 2
i=1
σ i
n
X yi xj



 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 :
Fig. 4.19 – L’ajustement d’une fonction linéaire à des
données aléatoires donne un résultat. Ici : 0.79875 − g(y) = P (h(x))
0.24841 × x. Quel sens donner à ces nombres ? Aucun !
où g et h sont des fonctions connues sont évidemment
Malheureusement, tout ceci est un peu trop beau. En possibles.
effet il suffit de considérer les équations de ce chapitre À condition de disposer d’un sous-programme de
pour constater que ces méthodes donneront toujours un résolution de systèmes linéaires, tout ceci est très simple à
résultat, si absurde soit-il. La figure 4.19 montre l’ajuste- programmer, ça marche très bien et c’est rapide car il n’y
ment d’une droite sur un nuage de points aléatoires. a pas à converger plus ou moins laborieusement vers une
On obtient des nombres. solution.
Physique numérique, Philippe Depondt 69

Alors, s’agit-il du programme « résout tout problème,

marche à tout coup » ? Poser la question est évidemment
un début de réponse.
Revenons au pot de yaourt du paragraphe 4.8.2.3.
Il est probable que l’ajustement d’une fonction linéaire
laissera des écarts entre cette fonction et les données
expérimentales : faut-il alors prendre un polynôme de
degré plus élevé ? Il est clair que l’ajustement en sera
meilleur : à la limite, si l’on prend un degré égal au nombre
de points moins un, p = n − 1, on obtiendra un polynôme
passant par tous les points expérimentaux ! Mais les coef-
ficients ainsi introduits ont-ils un sens physique ? Non !
Il faut d’abord se poser des questions physiques. Par
exemple, y a-t-il une raison pour laquelle le modèle choisi
ne conviendrait pas ? Comme le thermostat a un cycle de
24 heures car on chauffe moins la nuit, ne pourrait-on pas
plutôt introduire cette périodicité dans le problème ? On Fig. 4.20 – Un cosinus bruité, sa dérivée calculée avec
pourrait tenter quelque chose comme q = 3 et avec q = 10.

¯ + µ sin 2π t
ṁ = ṁ
τ Exercice : essayer de calculer ṁ(t) à partir des données
de mesure. On constatera qu’il faut choisir un intervalle
Évidemment, c’est plus difficile parce qu’il ne s’agit plus
de mesure sensiblement plus court que la durée des va-
d’un polynôme et il faudra recourir aux méthodes du para-
¯ riations quotidiennes de la température : l’idéal étant un
graphe 4.8.6, mais c’est peut-être plus réaliste, puisque ṁ
enregistrement toutes les heures par exemple.
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- 4.8.5 Lissage : a dirty trick !
tionnel à la pression laquelle obéit probablement à une loi Il arrive que les informations intéressantes d’une
d’Arrhenius en fonction de la température. . . expérience soient difficilement visibles sur la courbe
expérimentale obtenue à cause du bruit. La plupart des
4.8.4 Dérivée locale d’une courbe logiciels d’acquisition offrent des options de smoothing ou
expérimentale. lissage visant à réduire le bruit. Il s’agit d’ajuster locale-
ment un polynôme comme précédemment, par exemple un
On peut aussi prendre la question différemment : l’in- polynôme d’ordre 2 :
connue « intéressante » de l’expérience est la vitesse
d’évaporation ṁ : c’est cela que l’on cherche à mesurer. Lij = c2i δx2 j 2 + c1i δxj + c0i
On voudrait calculer la dérivée locale de la mesure et c’est
à cette grandeur là que l’on tentera d’appliquer quelque mais seul la valeur en xi de l’ajustement local nous
théorie. intéresse :
Il suffit d’ajuster localement une fonction linéaire : Li0 = c0i

f (x) = c1i x + c0i car on remplacera les xi par les valeurs lissées Li0 . À la
suite de calculs sans difficulté, on obtient, toujours par les
à condition de rester proche de xi . Le χ2 devient local mêmes méthodes :
autour du point xi : q
X
+q
X J y
4 i + (J4 − J2 k 2 )(yi+k + yi−k )
2
χ2i = (c1i xk+i + c0i − yi+k ) Li0 = c0i = k=1
(4.20)
k=−q J0 J4 − J22
où q détermine la largeur de l’intervalle autour de xi où ce où q
calcul est fait. Le coefficient c1i est donc la dérivée locale X
Jℓ = jℓ
recherchée : un calcul sans difficulté donne :
j=−q
+q
X
3 soit :
c1i = k yi+k q(q + 1)(2q + 1)
δx q(q + 1)(2q + 1) J0 = 2q + 1, J2 = ,
k=−q
3
dans le cas où xi = x0 + iδx 27 . Évidemment, le résultat q(q + 1)(2q + 1)(3q 2 + 3q − 1)
J4 =
que l’on trouve dépend de q : si l’on choisit une valeur 15
de q petite, le résultat risque d’être sensible au bruit, en (les Jℓ pour ℓ impair sont bien sûr tous nuls) et
revanche, si q est trop grand, on perdra les fluctuations
rapides (voir la figure 4.20). Il faut choisir autant que pos- q(q + 1)(2q + 1)2 (4q 2 + 4q − 3)
J0 J4 − J22 =
sible qδx < ∆x l’ordre de grandeur des variations que l’on 45
cherche à détecter. C’est encore extrêmement facile à programmer et ra-
P+q 2 q(q+1)(2q+1)
27 Il faut se rappeler au passage que
−q
k = 3
. pide à l’exécution. Il faut cependant réaliser que 1˚ le
70 Licence de physique L3 : Physique Fondamentale & PHYTEM,
résultat 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 hy-
pothèse sous-jacente très importante : c’est que les varia-
tions intéressantes sont de longueur d’onde ou de dimen-
sion caractéristique grande par rapport aux fluctuations
dues au bruit et donc à l’intervalle balayé dans l’équation
(4.20). C’est pour cela qu’il vaut généralement mieux, sauf
pour des raisons « cosmétiques » ne pas faire de lissage, et,
au contraire, ajuster une fonction physiquement justifiée
aux 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’ajus-
tement devrait la faire apparaı̂tre.
4.8.6 Ajustement non-linéaire.
Ce qui rend l’ajustement de polynômes si simple, c’est
que la dépendance d’un polynôme par rapport aux pa-
ramè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
n’est pas une fonction linéaire de x. En revanche, on peut
vouloir chercher à ajuster une fonction comme :
L0
L(x) =  2
x − x0
1+
γ
C’est une lorentzienne comme sur la figure 4.21 où, comme
le montre une analyse élémentaire, L0 est la hauteur de
la courbe, x0 la position de son maximum et γ sa demi-
largeur à mi-hauteur. Il est facile de montrer que la lo-
rentzienne est le module au carré de la transformée de
t
Fourier de eiωt− τ et donc la réponse spectrale des oscilla-
tions amorties, ce qui en fait une courbe très répandue en
spectroscopie, par exemple optique : la position du som-
met de la courbe donne la fréquence de l’oscillateur et sa
largeur, l’amortissement.
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
−5 0 5 10
Fig. 4.21 – Lorentzienne avec L0 = 1, γ = 0.5 et x0 = 2.
Les paramètres que l’on veut ajuster sont L0 , x0 et γ,
or L n’est linéaire ni en x0 ni en γ ; alors on linéarise le
problème en sachant que le résultat ne sera pas correct
mais en espérant qu’il sera moins mauvais que le point
de départ et l’on répète l’opération jusqu’à ce qu’une so-
lution acceptable soit trouvée. Il s’agit donc, une fois de
plus, de rechercher un minimum de χ2 en fonction de ses
paramètres, seulement, il n’y a plus de solution simple,
il faut utiliser une méthode du type Newton ou gradient
conjugué avec les précautions qu’imposent ces méthodes :
ce n’est pas parce que cela fait partie d’un logiciel tout fait
Université Pierre et Marie Curie Paris-6 & ENS-Cachan
que ces méthodes deviennent infaillibles, elles conservent
les défauts déjà vus. Si le point de départ de la recherche,
les paramètres initiaux, est trop éloigné d’une solution, le
résultat obtenu risque d’être absurde, si le modèle com-
porte un trop grand nombre de paramètres ajustables
(chaque paramètre ajoute une dimension à l’espace de re-
cherche) la signification du résultat final risque d’être assez
discutable. . .
Ainsi, lorsqu’on ajuste un modèle théorique à une
expérience, on est donc confronté à deux types de diffi-
cultés :
– la recherche du minimum de χ2 , il est parfois difficile
de se convaincre que le minimum trouvé est bien le
minimum de la fonction
– le fait que d’avoir trouvé le minimum de χ2 ne valide
en aucun cas le modèle utilisé.
Ces mises en garde ne doivent toutefois pas être vues
comme devant dissuader d’utiliser ces outils : il faut les
utiliser, ils sont d’une grande puissance ! Parfois, un ajus-
tement difficile ou qui paraı̂t donner des résultats douteux
est une indication qu’un autre modèle (pas forcément plus
compliqué, d’ailleurs) serait peut-être meilleur. Il faut sim-
plement se rappeler que l’ordinateur qui fait le calcul est
un serviteur puissant mais. . . stupide ! Au physicien de
faire son métier et de garder un regard critique.
Il existe, au reste, de bonnes habitudes qui peuvent ai-
der à éviter des mésaventures. La première est de tracer
sur un même graphe la courbe théorique et les résultats
expérimentaux pour voir si ça ressemble ! L’œil humain
est un bon juge en la matière. On peut pousser un peu
plus loin en traçant la courbe des écarts entre fonction
théorique et expérience : en principe, on ne devrait voir
que du bruit, c’est-à-dire un signal aléatoire, symétrique
par rapport à l’axe des abscisses. Si des zones où les écarts
sont systématiquement positifs ou négatifs apparaissent,
c’est peut être le signe qu’il y a là à chercher davan-
tage. On peut aussi refaire l’ajustement à partir de jeux
de paramètres initiaux différents : il vaudrait mieux que
le résultat final n’en dépende pas trop ! Si certains pa-
ramètres se retrouvent affectés d’une déviation standard
estimée très élevée (par exemple d’un ordre de grandeur
comparable au paramètre lui-même), on se demander s’il
est vraiment utile de le garder : ne pourrait-on pas ima-
giner 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 ?
Voici un exemple authentique : il s’agissait d’une
expérience de diffusion Raman, c’est-à-dire de diffusion
inélastique de la lumière. On éclairait un échantillon avec
de la lumière monochromatique de longueur d’onde connue
5145Å, et on analysait la lumière diffusée par l’échantillon
à l’aide d’un ensemble de réseaux. Le résultat expérimental
était l’intensité lumineuse en fonction de la pulsation
I(ω) et la courbe obtenue ressemblait à la figure 4.21
avec du bruit. On connaissait les propriétés du disposi-
tif expérimental et la théorie disait que le résultat devait
être le produit de convolution d’une lorentzienne par une
« fonction d’appareil » qui reproduisait les caractéristiques
du dispositif. L’ajustement donna, sans surprise, hauteur,
position et largeur de la lorentzienne. On traça alors la
courbe des écarts pour s’apercevoir qu’il y avait une bosse
systématiquement positive au pied de cette lorentzienne.
On tenta alors de reprendre l’ajustement avec d’autres pa-
ramètres initiaux, et/ou en bloquant à des valeurs « rai-
Physique numérique, Philippe Depondt 71

sonnables » l’un ou l’autre paramètre sans jamais réussir Il suffit d’ajouter une deuxième lorentzienne :
à réduire cette bosse. . . Finalement, l’on décida d’intro- f(x) = l1/(1+((x-x1)/g1)**2)+l2/(1+((x-x2)/g2)**2)
duire dans le modèle une deuxième lorentzienne, toujours x1 = 940 ; x2 = 950 ; l = 1000
convoluée avec la fonction d’appareil : le résultat devint fit f(x) ’lorentz.out’ u 1 :2 :(1) via l1, l2, x1,
excellent ! La lumière diffusée comportait donc deux pics x2, g1, g2
à deux fréquences différentes et non un : le premier était et l’on obtient :
2500
celui que l’on voyait à l’œil nu, le deuxième, beaucoup plus f(x)
’lo2’
faible en intensité, à une fréquence légèrement supérieure,
était caché dans le pied du premier : l’analyse attentive du 2000

résultat de l’ajustement avait seule permis de le détecter.

Restait évidemment à expliquer d’où il venait, ce deuxième
1500
pic. . . : il s’avéra qu’en fait le premier pic était dû à des im-
perfections du dispositif expérimental et que l’information
physique résidait dans le deuxième. 1000

500

Comme beaucoup d’autres programmes, le logiciel de tracé

de courbe gnuplot comporte une fonction fit qui permet de 0
900 920 940 960 980 1000
faire toutes sortes d’ajustements de fonctions à des données
sans avoir à écrire soi-même un programme. La syntaxe en avec les valeurs :
est assez simple, par exemple : l1 = 2019.76 +/- 8.07 ; l2 = 112.795 +/- 6.978 ; x1
fit a*x**2+b*x+c ’fichier’ via a,b,c = 940.013 +/- 0.02164 ; x2 = 953.61 +/- 0.4528 ; g1
permet d’ajuster un polynôme du deuxième degré aux = 4.96645 +/- 0.03408 ; g2 = 5.86099 +/- 0.7297
valeurs contenues dans un fichier. Implicitement, la première On peut même tracer les écarts entre la fonction théorique
colonne du fichier contient les valeurs de x, la deuxième et les données :
celles de y et la troisième celles des incertitudes sur y. Si ces plot "lorentz.out" using 1 :($2-f($1))
dernières sont inconnues ou constantes, on peut taper : 60

fit a*x**2+b*x+c ’fichier’ using 1 :2 :(1) via

50
a,b,c
ce qui fixe la valeur de cette incertitude uniformément à 1. 40

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

On peut faire des choses plus sophistiquées :

20
f(x) = l/(1+((x-x0)/g)**2)
x0 = 940 ; l = 1000 10

fit f(x) ’lorentz.out’ u 1 :2 :(1) via l, x0, g 0

On ajuste alors une lorentzienne à des valeurs contenues dans
-10
un fichier, en donnant des valeurs initiales à plusieurs va-
riables pour « aider » le programme. Pour tracer le résultat : -20

plot f(x), ’lorentz.out’ -30

ce qui donne la figure ci-dessous.
-40
l = 2007.89 +/- 14.49; x0 = 940.12 +/- 0.03819 ; g = 5.26853 +/- 0.05383 900 920 940 960 980 1000
2500
fonction
donnees

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

1500

4.9 Systèmes d’équations diffé-

1000 rentielles ordinaires.
Les physiciens sont extrêmement prolifiques lorsqu’il
500
s’agit de produire, à partir de problèmes divers, des
équations différentielles ordinaires (par exemple, les
0
900 920 940 960 980 1000
équations du mouvement de la mécanique newtonienne).
Malheureusement, l’inspiration manque parfois lorsqu’il
On observe une petite « bosse ». . . qu’à cela ne tienne ! Voir
la table 4.2.
s’agit de les résoudre, en particulier quand elles ne sont
pas linéaires : un petit programme de résolution numérique
Tab. 4.1 – Fit avec gnuplot peut alors s’avérer précieux.

4.9.1 Un exemple : les lignes de champ.

Admettons que l’on puisse calculer en chaque point ~r le
~ r ) dû à une distribution de charges et
Cette anecdote n’a rien d’exceptionnel : pratiquement champ électrique E(~
tout expérimentateur en a d’autres du même style à ra- que l’on en veuille tracer les lignes de champ. Une ligne
conter, ce genre d’aventure fait partie du métier ! de champ est définie par le fait qu’elle est en chaque point
72 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

parallèle au champ : 4.9.2 La méthode d’Euler.

~ r)
d~s // E(~ Soit donc, pour généraliser, un système de n équations
différentielles du premier ordre du type :
où le vecteur d~s est le vecteur élémentaire tangeant au
dyℓ
point ~r à la ligne de champ (figure 4.22) et s est l’abscisse = fℓ (x, {yp }), ∀ℓ ∈ [1, n]
curviligne sur la ligne de champ. dx
et l’on cherche à calculer numériquement les valeurs
ds des yℓ (x) en connaissant les expressions des dérivées
fℓ (x, {yp }) en fonction de x et de l’ensemble des yp (dans
l’exemple précédent, on avait les dérivées des coordonnées
d’un point sur la ligne de champ par rapport à l’abs-
cisse curviligne en fonction du champ, lui-même dépendant
de la position). Il faut alors fixer des conditions initiales
(0)
yℓ (x0 ) et un pas d’intégration fini dx et procéder pas à
Ligne de champ 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
Fig. 4.22 – Une ligne de champ fonctions est estimée à partir du résultat précédent (figure
4.23).
Si les coordonnées de d~s sont (dx, dy, dz), on obtient
évidemment en chaque point ~r :
dx dy dz ds
= = =
Ex Ey Ez E y (2) (3)
(1) (2) f
y f
(1) f
~ et E = kEk.
où, bien sûr, ds = kdsk ~ On aboutit alors
(0)
à un système de trois équations différentielles du premier f
(0)
ordre : y
dx Ex (~r)
=
ds E(~r) dx
dy Ey (~r)
=
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
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.
Il reste alors à intégrer pas à pas :
xn = xn−1 + dx
yn = yn−1 + dy
zn = zn−1 + dz
avec
Ex (xn−1 , yn−1 , zn−1 )
dx = ds
E(xn−1 , yn−1 , zn−1 )
Ey (xn−1 , yn−1 , zn−1 )
dy = ds
E(xn−1 , yn−1 , zn−1 )
Ez (xn−1 , yn−1 , zn−1 )
dz = ds
E(xn−1 , yn−1 , zn−1 )
c’est ce que l’on appelle la méthode d’Euler. Pour tracer
d’autres lignes de champ, il suffit de partir d’autres condi-
tions initiales et de recommencer. sants, mais elle a le défaut que les dérivées sont évaluées au
x0 x1 x2
Fig. 4.23 – La méthode d’Euler (ici à une dimension,
c’est-à-dire une seule équation différentielle) : on cal-
cule les dérivées en un point, on prolonge les fonctions
linéairement en ce point en utilisant les dérivées sur un
pas d’intégration fini dx ce qui donne un nouveau point
de départ d’où l’on peut recommencer.
Comme pour les problèmes d’intégrales, la difficulté est
évidemment le choix du pas d’intégration : la première
règle est évidemment qu’il doit être petit par rapport à une
distance de variation significative des fonctions étudiées.
Ici, une fois de plus, il ne faut pas oublier que l’on est
physicien : par exemple dans le cas des lignes de champ,
on peut tenter de tracer deux lignes très proches et vérifier
qu’elles ne se croisent pas. . .
4.9.3 La méthode d’Euler « améliorée »
ou méthode de Heun.
La méthode d’Euler donne souvent des résultats satisfai-
Physique numérique, Philippe Depondt 73

début de l’intervalle dx : il y a là une dissymétrie 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 retrouve
les questions abordées pour l’intégration dans le chapitre
4.3.2 par la méthode des rectangles, à gauche, à droite
ou centrés. La différence est qu’alors, on pouvait calculer
la fonction à intégrer n’importe où : ce n’est plus le cas
puisque les valeurs des fonctions sont les réponses que l’on
cherche justement. On ne connait que les dérivées en fonc-
tion des valeurs prises par ce que l’on cherche, puisque les
fℓ dépendent des yp : on tourne en rond !
d’Euler et obtenir de nouvelles valeurs des yp : on ne trou-
vera pas le même résultat puisqu’on n’utilise pas les mêmes
dérivées, il ne s’agit toujours que d’estimations. Cela per-
met d’obtenir une troisième estimation de dérivées. Cette
troisième estimation est utilisée pour faire un pas complet,
cette fois-ci, d’Euler, toujours à partir du même point de
départ : quatrième estimation des yp et des dérivées. . .
(4)
(2) (3)

(1)
(3)
y(x) première estimation de la dérivée (2)
deuxième estimation

y(x+dx)

moyenne des 2 dérivées

dx/2
x x+dx dx

Fig. 4.24 – Méthode d’Euler améliorée

Fig. 4.25 – Les quatre évaluations de la dérivée dans la
Ce que l’on aimerait faire, c’est une estimation de la méthode de Runge-Kutta d’ordre 4.
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 à Il reste alors à faire une moyenne pondérée de ces
la fin de l’intervalle : quatre estimations en faisant compter celles du milieu
deux fois plus et faire enfin un pas de longueur dx. Le
(k−1) (k)
f ℓ (xk−1 , {y p }) + f ℓ (xk , {y p }) sous-programme correspondant est très simple :
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
! sous programme de resolution d’equations !
une première estimation à l’aide de la méthode d’Euler ! differentielles du premier ordre par la !
précédente ; puis on applique l’équation (4.21) pour ob- ! methode de Runge-Kutta !
tenir la dérivée au demi-pas et enfin on peut utiliser de ! x = abscisse !
nouveau la méthode d’Euler avec cette dérivée corrigée ! 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
integer , intent(in) :: n
d’intégration deux fois plus grand.
real, dimension(n), intent(inout) :: y
real , intent(in) :: x, dx
4.9.4 La méthode de Runge-Kutta ! d1, d2, d3, d4 = estimations des derivees
d’ordre 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 uti- real :: ddx, c = 1.0/6.0
lisé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
call deriv(x+ddx,yp,d2,n); yp=y+d2*ddx
estimation des dérivées à l’aide d’une moyenne de 4 esti-
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 -Exercice : vérifier que le programme ci-dessus fait bien
au demi-pas : cela permet de calculer de nouvelles valeurs ce qui est annoncé. . .
des dérivées (figure 4.25). On revient au point de départ et Pour utiliser ce sous-programme, il faut un programme
l’on utilise ces nouvelles dérivées pour refaire un demi-pas principal qui fasse une boucle sur x et qui gère les entrée-
74 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

sorties et un autre sous-programme qui contient la phy- Un autre exemple célèbre est l’équation de Schrödinger
sique du problème, soit le calcul des dérivées : dans le cas dépendant du temps : si l’on ne fait pas très attention, on
des lignes de champ, il doit calculer les composantes du obtient que la norme de la fonction d’onde diverge expo-
champ, sa norme et faire les rapports. nentiellement avec le temps, ce qui est fâcheux !
Cela ressemble certes à une recette de cuisine, mais Dans les deux cas, la méthode de Cranck et Nicholson
c’est un des chevaux de bataille des physiciens : c’est une peut être une solution.
méthode remarquablement efficace ! Une illustration en est Si l’on revient à la méthode d’Euler, la critique qui en
donnée figure 4.26. avait été faite était qu’elle est dissymétrique :
(k+1) (k) (k)
yℓ = yℓ + fℓ (xk , {yℓ′ })dx
la variation des fonctions étant entièrement calculée à par-
tir des valeurs des dérivées au début de l’intervalle : on
pourrait tout aussi bien faire le même calcul en utilisant
les dérivées à la fin de l’intervalle :
(k+1) (k) (k+1)
yℓ = yℓ + fℓ (xk+1 , {yℓ′ })dx
La méthode de Heun faisait une estimation des dérivées
en fin de l’intervalle par la méthode d’Euler, mais il y a
là encore une part d’arbitraire : on peut remarquer tou-
tefois que l’équation ci-dessus est une équation implicite,
(k+1)
les inconnues yℓ figurant dans le deuxième membre ;
il faut donc résoudre un système d’équations (en général
non-linéaires) :
(k+1) (k) (k+1)
yℓ − yℓ − fℓ (xk+1 , {yℓ′ })dx = 0

c’est une recherche de zéro qui peut être faite par la

méthode de Newton déjà vue (§4.5.3). Cette méthode est
appelée la méthode d’Euler implicite mais elle n’apporte
guère par rapport à la méthode d’Euler explicite déjà vue
Fig. 4.26 – Lignes de champ d’un système de trois charges -elle est tout aussi dissymétrique- sinon qu’elle est sensi-
calculées à l’aide de la méthode de Runge-Kutta d’ordre blement plus compliquée !
4. La méthode de Cranck et Nicholson est une moyenne
entre la méthode d’Euler explicite et la méthode d’Euler
implicite, qui rétablit ainsi la symétrie à la manière de la
méthode de Heun, mais de façon plus rigoureuse :
4.9.5 La méthode de Cranck et Nicholson  
(k) (k+1)
Même la méthode de Runge-Kutta, malgré toutes f ℓ (x k , {y ℓ ′ }) + f ℓ (xk+1 , {y ℓ ′ })
(k+1) (k)
yℓ = yℓ + dx
ses qualités, ne donne pas toujours entière satisfaction. 2
Un exemple classique et le modèle proies-prédateurs de (k+1)
Volterra-Lotka28. Le nombre x de proies croı̂t au cours du ce qui donne à résoudre en yℓ′ :
temps d’un coefficient a mais diminue proportionnellement  
(k) (k+1)
au nombre de prédateurs y : f ℓ (xk , {y ℓ ′ }) + f ℓ (x k+1 , {y ℓ ′ })
(k+1) (k)
yℓ − yℓ − dx = 0
2
dx (4.22)
= x (a − by)
dt C’est une méthode assez lourde puisqu’il faut résoudre
un système non-linéaire d’équations (4.22) par la méthode
De même, le nombre de prédateurs décroı̂t d’un taux c à de Newton, ce qui suppose de calculer la matrice ja-
cause de la mortalité, mais croı̂t proportionnellement aux cobienne des dérivées partielles et un programme de
ressources disponibles en proies, soit : résolution de systèmes linéaires appelé itérativement en
dy espérant que les solutions trouvées accepteront de conver-
= y (−c + d x) ger. Il s’agit cependant d’un moyen puissant pour se tirer
dt
de situations délicates, à garder donc dans ses archives au
On démontre que les solutions de ce système d’équations cas où !
sont périodiques au cours du temps : un bon test est donc
de vérifier la périodicité du résultat numérique obtenu en 4.9.6 Équations d’ordre supérieur à 1.
traçant, par exemple, y en fonction de x afin de voir si
la trajectoire obtenue repasse toujours au mêmes endroits Pour le moment, on s’en est tenu à des systèmes
(voir la figure 4.27). . . ce qui n’est, bien sûr, jamais par- d’équations d’ordre un : en fait, c’est beaucoup moins res-
faitement obtenu ! trictif que cela en a l’air. Soit par exemple, une équation
28
du deuxième ordre :
voir par exemple :
http ://perso.univ-rennes1.fr/gregory.vial/agreg/cplt/ d2 y dy
volterra.pdf. +a =f
dx2 dx
Physique numérique, Philippe Depondt 75

temps dans le sous-programme de calcul des forces ; il est

vital d’optimiser ces calculs là. Or, ce n’est sans doute pas
une très bonne idée, dans ce cas là, d’utiliser un algorithme
comme Runge-Kutta30 qui exige quatre estimations des
forces par pas de calcul !
L’algorithme de Verlet est une réponse très simple à ce
problème :

 dt dt f ({~r ′ (t)})
 ~vℓ (t + ) = vℓ (t − ) + ℓ ℓ dt
2 2 mℓ

 ~r (t + dt) = ~r (t) + ~v (t + dt )dt
ℓ ℓ ℓ
2
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-
prime la dissymétrie qui était génante dans la méthode
d’Euler.
Fig. 4.27 – Vérification de la périodicité du problème de Cette méthode est fort utilisée sous des formes diverses
Volterra-Lotka résolu par la méthode de Cranck et Nichol- dès que l’on s’intéresse à la dynamique de systèmes com-
son. portant un grand nombre de particules (de quelques di-
zaines à quelques dizaines de milliers. . .).
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

 dy l’a vu, le pas d’intégration est non-nul, il est petit, certes,
 =z
dx mais il n’est pas nul. « Il n’y a qu’à » le choisir as-
 dz = f − az
 sez petit. . . Ce n’est, hélas, pas toujours aussi simple :
dx si on le choisit trop petit, on multiplie le nombre des
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
tion de la norme de la fonction d’onde pour l’équation de
ordre 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~rp analytique (un système linéaire, par exemple) et vérifier
2
= f~ℓ ({~rp , }), ∀ℓ ∈ [1, n] que le calcul numérique donne bien le même résultat, ou
dt 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 de la section 3.2. 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éaction29, 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)
l’expérience prouve que le programme va passer 99% du = = x (r(1 − x) − 1)
dt dt
29 f~ ′ = −f~ℓℓ′ . 30 sans parler de Cranck-Nicholson. . .
ℓ ℓ
76 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Il s’agit d’une équation différentielle qui se résoud analyti- Heun et Runge-Kutta, l’application est facile : il suf-
quement à la main avec un peu de travail31 , ou alors grâce fit de décomposer l’équation du deuxième ordre en deux
à un logiciel de calcul formel, et l’on obtient : équations du premier ordre, en introduisant une variable
supplémentaire v :
(r − 1)x0
x(t) =
rx0 + (r(1 − x0 ) − 1) e−(r−1)t ẋ = v
v̇ = − sin x
où x0 = x(t = 0). Pour r > 1, cette expression converge
exponentiellement vers son point fixe : plus de chaos ! Pour Cranck-Nicholson, il y a un peu plus de travail ;
On obtient donc un énorme changement qualitatif (figure soient, pour simplifier les notations, x = x(t) et v = v(t)
4.28)32 . x+ = x(t + δt) et v + = v(t + δt). Cela s’écrit :
1
v + v+
x+
dt=1
0.9 continu = x+ δt
2
0.8
sin x + sin x+
0.7 v+ = v− δt
0.6
2
0.5 où x+ et v + sont les inconnues. On a donc deux fonction
x

0.4 dont on doit chercher le zéro par une méthode de Newton :

0.3

0.2 v + v+
f (x+ , v + ) = x − x+ + δt
0.1 2
0 sin x + sin x+
0 5 10 15 20 25 30 35 40 45 50 g(x+ , v + ) = v − v+ − δt
t 2
Fig. 4.28 – Résolution numérique avec dt = 1 et résolution On doit appliquer à x+ et v + des variations dx+ et dv + de
analytique de l’équation logistique pour r = 4 : qui a rai- façons à ce que ces fonctions s’annulent, c’est-à-dire que
son ? df = −f et dg = −g ; or, en linéarisant, comme d’habitude

Le calcul numérique est-il donc faux ? Cela dépend du ∂f ∂f

df = +
dx+ + + dv +
modèle. Si l’on considère qu’il n’y a pas de saison et que le ∂x ∂v
taux de reproduction des insectes dépend instantanément ∂g ∂g
dg = dx + + dv +
+
de la population à l’instant t, alors c’est le calcul avec le ∂x+ ∂v
temps continu qui est correct. Si, au contraire, on considère ∂f ∂g
que le taux de reproduction des insectes dépend de l’état Les dérivées sont aisées à calculer : +
= = −1,
∂x ∂v +
de la génération précédente au moment de la ponte et donc ∂f δt ∂g + δt
de la façon dont elle a pu se nourrir l’année précédente, ∂v + = 2 et ∂x+ = − cos x 2 . Cela donne, tous calculs
alors c’est le pas d’intégration d’un an qui est correct. faits :
Au physicien - averti, bien sûr -, donc, de choisir son
modèle en connaissance de cause et de faire ses choix en f + g δt
dx+ = 2

2
conséquence ! 1 + cos x+ δt 2
dx+ − f
dv + =
4.9.9 Quelle méthode choisir ? δt
2

Comme chaque fois que l’on dispose de plusieurs Le programme qui fait tout cela et calcule la variance de
méthodes pour résoudre un problème se pose la question : l’énergie en fonction du pas de temps peut s’écrire :
laquelle choisir ? Il serait bien sûr tellement agréable de
pouvoir répondre de façon univoque et définitive ! C’est, program pendule
hélas, trop demander. implicit none
integer, parameter :: n = 2
À titre indicatif, on a tenté de comparer les méthodes
real, dimension(n) :: theta
exposées ci-dessus dans le cas d’un pendule simple, dont real :: t, dt, tmax
l’équation du mouvement s’écrit : double precision :: e, em, e2m, e0
integer :: nstep, step, it
ẍ = − sin x character (len=1) :: ode
external :: d
où x est l’angle que fait le pendule avec la verticale.
Comme il s’agit d’un système non-dissipatif (sans force write(*,’("Runge-Kutta, Euler, Heun, Verlet, &
de frottement), l’énergie doit rester constante ; ainsi la & Cranck-Nicholson ? ")’,advance=’no’)
variance de l’énergie au cours d’une simulation devrait read(*,*) ode
être nulle : voilà donc un test pour mettre ces algo- open(1, file = ’pendule.var’)
rithmes à l’épreuve. Pour les méthodes d’Euler, Verlet, tmax = 157. ! 25 periodes
do it = -24, 4 ! boucle sur la valeur du
31 On a dt = 10.**(0.25*it) ! pas de temps
peut faire le changement de variable x(t) = b+cy(t) où a, b
et c sont des coefficients à déterminer et y(t) la nouvelle variable. nstep = nint(tmax/dt)
32 Voir H. Krivine, J. Treiner, A. Lesne, soumis Am. J. Phys. em = 0. ; e2m = 0.
Physique numérique, Philippe Depondt 77

theta(1) = 1.5 ; theta(2) = 0. ! cond. init. real, dimension(n), intent(inout) :: y

e0 = theta(2)**2*0.5 - cos(theta(1)) real :: ddx, c= 1.0/6.0
do step = 1, nstep ! boucle sur le temps real, dimension(n) :: yp, k1, k2, k3, k4
t = step*dt ddx = 0.5*dx
select case (ode) call deriv(x ,y ,k1,n) ; yp = y+ddx*k1
case(’R’) call deriv(x+ddx,yp,k2,n) ; yp = y+ddx*k2
call rk4(t, theta, dt, n, d) call deriv(x+ddx,yp,k3,n) ; yp = y+dx*k3
case (’E’) call deriv(x+dx ,yp,k4,n)
call euler(t, theta, dt, n, d) y = y+dx*( k1 + 2.0*k2 + 2.0*k3 + k4 )*c
case (’H’) end
call heun(t, theta, dt, n, d)
case(’V’) subroutine cranck(t,y,dt,n,deriv)
call verlet(t, theta, dt, n, d) implicit none
case(’C’) integer , intent(in) :: n
call cranck(t, theta, dt, n, d) real , intent(in) :: t, dt
case default real, dimension(n), intent(inout) :: y
stop double precision :: x, v, xp, vp, dx, dv, f, g, &
end select dth, eps = 1.e-8
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))
end
La figure 4.29 montre le résultat de ces calculs et la table
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,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) Fig. 4.29 – Variance de l’énergie d’un pendule simple

implicit none 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
On constate d’abord que la méthode de Verlet, pour
real, dimension(n) :: dy
une durée d’exécution identique à celle d’Euler et un effort
call deriv(x,y,dy,n)
y(2) = y(2) + dy(2)*dx ; y(1) = y(1) + y(2)*dx de programmation mineur, permet de gagner un ordre de
end grandeur dans le pas d’intégration et plusieurs ordres de
grandeur de précision : Euler paraı̂t donc à rejetter sans
subroutine rk4(x,y,dx,n,deriv) hésitation ! La méthode de Heun permet une amélioration
implicit none sensible des résultats par rapport au deux précédentes,
integer , intent(in) :: n mais Runge-Kutta fait encore nettement mieux puisqu’on
real , intent(in) :: x, dx gagne à peu près un ordre de grandeur pour le pas de
78 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Euler 2mn 8s 4.10.1 La transformée de Fourier en phy-

Verlet 2mn 10s sique.
Heun 3mn 2s
Runge-Kutta 5mn 34s Au début du XIXe siècle, en 1822, le baron Joseph
Cranck-Nicholson 2mn 57s Fourier34 , dans sa Théorie analytique de la chaleur, uti-
lisa pour résoudre la relation qui porte son nom (φ ~ =
Tab. 4.3 – Durées d’exécution du programme ci-dessus −κ grad ~ T , le flux de chaleur est proportionnel au gra-
pour les différentes méthodes (sur un PC). dient de température) des développements sur une base
de sinus et de cosinus : les séries de Fourier. En notations
complexes35 : X
temps pour une durée d’exécution à peine deux fois plus f (t) = cℓ e−2πiℓνt (4.23)
grande. Quant à Cranck & Nicholson, elle se situe à peu de ℓ
choses près dans la même gamme de qualité que Heun, au
ou en développant l’exponentielle :
prix d’un effort de programmation nettement supérieur.
X
Ainsi, la méthode de Runge-Kutta offre un rapport qua- f (t) = aℓ cos(−2πℓνt) + ibℓ sin(−2πℓνt)
lité-prix excellent ce qui explique son succès auprès des ℓ
physiciens !
Il convient toutefois de nuancer assez nettement ce où les coefficients aℓ et bℓ sont complexes, ou encore en
verdict : dans le problème ci-dessus, l’amplitude des os- décomposant les coefficients cℓ en module et phase :
cillations a été choisie forte. Si l’on choisit de faire le X
même calcul pour des amplitudes plus faibles, les résultats f (t) = kcℓ k eiϕℓ e−2πiℓνt
ℓ
changent : en particulier, Cranck & Nicholson ne fait alors X
guère mieux qu’Euler (ce qui confirme que cette méthode = kcℓ k ei(−2πℓνt+ϕℓ )
est à réserver aux cas difficiles) ! Si, au lieu d’un pendule, ℓ
on en avait eu 1000, couplés entre eux, il est fort probable
que la méthode de Verlet aurait sensiblement amélioré son Ce genre de développement1 est limité aux fonctions
score. . . périodiques de période τ = ν , mais on peut généraliser
en considérant que la fréquence, au lieu d’être limitée à ν
La conclusion de tout ceci est que, sauf raison contraire et à ses harmoniques 2ν, 3ν, . . ., ℓν,. . ., varie continûment,
a priori, dans la plupart des cas, la méthode de Runge- ainsi la somme de l’équation (4.23) devient une intégrale :
Kutta est un excellent point de départ, mais pour des
Z ∞
systèmes du second ordre sans frottement pour lesquels
les temps de calcul des dérivées est grand (typiquement f (t) = F (ν) e−2πiνt dν (4.24)
−∞
quelques milliers d’atomes en interaction), Verlet est sans
doute un meilleur choix. Ces remarques ne doivent tou- et inversement :
tefois en aucun cas servir de prétexte pour se dispenser Z ∞
de tests sérieux pour chaque tentative particulière : caveat F (ν) = f (t) e2πiνt dt
33
emptor . −∞

où la fonction F (ν) est la transformée de Fourier de f (t),

L’imagination des numériciens et des mathématiciens
f (t) est la transformée de Fourier inverse de F (ν). La fonc-
appliqués concernant la résolution d’équations différen-
tion f (t) n’a plus de raison d’être périodique.
tielles ordinaires paraı̂t infinie : la littérature sur la
Dans l’équation (4.23), le coefficient complexe cℓ donne
question est surabondante. En particulier, toutes les
le poids et la phase du terme d’ordre ℓ du développement,
méthodes à pas variable qui permettent d’adapter en
c’est-à-dire de la contribution de fréquence ℓν : la même
cours de calcul la longueur du pas d’intégration sont
note (c’est-à-dire un son de même fréquence fondamentale)
complètement ignorées ici. Se reporter au besoin à la
jouée sur un clavecin et sur un piano ne produit pas le
littérature, par exemple, la référence [19] dans la biblio-
même son, c’est que la suite des cℓ n’est pas la même.
graphie.
Dans l’équation (4.24), le terme F (ν) donne de la même
façon le poids et la phase de la contribution de fréquence
ν du signal temporel : il s’agit d’une décomposition en
4.10 Transformées de Fourier ra- fréquences.

pides. 4.10.1.1 Un exemple : le paquet d’ondes.

Dans ce chapitre, nous verrons de façon aussi concrète Imaginons, par exemple, que l’on allume une lumière
que possible ce qu’est une transformée de Fourier pour à l’aide d’un interrupteur à un instant t0 − τ2 et que la
un physicien, sans que cela remplace un cours plus for- maintienne allumée pendant un temps τ , puis on l’éteint.
mel, puis l’on étudiera ce qu’en font les logiciels et sous- 34 À ne pas confondre avec Charles Fourier, philosophe, auteur de
programmes de transformée rapide afin de tenter de saisir l’utopie sociale fouriériste et des phalanstères.
la puissance mais aussi les limites de cet outil extraordi- 35 On peut considérer, pour se fixer les idées, t comme un temps

naire. et ν comme une fréquence, mais les relations données ici sont plus
générales : coordonnées spatiales et vecteur d’onde, par exemple,
sont susceptibles du même traitement, c’est d’ailleurs le cas pour la
33 « Que l’acheteur ouvre l’œil ». relation de Fourier.
Physique numérique, Philippe Depondt 79

Mettons, pour simplifier, que la lumière soit monochroma- durée du paquet d’onde devient petite, la distribution des
tique de fréquence ν0 . On a ainsi produit une onde plane fréquences s’élargit jusqu’à devenir infinie.
interrompue, pour ainsi dire de durée finie, dont l’ampli- Concrètement, si en actionnant à la main un inter-
tude peut s’écrire, au point ~r = 0 : rupteur, l’on allume une lumière ou un laser, puis on
 l’éteint une seconde plus tard, la largeur de la distribu-
E(t) = E0 e−2πiν0 t si t0 − τ2 < t < t0 + τ2 tion de fréquences sera de l’ordre de 1Hz ; or la fréquence
E(t) = 0 sinon de la lumière visible est plutôt dans le domaine des
1014 Hz : l’élargissement en fréquences est complétement
La transformée de Fourier d’un tel signal donne, à la négligeable, le paquet d’ondes peut être considéré comme
suite d’un petit calcul : infini sans inconvénient, c’est d’ailleurs l’approximation
Z t0 + τ2 habituelle en optique. En revanche, si l’on choisit d’utiliser
E0 e2πi(ν−ν0 )t dt = un laser à impulsions, chaque impulsion37 durant quelques
t0 − τ2 centaines de femtosecondes38 (ça s’achète dans le com-
merce), la largeur spectrale est de l’ordre de 1013 Hz ce
E0 τ e2πi(ν−ν0 )t0 sinc π(ν − ν0 )τ (4.25) qui n’est plus du tout négligeable comme le montrera le
donc, essentiellement un sinus cardinal36 représenté sur la cours d’optique.
figure 4.30. Ces considérations ne se limitent bien sûr pas à l’op-
tique : un instrument de musique capable de « tenir »
1 une note, comme un orgue, un violon ou une trompette,
0.8 produira un son dont la hauteur ou la fréquence est bien
0.6 définie, alors que pour une percussion, timbale ou tam-
0.4 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
maine des communications, en général, on utilise une onde
−0.2 porteuse d’une certaine fréquence : il faut que la durée
−0.4 des impulsions qui codent l’information soit relativement
−0.6 longue par rapport à la période de la porteuse afin d’éviter
−0.8 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 2 4 6 8 10 de la transmission.
frequences
1
0.9 4.10.1.2 Quelques propriétés importantes.
0.8 4.10.1.2.1 Notations. La notation utilisée jusqu’ici
0.7 prend la convention temps-fréquence, or on pourrait tout
0.6 aussi bien éviter le facteur 2π grâce à la pulsation ω =
0.5 2πν : Z ∞
0.4 F (ω) = f (t) eiωt dt
−∞
0.3
et Z ∞
0.2 1
f (t) = F (ω) e−iωt dω
0.1 2π −∞
0
0 2 4 6 8 10 Évidemment, le changement de variable introduit le fac-
frequences teur de 1/2π dans la transformée inverse. Les notations
sont parfois diverses : il arrive de√trouver ce facteur réparti
Fig. 4.30 – Transformée de Fourier d’une onde plane in- équitablement sous forme de 1/ 2π dans les expressions
terrompue : en haut partie réelle de l’équation (4.25) pour de la transformée directe et inverse, ou purement et sim-
ν0 = 5, τ = 1 et t0 = 10. En bas, module au carré (i.e. plement supprimé. . . Il est vrai que cela n’a guère d’impor-
produit par son complexe conjugué) de la même chose : tance puisqu’il ne s’agit « que » d’un facteur multiplicatif !
c’est ce que l’on appelle le « spectre ». On a raisonné ici en termes de temps et de fréquence
mais rien n’oblige à ce que t soit un temps : il peut très bien
On constate que l’onde plane interrompue, au lieu de s’agir d’une coordonnée spatiale z et dans ce cas, on rem-
n’avoir qu’une fréquence bien définie ν0 comme une onde placera la pulsation par le vecteur d’onde k = 2π λ où λ peut
plane infinie, s’étale sur tout un spectre de fréquences. Ce être considéré comme une longueur d’onde, par exemple,
spectre est centré sur ν0 , la fréquence de l’onde plane de si ρ(z) est la densité électronique dans un matériau :
départ. Le premier zéro du sinus cardinal donne une esti- Z ∞
mation de la largeur du spectre : on trouve ν − ν0 = ± τ1 . S(k) = ρ(z) eikz dz
Ainsi, si la durée τ du paquet d’ondes devient grande jus- −∞
qu’à tendre vers l’infini, le spectre de fréquence se resserre la quantité S(k) s’appelle le facteur de structure et c’est
autour de ν0 jusqu’à ne plus comporter que la fréquence ce que l’on mesure (ou du moins son module au carré)
ν0 : on retrouve l’onde plane infinie. Au contraire, si la
37 Ou pulse en bon franglais.
36 sinc x sin x 38 1fs=10−15 s.
= x
.
80 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

lors d’expériences de diffraction de rayons X : c’est une c’est que l’onde plane infinie a une distribution spectrale
grandeur d’une considérable importance en physique de la qui ne comporte qu’une seule fréquence.
matière condensée : à partir de la connaissance du facteur La distribution de Dirac est parfois fort utile, si , par
de structure, on peut remonter39 à la densité électronique, exemple, on a une distribution de charge ρ(z) qui ne com-
et en admettant que les électrons se situent à proximité porte qu’une charge ponctuelle q située en z0 , on peut
des noyaux, la structure atomique du matériau considéré. écrire :
C’est donc un moyen très puissant d’investigation de la ρ(z) = q δ(z − z0 )
matière.
De façon plus générale, les mathématiciens ne se et introduire ceci sans arrière-pensée dans les intégrales
préoccupent pas toujours du sens physique des variables et transformées de Fourier que l’on choisira afin d’utiliser
utilisées pour s’intéresser à l’objet mathématique « trans- tous les théorèmes habituels.
formée de Fourier » qui peut s’écrire : La distribution de Dirac permet également de vérifier
Z ∞ que l’expression de la transformée de Fourier inverse
ϕ(u) = f (x) eiux dx donnée au début de ce chapitre est correcte : il suffit d’in-
−∞ jecter l’expression :
et la transformée inverse : Z ∞
Z ∞ F (ν) = f (t) e2πiνt dt
1
f (x) = ϕ(u) e−iux du −∞
2π −∞
dans l’équation (4.24) :
4.10.1.2.2 La distribution de Dirac. Intuitive- Z ∞ Z ∞ 
ment, il s’agit d’une « fonction »40 δ(x) qui vaut zéro par- f (t) =
′
f (t′ ) e2πiνt dt′ e−2πiνt dν
tout sauf en x = 0 où. . . elle est infinie. Soit une fonction −∞ −∞
Z ∞ Z ∞
f (x), alors, la propriété fondamentale de la distribution ′

de Dirac est : = f (t ′
) e2πiν(t −t) dν dt′
−∞ −∞
Z ∞
f (x) δ(x) dx = f (0) après inversion de l’ordre des intégrations. L’intégrale sur
−∞ ν donne δ(t′ − t) et finalement :
ou bien à l’aide d’un changement de variable trivial : Z ∞
Z ∞ f (t) = f (t′ ) δ(t′ − t) dt′
−∞
f (x) δ(x − x0 ) dx = f (x0 )
−∞
ce qui est vrai.
Si l’on applique ceci à la transformée de Fourier, on
obtient : Z ∞ 4.10.1.2.3 Linéarité. La transformée de Fourier est
δ(x) eiux dx = 1 une transformation linéaire : il est facile de se convaincre
−∞
que la transformée de Fourier d’une somme est la somme
la transformée de Fourier d’une Dirac est une constante des transformées de Fourier et que la transformée de Fou-
(un, en l’occurence) : c’est le cas extrême du paquet rier d’une fonction multipliée par une constante est le pro-
d’ondes infiniment court : sa largeur spectrale est infinie, duit de la transformée de Fourier par cette constante,
sa transformée de Fourier non seulement infiniment large Z Z ∞ Z ∞
∞
mais constante.
(f (x) + g(x)) eiux dx = f (x) eiux dx + g(x) eiux dx
Inversement, −∞ −∞ −∞
Z ∞
1 et
C e−iux dx = C δ(x) Z ∞ Z ∞
2π −∞
Cf (x) eiux dx = C f (x) eiux dx
−∞ −∞
la transformée de Fourier d’une constante est la distribu-
tion de Dirac. On peut s’en convaincre en remarquant que, Cela est vrai bien sûr aussi pour les transformées in-
tant que x est non nul, l’intégrale s’effectue sur un nombre verses. Les propriétés suivantes sont tout aussi faciles à
infini de périodes des cosinus et sinus de l’exponentielle démontrer :
complexe, or, bien évidemment : Si. . . alors. . .
Z 2π Z 2π f (x) est réel ϕ(−u) = [ϕ(u)]∗
f (x) est imaginaire pur ϕ(−u) = −[ϕ(u)]∗
sin x dx = cos x dx = 0
0 0 f (x) est paire ϕ(u) est paire
f (x) est impaire ϕ(u) est impaire
et le résultat final est nul. En revanche, quand x = 0, f (x) est réelle et paire ϕ(u) est réelle et paire
l’exponentielle vaut 1 et le résultat est infini. Si donc, la f (x) est réelle et impaire ϕ(u) est imag. et impaire
transformée de Fourier d’une constante donne une Dirac, f (x) est imag. et paire ϕ(u) est imag. et paire
39 En principe. . . toutefois, la grosse difficulté vient de ce qu’on f (x) est imag. et impaire ϕ(u) est réelle et impaire
mesure le module de S(k) seulement et donc on perd la phase de la
fonction complexe.
Par ailleurs, si ϕ(u) est la transformée de Fourier de
40 Ce n’est pas une fonction au sens mathématique, mais une dis- f (x), celle de f (ax) est a1 ϕ( ua ) et celle de f (x − x0 ) s’écrit
tribution. La nuance sera explicitée en mathématiques. ϕ(u) eiux0 .
Physique numérique, Philippe Depondt 81

4.10.1.2.4 Produit de convolution. Imaginons que La transformée de Fourier d’un produit de convolution
l’on fasse une expérience pour mesurer une grandeur y en est le produit des transformées de Fourier.
fonction d’une autre grandeur x, mais l’appareil de me-
sure n’est évidemment pas parfait : si on le règle sur une Le produit des transformées de Fourier est souvent
certaine valeur x = x0 , il « bave » un peu et le résultat beaucoup plus facile à faire que le produit de convolution
obtenu sera une superposition de contributions issues de lui-même, et quand on verra l’efficacité des transformées
points voisins de x0 : de Fourier rapides numériques. . .
Z
ymesure (x0 ) = y(x) a(x0 − x) dx (4.26) 4.10.1.2.5 Quelques transformées de Fourier
« célèbres ». On a déjà vu que la transformée de Fou-
où a(x) est la « fonction d’appareil » dont on peut espérer rier d’une fonction créneau donnait un sinus cardinal et
qu’elle a un maximum relativement marqué en x = 0. . . Le que la distribution de Dirac donnait une constante.
cas arrive, par exemple, si l’on fait une mesure de disper- -La gaussienne. La fonction de Gauss s’écrit :
sion de la lumière à l’aide d’un prisme avec un faisceau de
lumière incident qui ne serait pas parfaitement fin (figure C (x−x0 )2
√ e− 2σ2
4.31). 2π
ν1 où x0 est l’emplacement du sommet et σ sa variance.
ν2 0.4

0.35

0.3

0.25

A 0.2

0.15

0.1

0.05
Fig. 4.31 – Au point A, on reçoit une superposition de
0
lumière de deux fréquences différentes ν1 et ν2 parce que −2 −1 0 1 2 3 4
le faisceau incident n’est pas parfaitement fin. En fait, on
reçoit aussi toutes les fréquences intermédiaires ce qui fait Fig. 4.32 – Gaussienne pour C = 1, x0 = 1 et σ = 0.5.
que le résultat est la superposition de toutes ces contribu-
tions comme dans l’équation (4.26). C’est une courbe (figure 4.32) qui ressemble beaucoup à
la lorentzienne si ce n’est que les « pieds » en sont moins
L’équation (4.26) est un produit de convolution de la large à cause de l’exponentielle qui décroı̂t plus vite que
fonction y par la fonction a. C’est un objet que l’on re- la fraction rationnelle. Si l’on en calcule la transformée de
trouve fréquemment, dans les problèmes de fonction d’ap- Fourier dans le cas le plus simple (x0 = 0, σ = 1), l’on
pareil comme on l’a vu, mais aussi par exemple lorsqu’un obtient :
système répond avec retard à une sollicitation et que son Z ∞ Z ∞
état est le produit de convolution de la sollicitation aux 1 x2 1 x2
ϕ(u) = √ e− 2 eiux dx = √ e− 2 cos ux dx
instants précédents par une « fonction mémoire ». −∞ 2π π −∞
Le produit de convolution d’une fonction f par une fonc-
parce que le sinus de la partie imaginaire de l’exponen-
tion g se note par un astérisque :
Z ∞ tielle est impair et donc l’intégrale correspondante nulle.
f ∗g = ′ ′
f (x ) g(x − x ) dx′ En supposant que tous les théorèmes de convergence sou-
−∞ haitables s’appliquent ici, une dérivation par rapport à u
et c’est une fonction de x. Par un changement de variable, sous le 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 ∞ 
[f ∗ g](x′ ) eiux dx′ = f (x)g(x′ − x) eiux dxdx′ 1 x2 x2
−∞ −∞ −∞ ϕ′ (u) = √ e− 2 sin ux −u e− 2 cos ux dx
Z ∞Z ∞ 2π −∞ −∞
= f (x)g(X) eiu(X+x) dxdX
−∞ −∞ soit :
Z ∞ Z ∞
ϕ′ (u) = −uϕ(u)
= f (x) eiux dx g(X) eiuX dX
−∞ −∞ une équation différentielle qui donne :
soit le produit des transformées de Fourier. C’est un
u2
théorème important : ϕ(u) = K e− 2
 82 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où K est une constante d’intégration qui, via l’expression

de la transformée inverse, vaut 1. Donc :
ondes de choc
Z ∞
1 x2 u2
√ e− 2 eiux dx = e− 2 (4.27)
2π −∞
v 0000000000000000
1111111111111111
0000000000000000
1111111111111111
Le résultat final est que la transformée de Fourier d’une 0000000000000000
1111111111111111
1111111111111111
0000000000000000
0000000000000000
1111111111111111
0000000000000000
1111111111111111
gaussienne est une gaussienne.
En posant u = 0 dans l’équation (4.27), on obtient :
Z ∞ √
x2 L
e− 2 dx = 2π
−∞ l
x
l’intégrale de Gauss.
Des changements de variables ad hoc permettent de
généraliser l’équation (4.27) en une relation utile pour bien t
t1 t2
des calculs :
Z ∞ r
π β2 Fig. 4.33 – Modélisation des ondes de chocs produites
−αx2 −βx
e dx = e 4α (4.28) par un objet qui se déplace à vitesse supersonique. L’axe
−∞ α
horizontal supérieur donne une allure de la pression en
où α et β peuvent être complexes à condition que ℜe (α) > fonction de la position et l’axe inférieur en fonction du
0 : ces relations expliquent que de nombreux modèles temps pour un auditeur immobile au sol.
théoriques partent de distributions gaussiennes alors qu’il
n’y a pas forcément toujours d’hypothèse physique très
Ainsi, un objet qui se déplace dans l’air avec une vitesse
convaincante pour le justifier41 . . .
supersonique (un avion, par exemple) produit le fameux
-L’oscillateur harmonique amorti. Le mouvement
double « bang » : il s’agit de la succession de deux ondes
d’un oscillateur harmonique amorti peut s’écrire :
de choc que l’on peut être tenté de modéliser de façon

z(t) = z0 e−iω0 t−αt si t > 0 simple. Il suffit de se rappeler les vagues d’étrave d’un ba-
z(t) = z0 si t ≤ 0 teau (qui lui aussi se déplace plus vite que les ondes -les
vagues- qu’il produit : les bateaux sont pratiquement tou-
où ω0 et α sont réels. La transformée de Fourier de ceci jours supersoniques !) pour considérer que l’objet traı̂nera
donne : avec lui une onde de surpression initiée à l’avant et une
Z 0 Z ∞ onde de dépression initiée à l’arrière (figure 4.33). L’audi-
z0
z0 eiωt dt + z0 ei(ω−ω0 )t−αt dt = z0 δ(ω) + teur, immobile au sol, percevra la première à l’instant t1
−∞ 0 α − i(ω − ω0 )
et la seconde à l’instant t2 avec
Si l’on en prend le module au carré, c’est-à-dire la densité L
spectrale, on obtient : ∆t = t2 − t1 =
v
!
2α 1/α2 où L est la longueur de l’avion et v sa vitesse.
I(ω) = z02 δ 2 (ω) + δ(ω) 2 2 +
2 La durée de chacune de ces impulsions peut s’évaluer
α + ω0 1+ ω−ω 0
α approximativement comme :
soit une lorentzienne centrée en ω0 , la fréquence de l’os- ℓ
cillateur, et de demi-largeur à mi-hauteur α, le coeffi- δt =
v
cient d’amortissement (à condition d’ignorer les Dirac sans
grand intérêt et dues à la partie t < 0 lorsque l’oscillateur où ℓ est une dimension caractéristique des extrémités de
ne bouge pas). Comme l’oscillateur amorti est un objet as- l’objet (rayon de courbure de la pointe avant par exemple).
sez répandu dans le monde des physiciens, cela montre que Pour simplifier, on considérera l’objet comme symétrique
la lorentzienne est un objet mathématique d’usage plutôt et chaque onde de choc comme gaussienne : c’est un
courant : c’est bien souvent le premier candidat plausible modèle, il est fort probable que le profil des variations de
comme modèle à ajuster à quelque expérience. . . pression ne soit pas gaussien ; toutefois on peut espérer
que quelques propriétés physiques importantes puissent
4.10.1.3 Un exemple : le bang supersonique. être mises en évidence malgré cette simplification. La sur-
pression ressentie au sol et due aux ondes de choc s’écrit
L’intérêt des transformées de Fourier par rapport aux alors :  
(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
détonation, percussion, etc., entre dans ce cas. Il s’agit de calculer maintenant la dépendance en fréquence
41 Un peu loin de la physique, les calculs boursiers se basent en car l’oreille humaine perçoit la hauteur des sons, autre-
général sur des distributions « normales » ou gaussiennes des fluc- ment dit leur fréquence : il s’agit donc de faire une trans-
tuations des cours, tout simplement parce que là s’appliquent des formée de Fourier en utilisant les relations ci-dessus.
théories d’intégration bien établies. . . alors qu’on sait très bien que
dans bien des cas les cours de la bourse ne suivent pas des distri- L’équation (4.28) permet d’écrire de façon générale,
butions de fluctuations gaussiennes : c’est un peu l’histoire du type Z ∞ Z ∞ r
qui cherche ses clefs sous le réverbère parce qu’au moins là, il voit t−t 2
−( τ 0 ) iωt iωt0
2
−( τt ) iωt iωt0 π − ω2 τ 2
quelque chose !
e e dt = e e e dt = e 2
e 4
−∞ −∞ τ
Physique numérique, Philippe Depondt 83

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

Comme Ṽ ne dépend pas de x, y et z et en supposant 4.10.2 La transformée de Fourier discrète.

que l’on puisse dériver sous le signe somme, une dérivée
Il existe des méthodes numériques très efficaces pour
partielle s’écrit :
calculer des transformées de Fourier ; elle reposent toutes
∂2V 1 cependant sur une même approximation :
= ×
∂x2 (2π)3
Z ∞ n−1
X
ZZZ f (x) eiux dx ∼ f (xℓ ) eiuxℓ δx
2 −i(kx x+ky y+kz z)
Ṽ (kx , ky , kz ) × −kx e dkx dky dkz −∞ ℓ=0

avec :
avec évidemment des expressions similaires pour y et z. xℓ = xmin + ℓ δx
On définit ρ̃ de la même façon :
et
xmax − xmin
ρ(x, y, z) = δx =
n
ZZZ ainsi, x0 = xmin et xn−1 = xmax − δx , on est dans la
1 même situation que celle de l’intégration par la méthode
ρ̃(kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz
(2π)3 des rectangles.
On remplace donc l’intégrale de −∞ à ∞ par une série
En appliquant l’équation de Poisson, on obtient alors :
discrète sur un échantillonnage de points pris sur un in-
ZZZ tervalle borné.
Ṽ (kx , ky , kz ) k 2 e−i(kx x+ky y+kz z) dkx dky dkz = En fait pour des raisons de généralité des programmes,
on se borne à calculer la série :
ZZZ n−1
1 X
ρ̃(kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz Fk = fℓ e
2πikℓ
n (4.30)
ε0
ℓ=0
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 )
Ṽ (kx , ky , kz ) = L’expression (4.30) est celle de la transformée de Fou-
ε0 k 2 rier 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,
pourtant extrêmement courants et indéniablement très
donne en transformée de Fourier :
utiles.
Ẽx (kx , ky , kz ) = ikx Ṽ (kx , ky , kz )
4.10.2.1.1 Périodicité. La première remarque que
Ẽy (kx , ky , kz ) = iky Ṽ (kx , ky , kz ) 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.
1
On risque bien sûr de rencontrer quelques difficultés
0.9
quand k = 0, mais il suffit de noter que :
0.8
ZZZ
0.7
Ṽ (k = 0) = V (x, y, z) dx dy dz
0.6
0.5
pour voir que le choix de la valeur de Ṽ (k = 0) n’est qu’un 0.4
choix de la constante arbitraire du potentiel : Ṽ (k = 0) = 0.3
0 peut être une bonne option.
0.2
La méthode peut paraı̂tre assez lourde, mais en fait, la
grande rapidité des transformées de Fourier numériques 0.1
permet de résoudre ainsi bien des problèmes qui n’au- 0
0 1 2 3 4 5 6 7 8 9
raient pas de solution sinon. Il faut cependant maintenant
se préoccuper de ce que font réellement les transformées Fig. 4.35 – Une gaussienne « périodique » et mal coupée !
de Fourier numériques proposées dans les bibliothèques de
calcul car il s’agit bien sûr d’approximations et cela peut En principe, ce n’est pas bien grave parce qu’on peut
avoir des conséquences, parfois imprévues. choisir une très grande période, « infinie » en pratique par
Physique numérique, Philippe Depondt 85

rapport aux dimensions ce que l’on veut étudier : c’est Ainsi, la longueur de l’intervalle dans l’espace de la
d’ailleurs généralement ce que l’on fait. Toutefois, il y a transformée de Fourier est l’inverse du pas dans l’espace
parfois des choix maladroits : par exemple, si l’on veut cal- direct.
culer la transformée de Fourier d’une gaussienne centrée Ces deux théorèmes qui ont l’air, il est vrai, tri-
en zéro, on sait que la partie imaginaire doit être nulle viaux, sont très importants car c’est ainsi que l’on choi-
puisque la gaussienne est paire ; or, si par malheur, on a sit l’intervalle d’intégration en fonction, par exemple, de
choisit pour faire le calcul, l’intervalle [0, X], X > 0 et la résolution fréquentielle voulue ou de l’intervalle de
grand par rapport à la variance, on est en train de cou- fréquences désiré. Ainsi, si l’on s’intéresse à un système
per en deux la gaussienne à son maximum en x = 0 et à d’oscillateurs pour lesquels les phénomènes intéressants se
l’autre extrémité de l’intervalle, la valeur de la gaussienne
produisent aux environs de 10Hz, on peut vouloir un in-
sera presque nulle (figure 4.35). Mais, en x = X, subite- tervalle de fréquences qui va de 0 à 20Hz : cela signifie que
ment à cause de la périodicité, la fonction retrouvera une le pas de temps doit être obligatoirement de l’ordre de
valeur non négligeable : une variation rapide qui donnera 1/20=0,05s (ici, l’on raisonne en temps-fréquence, donc
des contributions de haute fréquence. De plus, notre fonc- le facteur 2π disparaı̂t). De plus, si l’on veut pouvoir
tion n’est plus paire : la partie imaginaire n’a plus de raison
distinguer des phénomènes dont les fréquences diffèrent
d’être nulle ! Un intervalle [−X, X] serait plus judicieux. . .
de 0,1Hz, cela entraı̂ne que la longueur de l’intervalle de
temps est au minimum de 1/0,1=10s. Donc, n, le nombre
On peut certes tenter d’être habile, mais alors, il faut être
sûr de soi : on peut garder l’intervalle [0, X] (et donc di- de pas est égal, au minimum à 10s/0,05s = 200. Quitte à
viser par deux le nombre de points nécessaires), et forcer se répéter, ces relations très simples entre pas de temps
la partie imaginaire à zéro. On perdra alors toutefois une et fréquence sont fondamentales dès que l’on faire un
possibilité de détecter des erreurs ! usage pratique de cet outil, en particulier, quand (comme
expérimentateur, par exemple) on a affaire au monde réel
4.10.2.1.2 Pas de calcul. La discrétisation de qui a pour défaut principal que l’on ne peut pas considérer
l’équation (4.30) a aussi des conséquences. Pour faire la toutes les constantes comme valant 1 (m = e = c = h̄ =
correspondance entre l’intégrale et la somme discrète, on kB = 1) !
doit faire l’égalité :
4.10.2.1.3 Une « fausse » symétrie. Calculons le
2πikℓ
eiuk xℓ = e n terme Fn−k de la DFT, c’est-à-dire le symétrique de Fk
par rapport au milieu de l’intervalle :
sachant que :
n−1
X n−1
X
xℓ = xmin + ℓ δx 2πiℓ(n−k) 2πiℓk
Fn−k = fℓ e n = fℓ e2πiℓ e− n
et en posant : ℓ=0 ℓ=0
uk = umin + k δu
or e2πiℓ = 1, et donc :
soit :
n−1
X
2πikℓ 2πiℓk
ei(umin +k δu )(xmin +ℓδx ) = e n Fn−k = fℓ e− n = F−k
2πikℓ
ei(umin xmin +umin ℓδx +xmin k δu ) eikℓδx δu = e n ℓ=0

ce qui est cohérent avec la périodicité mais si la suite fℓ

Une chose au moins paraı̂t claire : ça ne marche pas ! On est réelle, ce qui arrive très souvent, on obtient :
doit donc supprimer xmin et umin .
Ainsi, la DFT postule que l’intervalle commence en zéro. Fn−k = Fk∗
Il faut donc utiliser la propriété que la transformée de
Fourier de f (x − x0 ) est ϕ(u) eiux0 : si l’on ne s’intéresse et pour le spectre,
pas à la phase, c’est sans importance, mais dans le cas
∗
contraire, il faut y penser. In−k = Fn−k Fn−k = Ik
La correspondance entre intégrale et somme discrète se
ramène donc maintenant à : seule la première moitié des points est utile : c’est à ne
pas oublier lorsque l’on voudra déterminer l’intervalle de
2πikℓ
e ikℓδx δu
=e n définition de f . . .

soit : 4.10.2.2 Fast fourier Transform = FFT.

2π
δu = Quand on veut calculer une transformée de Fourier
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
2π limpides. Cependant, la transformée de Fourier est d’un
n δu = usage tellement courant en physique que, généralement,
δx
86 Licence de physique L3 : Physique Fondamentale & PHYTEM,
on a déjà utilisé une FFT de bibliothèque et que l’on a
déjà déchiffré la documentation correspondante, et donc
il devient aussi aisé de l’utiliser que de reprogrammer soi-
même quelque chose, si simple cela soit-il !
Toutefois, l’argument massif est que l’algorithme FFT
est très efficace dès que le nombre de points considéré
devient important, et l’on a vu que des questions
d’échantillonnage de fréquences pouvaient imposer de tra-
vailler avec beaucoup de points.
Une première remarque est que l’équation (4.30) peut
se reécrire :
n−1
X 2πi
Fk = fℓ wnkℓ , si : wn = e n
ℓ=0
Découpons la somme ci-dessus en deux moitiés, l’une com-
prenant les termes pairs et l’autre les termes impairs :
(n−1)/2 (n−1)/2
X X
Fk = f2ℓ wn2kℓ + f2ℓ+1 wnk(2ℓ+1)
ℓ=0 ℓ=1
(n−1)/2 (n−1)/2
X X
kℓ
= f2ℓ wn/2 + wnk kℓ
f2ℓ+1 wn/2
ℓ=0 ℓ=1
On peut rediviser l’intervalle en deux et ainsi de suite : à
terme, l’on n’aura plus à calculer que des termes du type
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. . .
On regroupe sous le nom de méthodes de « Monte-
4.10.3 Filtrage de données expérimen-
Carlo » (à cause du célèbre casino) les méthodes qui re-
tales. posent sur des tirages au sort : vaste monde dont nous
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 recommen-
dable. 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 !
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
0
0 2 4 6 8 10
Fig. 4.36 – La fonction 12 (1 − tanh ν−ν
γ ) avec ν0 = 5 et
0
γ = 1 que l’on peut utiliser pour faire un filtre passe-bas.
La méthode, si elle est souvent employée avec succés,
peut être considérée comme un peu brutale. Une autre
possibilité est alors de multiplier la transformée de Fourier
par un fonction qui vaille 1 à basse fréquence et zéro à
haute. Le choix est au goût de chacun : un bon candidat
est cependant 12 (1 − tanh ν−ν γ ) où ν0 est le seuil et γ la
0
largeur du domaine où la fonction de filtrage décroı̂t (figure
4.36)46 .
La remarque faite précédemment (§ 4.8.5) selon la-
quelle 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.
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,
46 Il est vrai que, parfois, les méthodes numériques font penser à la
recette de la pâte feuilletée vue par Fernand Raynaud ; en particulier,
le choix de γ, ici, paraı̂t être de l’ordre de la fameuse « chaleur
patissière » indispensable à la réussite de ladite recette !
Physique numérique, Philippe Depondt
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
soumis au hasard comme ci-dessus, mais sans mémoire : le
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 sui-
vant (si le dé se rappelait le six et interdisait par exemple
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.
4.11.2 Les vicissitudes de π.
Le chapitre « Nombres aléatoires » des Numerical Re-
cipes (ref. [3]) commence par la remarque (p. 266) :
« Il peut paraı̂tre pervers d’utiliser un ordinateur, la
plus précise et la plus déterministe de toutes les ma-
chines conçues par l’esprit humain pour produire des
nombres “aléatoires”. » En effet, mais nous nous gar-
derons d’affirmer que la perversité n’a jamais fait re-
culer un mathématicien appliqué. . . Toujours est-il que
bien avant l’invention des ordinateurs, au XVIIIe siècle,
Georges Louis Leclerc comte de Buffon, un individu par
ailleurs honorablement connu, calcula que, si on lance au
hasard une aiguille de longueur ℓ sur un réseau de droites
parallèles distantes d’une distance a, la probabilité que
l’aiguille rencontre une droite s’écrit :
2ℓ
p=
aπ
une méthode probabiliste de détermination expérimentale
du nombre π. En effet, plusieurs tentatives de ce genre
eurent lieu au XIXe siècle malgré le caractère quelque
peu fastidieux de l’opération consistant à lancer un grand
nombre de fois une aiguille et à compter le nombre de fois
qu’elle recontre une droite47 .
4
3.8
3.6
3.4
3.2
3
2.8
où m est un nombre entier « grand » et a et b des entiers
2.6
1 10 100 1000 10000 100000 positifs appelés « multiplicateur » et « incrément ».
1e+06
A priori, cette séquence se répète puisqu’il n’y a que m
Fig. 4.37 – Calcul du nombre π par tirage au sort. En abs- valeurs possibles pour les Ij , ainsi, si l’on a plus que m
cisse le nombre de tirages en échelle logarithmique. En or- tirages, on doit retomber sur les mêmes nombres : c’est
donnée, les estimations de π correspondantes. Le résultat un système périodique. On note qu’il faut initialiser la
obtenu pour un million de tirages est 3,1428721 séquence avec une « graine » I0 50 . Finalement, si l’on fait
Plus simplement encore, on peut remarquer que comme
le rapport des surfaces d’un carré de coté a et d’un cercle
47 Ainsi, l’expérience faite en 1901 par Lazzerini, en jetant une
aiguille 3407 fois, donna : π = 3,1415929 (au lieu de 3,14159265).
87
de rayon a2 vaut π4 , on peut lancer des flèches, cailloux ou
tout autre projectile et compter le nombre de fois où le
projectile tombe dans le cercle et le diviser par le nombre
total de tirs. Cela donne des estimations successives de
π
4 (figure 4.37). Evidemment, plus les tirs sont nombreux,
meilleure est l’estimation.
Même si l’on peut imaginer d’autres méthodes plus
économiques pour déterminer π, ces remarques montrent
que l’on peut tenter de résoudre des problèmes qui ne
comportent a priori aucun caractère aléatoire à l’aide
de méthodes probabilistes. On notera que pour que les
théorèmes probabilistes, comme la limite centrale, puissent
s’appliquer, il faut un grand nombre de tirages au sort,
comme dans la figure 4.37, et que donc la capacité des or-
dinateurs à répéter de nombreuses fois la même opération
sans se lasser n’est pas à négliger.
4.11.3 La production de nombres
« aléatoires ».
Mais comment une machine déterministe comme un or-
dinateur peut-elle produire des nombres aléatoires ?
En fait, un ordinateur est incapable de produire des
nombres aléatoires et donc il n’en produit pas. . .
Un ordinateur produit des séquences de nombres arbi-
traires dont on espère qu’ils sont non-corrélés au problème
que l’on souhaite résoudre. C’est que l’on appelle sou-
vent des « nombres pseudo-aléatoires ». Pour illustrer
ceci, imaginons qu’un touriste un peu obsessionnel décide
de visiter les musées parisiens par ordre alphabétique :
c’est un ordre parfaitement déterminé, et si l’on recom-
mence un peu plus tard, en appliquant la même règle,
l’ordre sera strictement le même48 . Cependant, si l’on
s’intéresse aux thématiques de ces musées, on tombera sur
une séquence du type : Musée de l’Arc de Triomphe, Musée
des Armées, Musées des Arts Africains et Océaniens, etc. :
une séquence complètement arbitraire et qui peut être
considérée pratiquement comme. . . aléatoire car les arts
africains et océaniens n’ont pas grand-chose à voir avec
les armées49. Bien sûr, l’ordre alphabétique introduit des
corrélations parasites : tous les Musées des Arts xxx se
suivent ! Ce sont des choses dont il faudra se méfier aussi
dans l’usage de générateurs de nombres « aléatoires » des
ordinateurs.
Comment cela fonctionne-t-il ? Un générateur de
nombres pseudo-aléatoires produit une séquence de
nombres entiers I1 , I2 , I3 ,. . ., compris entre 0 et m − 1 par
la réccurence :
Ij+1 = aIj + b, modulo m
48 À condition, évidemment, que la liste des musées n’ait pas
changé entre-temps.
49 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.
50 seed en anglais.
88 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

I
le rapport mj on obtiendra une séquence de nombres réels i est un entier permet de le faire : il suffit d’une instruction
dans l’intervalle [0, 1[. call srand(i) avant le premier appel à rand(). Quelle
On a clairement intérêt à choisir m aussi grand que pos- valeur donner à i ? Soit l’on veut en garder la maı̂trise,
sible, soit, compte tenu de la représentation des nombres alors, il faut prévoir de lire au clavier la valeur de i, soit,
entiers sur quatre octets : m = 231 − 1 = 2 147 483 647. on peut choisir la fonction time qui donne l’heure sous
Le choix de a et b (par exemple a = 75 = 16 807 et forme d’un nombre entier : call srand(time()) don-
b = 0) fait l’objet de débats infinis et dépend parfois de nera. . . n’importe quoi, ce qui est ce qu’on voulait !
la machine utilisée. Dans la grande majorité des cas, on a
intérêt à se servir du générateur fourni avec l’ordinateur
que l’on utilise plutôt que de tenter d’écrire quelque chose ?
soi-même : il se trouve que le langage fortran fourni une
fonction intrinsèque rand()51 qui en général donne satis-
faction. Si la variable x est déclarée en real, l’instruction x
= rand() donnera un nombre pseudo-aléatoire. Si l’on fait
plusieurs tirages, on obtiendra une séquence de nombres
compris entre 0 et 1 avec une distribution uniforme (figure
4.38). Il existe aussi le sous-programme random number :
call random number(x) remplira le tableau x de nombres
pseudo-aléatoires. 60
seed=1
seed=2
50 seed=3
1
0.9 40

0.8 30

0.7 20

0.6 10

0.5 0

0.4 −10

0.3 −20

0.2 −30
0 500 1000 1500 2000 2500 3000 3500 4000 4500 5000
0.1
0 Fig. 4.39 – Marche au hasard ou drunkard’s walk (marche
0 10 20 30 40 50 60 70 80 90 100
1.03 de l’ivrogne) avec trois graines différentes.

1.02 La figure 4.39 montre une marche au hasard : un ivrogne

a une probabilité égale de faire un pas à gauche ou à
1.01
droite de longueur quelconque, en-dessous d’une certaine
valeur (liée à la longueur des jambes dudit ivrogne). Ainsi,
1
à chaque pas, on doit ajouter à la position actuelle un
nombre (pseudo)aléatoire compris entre −0, 5 et 0, 5 (c’est-
0.99
à-dire x = x + rand()-0.5). Trois graines différentes
0.98
donnent trois trajectoires différentes. Ce type de simu-
lation peut concerner, outre les errances53 éthyliques, le
0.97 mouvement brownien ou le cours d’une action en bourse !
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Il faut donc retenir de tout ceci que l’ordinateur ne
produit pas de nombres aléatoires et qu’il est bon de
Fig. 4.38 – En haut, une séquence de 100 nombres pseudo-
se méfier un peu : faire le même calcul avec plusieurs
aléatoires et en bas, distribution des valeurs fournies par
graines différentes, essayer plusieurs générateurs différents
la même fonction intrinsèque rand() après 1 000 000 de
si possible, voire utiliser des machines d’architectures
tirages : on obtient une distribution uniforme.
différentes. . . Certains algorithmes sont très sensibles aux
imperfections des séquences de nombres pseudo-aléatoires,
Le problème de la graine est un peu plus délicat : si on d’autres beaucoup moins : cet avertissement ne se veut pas
ne la fixe pas, la séquence de nombre produits par rand() dissuasif, comme les précédents, il vise à rappeler au mi-
sera la même d’un usage à l’autre : si on arrête l’exécution nimum de prudence !
du programme, l’ordinateur « oublie » où il en était et
si l’on relance l’exécution, il repart au premier point et
refait la même séquence. Dans certains cas, cela n’a au- 4.11.4 Obtenir une distribution autre
cune espèce d’importance, mais si, par exemple, on veut qu’uniforme.
comparer des moyennes effectuées sur des échantillonnages
différents, alors évidemment, il vaut mieux pouvoir chan- Dans le paragraphe précédent, il a été montré com-
ger d’échantillonnage. Le sous-programme srand(i)52 où ment obtenir une séquence de nombres pseudo-aléatoires
avec une distribution uniforme entre 0 et un, c’est à dire
51 pour random.
52 le s de srand est pour seed, évidemment. . . 53 sinon les errements. . .
Physique numérique, Philippe Depondt 89

0.45
des nombres qui ont une probabilité p0 (x)dx d’apparaı̂tre Generated distribution
Normal distribution
0.4
entre x et x + dx qui s’écrit :
 0.35
dx si 0 ≤ x < 1
p0 (x)dx = 0.3
0 sinon
0.25

p(x)
ce qui respecte la condition de normalisation : 0.2
Z ∞
0.15
p0 (x) dx = 1
−∞ 0.1

Mais si l’on veut autre chose qu’une telle distribution uni- 0.05

forme ? Soit une fonction y(x). On produit des nombres qui 0

−4 −2 0 2 4
ont une probabilité p0 (x)dx de tomber entre x et x + dx. x

Si on leur fait subir la transformation y(x), on obtient une

deuxième séquence de nombres dont la probabilité de tom- Fig. 4.40 – Comparaison d’une distribution obtenue par
ber entre y et y + dy est p(y)dy, mais c’est aussi celle de l’algorithme donné 2dans le texte et d’une distribution
1 x
tomber entre x et x + dx pour la première séquence, soit : gaussienne √ e− 2 . Le calcul a été fait avec 20000 ti-
2π
|p(y)dy| = |p0 (x)dx| rages au sort.
Comme une densité de probabilité est positive, cela donne,
 
 dx  4.11.5 Intégration multidimensionnelle
p(y) = p0 (x)  
dy sur des domaines compliqués.
Sachant que p0 (x) vaut un, le problème est donc 4.11.5.1 Principes
connaissant p(y), la distribution voulue, trouver la fonc-
tion y telle que : Au chapitre 4.3.2, on a vu des méthodes d’intégrations
dx à une dimension comme la méthode des trapèzes. Celle-ci
p(y) = se généralise sans difficulté à des intégrales multidimen-
dy
sionnelles du type :
donc, y(x) est la fonction réciproque d’une primitive de
p(y). Z b1 Z b2 Z bn
Par exemple, si l’on voulait p(y) = e−y , alors, y(x) = ... f (x1 , x2 , . . . , xn ) dxn . . . dx2 dx1
− ln x ; ou encore une distribution lorentzienne p(y) = a1 a2 an
1 1
, cela donne y = tan πx (exercice : le vérifier). Ce type d’intégrale correspond en fait à des domaines
π 1 + y2 d’intégration de géométrie simple (rectangle à deux di-
Malheureusement, ce n’est pas toujours aussi simple.
mensions, parallélépipède à trois dimensions, etc.) ; on
Si, par exemple, on veut une distribution gaussienne (ou
peut dans une certaine mesure, par des changements
normale) :
1 y2
de variables appropriés (coordonnées cylindriques ou
p(y) = √ e− 2 sphériques) adapter l’intégration à d’autres géométries. Il
2π
y a toutefois des limites.
le calcul de la fonction réciproque de la primitive n’a rien
d’évident. . . En fait les choses s’arrangent si l’on passe en
coordonnées polaires à deux dimensions en pensant à la
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 Fig. 4.41 – Un domaine d’intégration un peu compliqué. . .
v = sqrt(-2.*log(rand()))
phi = tpi*rand() Imaginons, par exemple, que l’on veuille calculer la fi-
x1 = v*cos(phi) ; x2 = v*sin(phi) gure d’interférences donnée par deux fentes d’Young, mais
end la source lumineuse, au lieu d’être ponctuelle, est un fila-
C’est, certes, de l’ordre de la recette de cuisine et c’est ment d’ampoule électrique épais, torsadé et courbé (figure
bien pour cela qu’il existe des ouvrages spécialisés et des 4.41), ou, pire, une galaxie vue à travers un télescope :
bibliothèques de programmes tous faits ! comme la source est incohérente, il faut donc intégrer les
90 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

intensités lumineuses issues de chaque point de la source. 2 1

Le domaine d’intégration est donc la source : il n’y a guère 1.5 0.8
d’habile changement de variable qui saute aux yeux ! 0.6
Il existe une première solution qui consiste à intégrer sur 1 0.4
un volume de géométrie simple qui englobe la source, en
0.2
0.5 0.0
fixant la valeur de l’intensité lumineuse à zéro en dehors
de la source. 0 −0.2
−0.4
−0.5−0.6
−0.8
−1 −1
−1.5
−2
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2
d Fig. 4.43 – Le domaine d’intégration D défini par
l’équation (4.31) est délimité par la courbe continue
rouge. . .

c’est nettement plus compliqué ! Il suffit toutefois de tirer

au sort des nombres x et y dans l’intervalle [−2, 2], et, si
la condition de l’équation (4.31) est vérifiée, additionner
la quantité sin(xy) à toutes celles déjà obtenues. Il faut
alors normaliser le résultat en multipliant cette somme S
d VD
par 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
Fig. 4.42 – Si l’on veut calculer l’intégrale d’une fonction
« coups au but » c’est-à-dire le nombre de fois où l’on est
dans un espace compliqué, on peut englober cet espace
tombé dans D. Que vaut alors VD ? Il suffit de reprendre
dans un (hyper)cube, ici un carré d × d, tirer au sort des
le raisonnement utilisé pour calculer π par le rapport de la
points dans ce carré, c’est-à-dire, pour chaque point, tirer
surface du cercle à celle du carré : c’est le volume total Vt
deux nombres compris entre 0 et d et n’ajouter la valeur
dans lequel on a fait des tirages multiplié par la proportion
de la fonction en ce point que s’il se trouve dans l’espace
de coups au but :
d’intégration. Sinon, on l’ignore et on fait un nouveau ti-
nc
rage. VD = Vt
nt
L’autre solution consiste à tirer au sort des points dans où nt est le nombre total de tirages. Ainsi, en fin de
ce volume (figure 4.42), d’ignorer les points qui sont en compte,
dehors de la source et de ne compter que ceux qui sont sur Vt
la source. Cette deuxième solution, si elle peut paraı̂tre ID = S
nt
un peu absurde, a au moins deux mérites : 1o elle est
simple à mettre en œuvre, et 2o elle permet de tracer le Le programme qui fait cela est extrêmement simple :
graphe du résultat en fonction du nombre de tirages au
sort, de sorte que lorsque le résultat ne fluctue que d’une program integr
valeur inférieure à un certain seuil, on peut considérer que implicit none
l’intégrale est calculée avec cette précision (c’est un peu real :: x, y, s
comme sur la figure 4.37 où l’on peut considérer que π integer :: i, imax = 100000000, n
est calculé à partir du moment où les fluctuations sont s = 0. ; n = 0
inférieures à la précision souhaitée). open(10,file=’integr_sin.out’)
do i = 1, imax
x = 4*(rand()-0.5) ; y = 4*(rand()-0.5) ! [-2,2]
4.11.5.2 Tentative « naı̈ve ». if ( 4*tanh(x-y)*exp(-(x**2 + y**2)) > 0.4 ) &
s = s + sin(x*y)
Prenons un autre exemple : on veut calculer,
if ( mod(i,5000) == 0 ) write(10,*) i, 4*s/i
Z enddo
ID = sin(xy) dx dy write(*,*) 4*s/imax
D end
où D est le domaine d’intégration. Si
Ça donne -8.9420289E-02 pour 108 tirages et quelques
2 2 secondes de calcul. Le résultat en fonction du nombre de
D = {(x, y), tels que x + y < π}
tirages est representé sur la figure 4.44. Les huit chiffres
c’est facile : ID = 0 ; mais si (figure 4.43) « significatifs » du résultat ci-dessus ne sont évidemment
2 2
pas tous significatifs ! On constate aisément sur la figure
D = {(x, y), tels que 4 tanh(x − y) e−(x +y ) > 0.4} qu’avec tous ces tirages, on en a au plus 3, soit ID ≃
(4.31) −0.0894. . . Peut-on être plus efficace ?
Physique numérique, Philippe Depondt 91

-0.0885 -0.088

-0.08875
-0.0882
-0.089

-0.08925 -0.0884

-0.0895 -0.0886
-0.08975
-0.0888
-0.09

-0.09025 -0.089

-0.0905
-0.0892
-0.09075

-0.091 -0.0894

-0.09125 -0.0896
-0.0915
-0.0898
-0.09175

-0.092 -0.09
100000 1e+06 1e+07 1e+08 1e+07 2e+07 4e+07 8e+07
n_t n

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

En divisant cette somme par le nombre de tirages, on ob- p(x, y) ∝ |xy|

tient la valeur moyenne de la fonction dans le domaine : il
puisqu’une approximation de sin(xy) quand x et y ne sont
« suffit » de multiplier par le volume du domaine VD pour
pas trop grands est xy (on prend la valeur absolue, puis-
obtenir le résultat. Si on connait ce volume, c’est en effet
qu’une densité de probabilité est toujours positive). En
assez facile, sinon, par exemple dans le cas de l’équation
utilisant la méthode du § 4.11.4, supposons que l’on tire
(4.31), il faut le calculer. . . par une méthode Monte-Carlo !
au sort des nombres X et Y avec des distributions uni-
C’est ce qui est fait fig. 4.45 et l’on obtient des résultats
formes, on a alors
assez similaires à ce qu’on avait précédemment.
Qu’a-t-on gagné en faisant tout cela ? Pas grand-chose, p(x, y) dx dy = dX dY
il faut le reconnaı̂tre, en termes de performances de calcul ; soit, en séparant
toutefois, on est rassuré que cela « marche », ce qui sera
précieux quand on n’aura plus le choix. . . x dx = dX et y dy = dY
92 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

et √ √ On sait qu’en thermodynamique statistique, pour un

x = 2X y = 2Y système donné, un grand nombre d’états microsco-
où l’on a oublié les problèmes de signe. . . On peut s’ar- piques correspondent à un même état macroscopique :
ranger pour que X et Y soient dans l’intervalle [−1, 1] et par exemple, la connaissance de la pression et de la
remultiplier par le coefficient qui va bien pour que x et température d’un gaz suffisent à définir son état macrosco-
y soient dans l’intervalle [−2, 2] comme auparavent. C’est pique qui correspond à un nombre gigantesque d’états mi-
plus simple que ça en a l’air : crosopiques possibles, définis, eux, par la position et la vi-
program importance tesse de chacun des atomes qui composent le gaz. A priori,
implicit none dans l’ensemble canonique, quand on connait la fonction
double precision :: x, y, xx, yy, s, z de partition du système
integer :: i, imax = 10000000 X − Ei
Z= e kB T
s = 0. ; n = 0 i
open(10,file=’import_sampling.out’)
do i = 1, imax on peut calculer toutes les grandeurs que l’on veut (T étant
xx = 2.*rand()-1. ; yy = 2.*rand()-1. la température du thermostat et kB la constante de Boltz-
x = 2.*sign(sqrt(abs(xx)),xx) mann). Le seul petit détail contrariant dans cette histoire
y = 2.*sign(sqrt(abs(yy)),yy) est que la somme sur i dans l’équation ci-dessus est une
if ( 4*tanh(x-y)*exp(-(x**2+y**2)) > 0.4 ) then somme sur tous les états microscopiques acccessibles au
z = x*y système 54 : autrement dit, sauf dans quelques cas55 , on ne
if ( abs(z) > 1.e-10 ) then ! no zero divide
sait pas calculer la fonction de partition.
s = s + sin(z)/abs(z)
else
Dans la formulation de Gibbs, quand on veut calcu-
s = s + 1. ler une grandeur macroscopique, par exemple l’aimanta-
endif tion d’un système magnétique, on doit prendre un grand
endif nombre de systèmes identiques, placés dans le même
if ( mod(i,10000) == 0 ) write(10,*) i, 4.*s/i état macroscopique, mais dans des états microscopiques
enddo différents. La moyenne thermodynamique d’une grandeur
close(10) (notée hM i pour une aimantation, par exemple) est la
write(*,*) 4.*s/imax moyenne de toutes les valeurs prises par cette gran-
end deur dans tous ces systèmes. C’est donc une très grosse
On obtient la courbe de la figure 4.46. Pour des résultats 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
Soit donc un système dans l’ensemble canonique (c’est-
-0.0875

-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 Z E(q1 ,q2 ,...,qn )
−
-0.09 A(q1 , q2 , . . . , qn ) e kB T
dq1 dq2 . . . dqn
-0.0905
hAi = Z E(q1 ,q2 ,...,qn )
-0.091 −
e kB T
dq1 dq2 . . . dqn
-0.0915

-0.092
100000 1e+06 1e+07
n Les q1 . . . qn sont les variables microscopiques du système
Fig. 4.46 – Valeurs obtenues pour ID avec le domaine
(4.31) en fonction du nombre de tirages (l’axe des x a une
échelle logarithmique) par une méthode d’échantillonnage
par l’importance. L’échelle de l’axe des y est la même que
pour la figure 4.44.
très comparables, voire meilleurs que ceux de la figure 4.44,
on a fait dix fois moins de tirages au sort (107 au lieu de
108 ) : on a gagné un ordre de grandeur en temps de calcul !
Ça méritait un petit effort. . .
4.11.6 Simulation de Monte-Carlo-
Metropolis.
À quoi tous les calculs d’intégrale plus ou moins com-
pliqués ci-dessus peuvent-ils bien servir à part meubler la
conversation d’un vieil enseignant ?
(4.32)
(typiquement les positions, vitesses, etc., de tous les
atomes ; n est, on l’aura compris, très grand et les
intégrales très multidimensionnelles) ; E(q1 , q2 , . . . , qn ) est
l’énergie du système dans l’état microscopique défini par
les valeurs de ces variables, A(q1 , q2 , . . . , qn ) la valeur de
la grandeur A dans les mêmes conditions. La probabilité
d’atteindre un état d’énergie E est proportionnelle à l’ex-
ponentielle (dans une statistique de Maxwell-Boltzmann)
et le dénominateur de l’expression est la fonction de par-
tition qui sert ici à la normalisation.
Il est bien sûr hors de question de calculer directement
l’expression (4.32), mais nous avons vu qu’il existe des
chemins de traverse plus ou moins tortueux pour ce genre
de situations.
54 la somme discrète ci-dessus, peut être remplacée par une
intégrale multiple sur toutes les variables microscopiques du système,
si celles-ci varient continûment.
55 voir à ce sujet le cours de thermodynamique statistique.
Physique numérique, Philippe Depondt 93

Imaginons de faire une marche au hasard dans l’espace 4.11.6.2 Concrètement.

des états accessibles au système : partons donc d’un état
Admettons, par exemple, que l’on s’intéresse à un
dont on peut calculer l’énergie E1 . La probabilité que cet
ensemble d’atomes susceptibles de constituer un so-
état soit réalisé est :
lide et que l’on puisse calculer l’énergie potentielle du
E
− k 1T système connaissant les positions atomiques : V ({~rℓ }), par
e B
p1 = exemple :
Z
 12  6 !
1X σℓm σℓm
En général, on ne peut pas calculer cette probabilité V = εℓm −2
puisque Z est inconnu. Faisons alors un pas au hasard 2 rℓm rℓm
ℓ,m
dans cet espace, on change alors d’état et l’énergie devient
si les interactions interatomiques sont des interactions de
E2 . La probabilité de ce nouvel état est
paire du type Lennard-Jones (figure 4.47), mais il existe
E
− k 2T de nombreuses autres possibilités.
e B
p2 = 2
Z
qui n’est pas plus calculable que p1 , mais Z, qui est une 1.5

intégrale sur tous les états, n’a pas changé.

1
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- 0.5

V
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 0

l’état 1 :
−0.5
π1→2 = p1 p1→2
−1
De même, en sens inverse : 1 1.2 1.4 1.6 1.8 2
r

π2→1 = p2 p2→1
Fig. 4.47 – Le potentiel de Lennard-Jones, pour ε = 1
Le principe dit « de la balance détaillée » stipule que et σ = 1. Le potentiel est fortement répulsif pour r < σ
ce qui correspond à la répulsion dite de « cœur dur »,
π1→2 = π2→1 ⇒ p1 p1→2 = p2 p2→1 attractif dans le cas contraire.

Cela signifie que si, par exemple, l’état 1 est très probable Appliquons la méthode ci-dessus : à partir d’une confi-
et l’état 2 très improbable, le système étant déjà dans l’état guration initiale qui est, soit choisie, soit prise au hasard,
2 aura une forte probabilité d’aller dans l’état 1, alors que on tire au sort un déplacement atomique, et l’on calcule
s’il est dans l’état 1, il aura une faible probabilité d’aller la variation d’énergie correspondante ∆V . Si ∆V < 0,
dans l’état 2. En revanche, si l’on regarde le système « de p1→2 = 1, on garde la nouvelle configuration et l’on reo-
loin », d’un point de vue macroscopique, on ne sait pas commence. Si, en revanche ∆V > 0,
dans quel état microscopique il est, et les probabilités de p1→2 = e
− k∆VT
B
transition dans un sens ou dans l’autre sont égales.
On arrive ainsi à la relation suivante : il faut donc garder cette nouvelle configuration avec cette
p2 probabiité.
p1→2 = p2→1 On compare alors un nombre s, tiré au sort dans l’in-
p1
tervalle [0, 1], avec cette probabilité de transition (figure
soit 4.48). La probabilité que p1→2 > s est justement. . . p1→2 !
(E2 −E1 )
−
p1→2 = e kB T
p2→1
s
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
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 0 1
(E2 −E1 )
− p = exp(dE/kT)
contraire, E2 > E1 , alors, p2→1 = 1 et p1→2 = e kB T
.
Ainsi si l’on choisit :
dE
(E2 −E1 ) Fig. 4.48 – On calcule p = e− kT et on compare avec un
−
p1→2 = min(1, e ) kB T
nombre s tiré au sort dans l’intervalle [0, 1]. Plus p est
grand, plus on a de chances que s < p : donc p est la
la marche au hasard ainsi produite obéira à la statistique probabilité de garder la nouvelle configuration.
de Maxwell-Boltzmann, ce que l’on voulait ».
En effet, nous sommes maintenant en train de faire une Donc, si p1→2 > s, on conserve la nouvelle configuration,
marche au hasard dans le domaine d’intégration avec une sinon on la rejette. Puis on recommence. . . À chaque pas,
probabilité qui est justement celle que l’on attend, on fait on calcule la grandeur dont on veut la valeur moyenne et
donc pour ainsi dire « spontanément » un échantillonnage l’on fait cette moyenne.
selon l’importance. Une écriture possible de cet algorithme serait
94 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

−0.4
i = n*rand() + 1 ! tirage au sort d’un atome 5x5
10x10
! i est dans l’intervalle [1,n], or 0 <= rand() < 1 −0.6 20x20
30x30
! −0.8 40x40
50x50
! conserver l’ancienne configuration au cas ou il 70x70
−1
! faudrait rejeter la nouvelle
x_old = x(i) ; e_old = e −1.2

Energie
! −1.4
! deplacer l’atome i
x(i) = x(i) + dx*(rand()-0.5) −1.6

! −1.8
! calcul de la nouvelle energie
−2
e = energie(x,n)
de = e - e_old −2.2
0 1 2 3 4 5
! T
1.1
if ( de > 0 ) then ! si l’energie a augmente 5x5
1 10x10
! plus exp(-de/kt) est grand, plus la condition 20x20
30x30
! ci-dessous est difficile a remplir 0.9
40x40
50x50
if ( rand() > exp(-de/kt) ) then 0.8 70x70
! rejet de la nouvelle configuration 0.7

Aimantation
x(i) = x_old ; e = e_old 0.6
endif ! sinon on garde 0.5
endif
0.4
0.3
C’est un algorithme très simple que l’on peut optimiser de
0.2
multiples façons, en particulier de calculer directement la
0.1
variation d’énergie (la variation ne dépend que de l’atome
0
déplacé et de ceux avec lesquels il est en interaction, alors 0 1 2 3 4 5
que l’énergie concerne tous les atomes) peut représenter T

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
n’est sans doute pas bien choisi car on ne connait pas au
départ quelles sont les « bonnes » configurations) jusqu’à
ce que l’on aboutisse à une situation où l’ont obtient au fil
des tirages autant d’augmentations que de diminutions de
l’énergie : le système se met à fluctuer autour d’une même
énergie. Si l’on poursuit néanmoins les tirages au sort, on
produit une succession de configurations possédant une
énergie dont les fluctuations sont de l’ordre de kB T . Les
configurations obtenues sont les configurations que par-
court le système à cette température : on peut faire des
moyennes des grandeurs physiques pertinentes, étudier la
structure, etc.
Si l’on change la température, on peut étudier comment
les grandeurs évoluent, en particulier s’intéresser aux chan-
gements de structure : les transitions de phase. Les simula-
tions de Monte-Carlo sont l’une des grandes méthodes de
simulation en matière condensée et les applications en sont
multiples. Elle s’applique, comme on l’a vu, à des systèmes
classiques dont les variables (ici, les positions 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- où X désigne l’ensemble des {xℓ }, et l’on cherche le mini-
Fig. 4.49 – Le résultat d’une simulation Monte-Carlo Me-
tropolis 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
interactions ferromagnétiques entre premiers voisins du
type −Si Sj tendant à aligner les spins ; chaque spin peut
prendre les valeurs +1 ou −1. Pour plusieurs températures
différentes, on a fait quelques centaines de milliers ti-
rages 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 l’aimantation diminue brusquement vers T = 2, 5
quand le désordre thermique prend le dessus. Si les courbes
d’énergie se superposent (sauf pour 5 × 5) on observe,
sur les courbes d’aimantation, que la transition est mieux
marquée pour le système le plus gros : l’aimantation ne
devient véritablement nulle au-dessus de la transition que
pour un système infini pour lequel les fluctuations sont
négligeables.
tion, même s’il ne s’agit pas d’une énergie ?
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 (fi-
gure 4.50), un autre plus profond se trouvant ailleurs. La
méthode du recuit simulé est une tentative pour s’attaquer
à ce problème. Soit, donc, une fonction :
f (x1 , . . . , xn ) = f (X)
Physique numérique, Philippe Depondt 95

120

100

80

60

40 A
20

−20
−10 −5 0 5 10

Fig. 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 ?

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 « thermodyna-
mique » 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 conserve
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 nombre 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 permettre
d’explorer un grand nombre de configurations (si la
température est élevée, la probabilité p0→1 est plus fa-
cilement proche de un), puis on l’a « refroidi » progressi-
vement 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 distance
Fig. 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 ?
parcourue finale soit la plus courte possible. Le recuit si-
mulé 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 susceptible 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 efficace dans le cas où il existe une,
ou un très petit nombre de solutions, bien définies (fig.
4.53).
Une autre application parfois intéressante est ce que l’on
appelle le « Monte-Carlo inverse » pour laquelle la fonction
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
positions 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 va-
leurs 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 sou-
haitable 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
96 Licence de physique L3 : Physique Fondamentale & 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
Fig. 4.53 – Le problème du voyageur de commerce, traité
0.4 0.4

0.3 0.3
par recuit simulé comme dans la figure 4.52, mais dans
0.2 0.2 un cas -des villes réparties sur un cercle- où la meilleure
0.1 0.1 solution est facile à deviner : ici la méthode par recherche
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 au hasard aboutit à un résultat assez peu convaincant, le
1 1

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

0.5 0.5

0.4 0.4 et de l’utiliser sans plus poser de question : c’est proba-

0.3 0.3
blement la meilleure façon de gagner du temps ! Si un tel
0.2 0.2
programme n’est pas disponible, on peut tenter d’utili-
0.1 0.1

0 0
ser la commande Unix sort sur un fichier, c’est efficace
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
T=0.0625
1
T=0.03125
mais pas toujours très souple d’emploi. Sinon, en général,
0.9 0.9 un algorithme du type Quicksort devrait donner satisfac-
0.8 0.8
tion : on partitionne en un endroit donné le tableau que
0.7 0.7

0.6 0.6
l’on veut trier et l’on en permute les éléments de telle
0.5 0.5
façon que tous les éléments précédents la partition soient
0.4 0.4 inférieurs à la valeur de l’élément frontière, et tous les
0.3 0.3 suivants supérieurs. On trie alors chaque sous-tableau en
0.2 0.2
refaisant une autre partition dans chacun d’eux, etc. : c’est
0.1 0.1
une logique qui ressemble un peu à celle des FFT et elle
0 0
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
en partage l’efficacité. Voir à ce sujet Numerical Recipes
T=0.015625 T=0.0078125
0.9 0.9 ref. [3] dans la bibliographie.
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

Fig. 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 à visi-
ter. 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. . .

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
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 large-
ment les quelques minutes de temps de calcul sur un PC !
Là commence ce que l’on peut appeler « le monde du cal-
cul 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 rai-
sonnables ; 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 per-
mettent d’utiliser au mieux l’architecture et les capa-
cités de calcul de nos machines : c’est un volet plutôt
« informatique ».
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
continu 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)
∂x2 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
comportant plusieurs matériaux d’indices différents ou
bien des matériaux inhomogènes dont l’indice peut va-
rier continû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 : Physique Fondamentale & 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’hydrodyna- vϕ (i δx ) = vi
mique 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 so- ∂E(x, t) Ei+1,j − Ei,j
lide 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-à- ce sont deux approximations possibles, équivalentes mais
dire d’équations différentielles de plusieurs variables qui qui n’ont pas exactement la même valeur. . . en fait, il fau-
contiennent des dérivées partielles comme : drait 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 rai- et en remplaçant les dérivées premières par les expressions
sons diverses, on ne sait pas les résoudre. Cependant, il (5.5) et (5.6), on obtient aisément l’approximation :
existe deux classes principales de méthodes pour s’y atta-
quer : les méthodes de différences finies et les méthodes ∂ 2 E(x, t) Ei+1,j + Ei−1,j − 2Ei,j
≃
d’éléments finis. L’on mentionnera également les méthodes ∂x2 δx2
dites spectrales.
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
vi δ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 propagation
onde électromagnétique dans un milieux unidimensionnel à travers une lame transparente d’un paquet d’ondes gaus-
(eq. (5.1) ) : il faut d’abord discrétiser le temps et l’espace, sien avec les réflexions sur les dioptres. On y voit bien sûr
le ralentissement du paquet dans le diélectrique (la pente
x = i δx t = j δt est plus forte, autrement dit, il faut plus de temps pour
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
Fig. 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).

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

ondes incidentes et réfléchies.
On pourrait, par exemple, compliquer le problème en − κi+1 − κi−1 + 4κi Ti+1 +2κi Ti − −κi+1 + κi−1 + 4κi 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 ordre
température en chaque point, or, le nombre d’équations et
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 : Physique Fondamentale & 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
   

T =  Ti   Q =  −Q̇i δx 
 2 méthodes sophistiquées pour résoudre le système linéaire !

 .   .. 
 ..   . 
5.2.2.3 Contourner le schéma implicite
Tn 2
−Q̇n δx
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 porelle du système au lieu de tenter de calculer d’emblée
exemple : une situation d’équilibre où tous les points dépendent les
uns des autres. Avec une équation d’évolution, on part
T0 = Ta et Tn+1 = Tb
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φ
∂t
seule contrainte étant alors Q̇(x).
c’est-à-dire que la variation temporelle locale de
On fait appel alors à un sous-programme de bi-
température (multipliée par la capacité calorifique C d’une
bliothèque, ou bien pris dans un manuel de « recettes
cellule) est la production locale de chaleur diminuée de la
numériques », capable de résoudre le système (5.9). Si n
est grand, le système est parfois lourd à résoudre, cepen- chaleur qui s’écoule hors de la cellule. En combinant cela
avec la loi de Fourier (5.2), on obtient :
dant, la matrice A comporte principalement des zéros (on
dit qu’elle est creuse), et dans le cas présent elle est tridia- ∂T (~r)  
C ~ T (~r)
= Q̇(~r) − div κ(~r) grad
gonale 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.

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

en fixant des conditions de température fixes aux deux
extrémités (T (x = 0) = 2 et T (x = 1) = 0) et sans
production de chaleur. La conductivité κ dépend de x.
On retrouve le résultat connu que la température varie
linéairement tant que κ est constant, un changement de
pente ayant lieu à chaque changement de valeur de la
conductivité.
Ce schéma est appelé implicite puisqu’on n’ob-
tient pas d’expression du type Ti = . . ., comme
précédemment, mais un système d’équations qu’il faut
résoudre numériquement.
Si l’on veut résoudre un problème à trois dimensions, la
méthode est la même dans le principe, la mise un œuvre
étant un peu plus lourde. Les indices (ℓ, m) de A de-
viennent composites : m ↔ (i, α) ; α ∈ {x, y, z} et en
Fig. 5.3 – Évolution temporelle de la distribution de
la température dans le cas représenté par la figure 5.2.
L’état initial est donné par T = 0 sur tout le barreau
sauf à la deuxième extrémité où elle vaut 2. Le système
évolue spontanément vers la situation d’équilibre trouvée
précédemment.
L’avantage d’une telle procédure est d’éviter les risques
d’instabilité numérique liés à la résolution du système
d’équations, mais l’inconvénient en est un coût en res-
sources de calcul qui peut s’avérer prohibitif.
5.2.2.4 Questions de stabilité
Même les schémas explicites peuvent parfois réserver
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
2
ce problème est ψ ℓ+1 puisqu’on cherche la fonction d’onde
2
∂ψ(x, t) h̄ ∂ ψ(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 :  
..
.  Fig. 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 paquet
ψ =
ℓ
 ψjℓ   gaussien centré en x = 0.5. Cette figure montre les pre-
 .. 
 .  miers pas de la simulation : on voit la la densité de probabi-
 
.. lité de présence s’élargir de préférence du côté du puits de
. potentiel, mais une partie continue à passer de l’autre côté.
Tout cela est fort beau. . . mais le défaut d’une telle On voit également les réflexions sur les parois (l’échelle des
méthode est qu’elle est instable ! On peut tenter de la 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 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

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

3.16
1 x et à l’instant t, ρ sa masse volumique, E le module
1 0.316 d’Young 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 poutre1 . 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
Fig. 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ℓ 
Fig. 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ödin-
ger que tenter d’écrire des équations aussi symétriques que soit, au coefficient δx4 près, les carrés des pulsations propres
possible pouvait arranger des choses. Une autre précaution ωp du système harmonique, c’est-à-dire les pulsations aux-
à prendre est d’essayer de faire que l’énorme matrice que quelles le système peut vibrer. Les vecteurs propres Up
l’on cherche à inverser ou diagonaliser soit « aussi diago- donnent les déplacements de la poutre pour chaque « mode
nale que possible » : autrement dit s’efforcer de rendre les propre » de pulsation propre ωp .
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 ce qui donne :
peuvent 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 .. .. .. .. ρ(~r) = ρ̃(~q) e−i~q.~r d3 ~q
 0 . . . . 0 

.. .. .. ..
0 0 0 . . . . En utilisant les transformées inverses, l’équation de Pois-
  son se reécrit :
ζ1 Z Z
 ..  2 q.~
r 3
 .  ∇ Ṽ e −i~
d ~r = − ρ̃ e−i~q.~r d3~r
 
Z=
 ζℓ  
 ..  soit après une dérivation sous l’intégrale :
 .  Z Z
ζn
−|~q|2 Ṽ e−i~q.~r d3~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 et :
valeurs propres, celles de D sont les mêmes que celles de A, ρ̃(~q)
Ṽ (~q) =
seulement les vecteurs propres donnent les déplacements |~q|2
pondérés par c(x) : il suffit d’en tenir compte (voir par extrêmement facile à résoudre. . . La méthode consiste
exemple la figure 5.7). donc à calculer d’abord la transformée de Fourier de ρ(~r),
diviser le résultat par |~q|2 puis retransformer par Fourier
0.1
1 inverse pour obtenir le potentiel V (~r). Tout ceci est très
0.08 2
3
4 efficace et rapide. En ~q = 0, on a :
0.06 5
6 Z
0.04
Ṽ (~q = 0) = V (~r)d3~r
0.02
0
il s’agit simplement de définir la constante arbitraire qui
−0.02
intervient dans le potentiel.
−0.04 Malheureusement, les choses sont parfois un peu re-
−0.06 torses comme on peut le constater sur la figure 5.8 puisque
−0.08 les deux charges placées sur un axe horizontal donnent un
−0.1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
potentiel qui n’a pas la même symétrie, ce qui est fâcheux !

Fig. 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 ra-
pides 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 : Fig. 5.8 – Calcul par une méthode spectrale à deux dimen-
Z sions du potentiel électostatique produit par deux charges.
i~
q .~
r 3
Ṽ (~
q ) = V (~r) e d ~r
En revanche, le même calcul par différences finies (figure
5.9), bien qu’exigeant sensiblement plus de temps calcul
où le symbole d3~r indique qu’il s’agit d’un intégration sur
(c’est un schéma implicite qui requiert la résolution d’un
les trois coordonnées d’espace. De même :
système linéaire 4096 × 4096, puisque le carré de 64 × 64
Z
donne 642 = 4096 mailles) fournit un résultat bien plus
q ) = ρ(~r) ei~q.~r d3~r
ρ̃(~ satisfaisant.
104 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

comme indiqué à la fin du paragraphe 5.2.2.2. Il faut tou-

tefois 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 relati-
vement 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.

Fig. 5.9 – Calcul par une méthode de différences finies du

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

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-
Fig. 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 dans
h̄2 ψ̃(ω, ~
q)
−h̄ω ψ̃(ω, ~q) = − 2
+ q′ − ~
Ṽ (~ q )ψ̃(ω, ~q′ )d~
q′ l’équation (5.4), on approxime la fonction f (x, y, z) re-
2m q cherchée par un développement local sur une base de fonc-
avec des notations similaires à ce qui précède. On obtient tions. On fait ainsi un maillage de l’espace (voir la figure
sans grande surprise un produit de convolution. Celui-ci 5.10), en général avec de petits tétraèdres de tailles va-
peut être très rapide à calculer si Ṽ (~ q ) est bien localisé riables de telle façon que la géométrie du maillage suive
(i.e. V (~r) varie lentement) et donc l’intégrale aisée à cal- d’assez près celle du problème : dans le cas de l’aile d’avion,
culer ; au contraire, si V (~r) est localisé, avec des variations par exemple, les « mailles » seront plus petites et plus res-
rapides, le produit de convolution dans l’espace réciproque serrées près du bord d’attaque de l’aile, là où le flux d’air
sera extrêmement laborieux à obtenir. . . on retrouve ici la subit les déviations les plus brutales, les champs de vitesse
bonne vieille propriété des transformées de Fourier : avec et de pression présentent des variations importantes.
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’espace ϕj (x, y, z) :
réciproque (l’espace des ~ q ) est plus efficace. X p
f (x, y, z) ≃ vj ϕj (x, y, z), (x, y, z) ∈ Mp
j
5.2.4 Introduction aux éléments finis
les vjp étant les coefficients du développement dans cette
Pratiquement tous les exemples ci-dessus sont unidi- maille.
mensionnels pour des raisons de simplification évidente. Le Comme les fonctions ϕj sont connues, choisies par l’uti-
passage à trois dimensions peut se faire dans tous les cas lisateur, leurs dérivées partielles sont calculables et les
Physique numérique, Philippe Depondt 105

dérivées partielles de f s’écrivent : à une échelle suffisamment grande pour que la structure
atomique de la matière n’intervienne pas. Lorsqu’on se
∂f (x, y, z) X p ∂ϕj (x, y, z)
≃ vj préoccupe de question se situant à une échelle plus petite,
∂x j
∂x il faut bien sûr adopter une modélisation appropriée où la
matière est considérée comme constituée d’atomes.
Très souvent, les fonctions ϕj sont tout simplement des
polynômes de telle façon que leurs dérivées soient faciles
à obtenir. 5.3.1 Matrice dynamique
En général, on se retrouve avec un très grand système On a vu, à propos des problèmes de valeurs propres (§
d’équations à résoudre dont les inconnues sont les coeffi- 4.5.4), que beaucoup de questions pouvaient se ramener à
cients vjp . un problème de matrice dynamique dont on cherche les va-
A titre d’exemple, le problème du paragraphe 5.4 est leurs propres et les vecteurs propres. Pratiquement tous les
traité ici, bien qu’il soit absurde d’utiliser les éléments fi- problèmes d’oscillateurs harmoniques couplés peuvent être
nis dans ce cas qui se résout facilement par différences avantageusement abordés de la sorte. Plusieurs problèmes
finies ! Il s’agit simplement de montrer ici le principe de la de cet ordre, suffisamment différents pour montrer la force
méthode. Dans ce cas, les mailles sont de nouveaux des pe- de cette approche, sont décrits ci-dessous.
tits intervalles d’indice p. Sur un intervalle, la température
s’écrit : 5.3.1.1 La chaı̂ne unidimensionnelle désordonnée
T (x) = ap x2 + bp x + cp
Considérons d’abord la dynamique d’une chaı̂ne uni-
si
δx δx dimensionnelle harmonique d’atomes : le problème est
xp − p < x < xp + p , δxp = xp − xp−1 mathématiquement assez proche de celui du paragraphe
2 2
5.2.2.6. La chaı̂ne est représentée en figure 5.11 ; l’équation
où xp est le milieu du p-ième intervalle. La température
du mouvement en est bien connue :
n’est donc pas considérée comme une constante dans
l’intervalle comme c’était le cas avec la méthode des
mẍℓ = κ(xℓ+1 − xℓ ) + κ(xℓ−1 − xℓ )
différences finies. La base de fonctions est ici limitée à trois
monômes de degrés 0, 1 et 2. Les inconnues sont les coeffi- où m est la masse des atomes tous identiques, κ la rai-
cients ap , bp et cp . Dans le p-ième intervalle, l’équation de deur des «ressorts » et xℓ le déplacement par rapport à
diffusion de la chaleur (5.8) s’écrit en tenant compte des sa position d’équilibre de l’atome ℓ. La distance entre les
expressions des dérivées : 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 : Fig. 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
ap+1 (xp + δxp+1 )2 + bp+1 (xp + δxp+1 ) + cp+1 type onde plane où ω est la pulsation de l’onde, q son
De même les dérivées premières : vecteur d’onde :

2ap (xp + δxp+1 ) + bp = 2ap+1 (xp + δxp+1 ) + bp+1 xℓ = x0 ei(ωt−qℓa)

On obtient ainsi un système de 3n équations à 3n incon- et l’on obtient l’équation de dispersion habituelle :
nues (puisque l’on à une base de 3 fonctions, cela n’a rien r 
à voir avec la dimensionnalité) que l’on peut résoudre par κ  qa 
les méthodes habituelles.
Si le principe en est simple, l’écriture de programmes
d’éléments finis est assez lourde. Le maillage à lui seul
n’est pas simple. Il s’agit cependant d’un problème assez
modulaire sur le plan informatique : le choix du maillage,
par exemple, est pratiquement indépendant du traitement
à proprement parler des équations aux dérivées partielles.
Ainsi, les utilisateurs semblent préférer utiliser des pro-
grammes déjà existants qui, en général, s’adaptent assez
bien à chaque problème particulier. Point n’est besoin de
réinventer ce qui existe déjà !
5.3 La matière comme une collec-
tion de particules.
Tous les problèmes ci-dessus, à l’exception bien sûr de
l’équation de Schrödinger, reposent sur une modélisation
ω=2 sin 
m 2
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
types différents, κ et m dépendent du site ℓ : κ doit être
remplacé par κℓ,ℓ+1 (la raideur entre les sites ℓ et ℓ + 1)
et m par mℓ ,
mℓ ẍℓ = κℓ,ℓ+1 (xℓ+1 − xℓ ) + κℓ−1,ℓ (xℓ−1 − xℓ )
On peut tenter une résolution analytique par des
méthodes perturbatives, mais le cas d’un fort désordre
paraı̂t difficile à traiter et la généralisation à trois dimen-
sions problématique (car le problème est en général traité
à l’aide d’une méthode dite de « matrice de transfert »
intrinsèquement unidimensionnelle.)
Toutefois, on peut aussi poser :
uℓ
xℓ = √ eiωt
mℓ
106 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

on se débarrasse alors de la dépendance temporelle, de structure dynamique » dont les maxima fournissent ce
mais on ne postule plus la périodicité spatiale comme qui tient lieu de « courbe de dispersion » (figure 5.12) qui
précédemment, puisque uℓ dépend de ℓ, c’est-à-dire du ressemble à ce que pourrait donner une expérience, par
site. On obtient le système d’équations suivant : exemple, de diffusion inélastique de neutrons.
On peut également regarder, ce qui paraı̂t pour le moins
κℓ,ℓ−1 difficile à réaliser expérimentalement, les mouvements cor-
ω 2 uℓ = −√ uℓ−1 respondants à différents points de la figure 5.12 : par
mℓ−1 mℓ
κℓ+1,ℓ + κℓ,ℓ−1 κℓ+1,ℓ exemple, en figure 5.13.
+ uℓ − √ uℓ+1
mℓ mℓ mℓ+1

La matrice dynamique D de dimension n × n composées

des coefficients du système s’écrit :

D=
 
.. ..
. . 0 0 0
 
 .. .. .. 
 . . . 0 0 
 κℓ,ℓ−1 κℓ+1,ℓ + κℓ,ℓ−1 κℓ+1,ℓ 
 0 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 ! (sur-
tout si la matrice est creuse, ce qui est toujours le cas –à
1-D, elle est même tridiagonale–).

40
20
10
3 5
Fig. 5.13 – Deux vecteurs propres. En haut, un vecteur
2.5 propre du début de la courbe de dispersion (ω ≃ 0,6), peu
affecté par le désordre. En bas, un vecteur propre non-
2
propagatif, localisé sur des impuretés (ω ≃ 2,2).
1.5 freq
1 Ainsi, l’on peut directement établir une relation entre
0.5 des résultats « expérimentaux » et des processus qui ont
lieu au niveau microscopique.
0
0 0.5 1 1.5 2 2.5 3 .
q
5.3.1.2 Dynamique d’une molécule
Fig. 5.12 – Facteur de structure dynamique d’une chaı̂ne
désordonnée de 100 atomes. Cela revient à la courbe de La dynamique d’une molécule unidimensionnelle à trois
dispersion d’une onde acoustique dans la chaı̂ne. On ob- atomes sera d’abord décrite pour préciser les principes de
serve une branche « normale » pour les basses fréquences la méthode de façon schématique, puis on généralisera à
et une composante à haute fréquence due au désordre (les des cas plus généraux.
impuretés dans cet exemple étant plus légères).
5.3.1.2.1 À une dimension, trois atomes. Soient
La matrice U donne les déplacements atomiques en
donc trois atomes alignés, de masses m1 , m2 et m3 . Ils
fonction du numéro du site, autrement dit de la position
sont liés par un potentiel harmonique, de telle façon que
ri = a×i : une transformée de Fourier spatiale des vecteurs
l’énergie potentielle d’interaction entre 1 et 2 s’écrive
propres doit donc donner quelque chose qui dépend du vec-
teur d’onde q, or il y a également dépendance en fonction 1
de la pulsation ω. On obtient alors S(q, ω), le « facteur V12 = k(x1 − x2 )2
2
Physique numérique, Philippe Depondt 107

où x1 et x2 sont les déplacements des atomes 1 et 2 par 5.3.1.2.2 À trois dimensions, N atomes. On
rapport à leur position d’équilibre. De même, réalise, à la lumière de l’exemple ci-dessus, que dès que
la matrice dynamique a une dimension qui dépasse 3,
1 ′ 2 le calcul devient inextricable, or la dimension de D est
V23 = k (x2 − x3 )
2 le nombre de degrés de liberté du système : pratique-
ment toutes les molécules échappent à cette analyse !
k k’
Évidemment, comme cela a déjà été montré, la résolution
numérique est beaucoup plus aisée.
Essayons de poser le problème de façon plus générale :
m1 m2 m3 soit une molécule de N atomes de masses mℓ situées
On néglige l’interaction entre 1 et 3. Les équations du aux coordonnées ~rℓ . On suppose que l’on est capable de
mouvement s’écrivent simplement : calculer l’énergie potentielle du système V ({~rℓ )}, ℓ ∈
[1, N ]. On suppose également que l’on connait les positions
(0)
m1 ẍ1 = k(x2 − x1) d’équilibre des atomes ~rℓ . Afin de simplifier les notations,
m2 ẍ2 = k(x1 − x2) + k ′ (x3 − x2 ) 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
où α indice les trois coordonnées de l’espace. L’indice k
pose :
varie de 1 à 3N , c’est-à-dire le nombre de degrés de liberté
u1 iωt du système. Les équations du mouvement2 s’écrivent :
x1 = √ e
m1
∂V
u2 iωt mk q̈k = − ∀k ∈ [1, 3N ]
x2 = √ e ∂qk
m2
u3 Les dérivées sont prises en {qk } : comme on s’intéresse à
x3 = √ eiωt
m3 un système harmonique, on peut faire un développement
(0)
limité autour de la position d’équilibre {qk },
ainsi :
√ u2 u1 ∂V ∂V (0)
X ∂2V (0)
− m1 ω 2 u1 = k( √ −√ ) ({qk′ }) = ({qk′ }) + ′′ ({qk′ })(qk − qk )
′′
m2 m1 ∂qk ∂qk ∂q k ∂qk
k′′
√ u1 u2 u3 u2
− m2 ω 2 u2 = k( √ − √ ) + k′ ( √ −√ )
m1 m2 m3 m2 Les dérivées de l’énergie potentielle à l’équilibre
√ u 2 u 3 ∂V (0)
− m3 ω 2 u3 = k( √ −√ ) ({qk′ }) sont nulles, et les équations du mouvement
m2 m3 ∂qk
se reécrivent :
En termes matriciels : X ∂2V (0) (0)
   k  m k q̈k = ′ ({qk′′ })(qk − qk′ )
′
− √ k 0 ∂q k ∂q
u1 m 1 m 1 m 2 k ′ k
 k+k′
− √mk2 m3 
′
U =  u2  D =  − √mk1 m2 m2 
(0)
u3 0
′
− √mk2 m3 k′ En posant xk = (qk − qk ) (les déplacements par rapport
m3
à l’équilibre), on obtient :
et X
ω 2 U = DU mk ẍk = − Ck,k′ xk′ (5.12)
k′
La recherche des valeurs propres revient à la recherche
des racines de |D − ω 2 I| = 0 : a priori, cela donne un où Ck,k′ est la matrice des dérivées secondes de l’énergie
polynôme en ω 6 , mais compte tenu de la solution ω = 0 potentielle, ce qui nous ramène à une forme familière : il
correspondant à la translation d’ensemble de la molécule reste à appliquer la procédure habituelle,
(car |D| = 0), on obtient une équation bicarrée en ω : uk
xk = √ eiωt
mk
′
k(m 1 + m 2 ) + k (m 2 + m 3 ) m 1 + m 2 + m 3
ω4− ω 2 +kk ′ = 0 et
m1 m2 m3 m1 m2 m3 X Ck,k′
ω 2 uk = √ uk ′
soit mk mk ′
k′
1 k(m1 + m2 ) + k ′ (m2 + m3 )
ω2 = × soit, comme avant :
2 m1 m2 m3
s ! ω 2 U = DU
m 1 m 2 m 3 (m 1 + m 2 + m 3 )
1 ± 1 − 4kk ′
k(m1 + m2 ) + k ′ (m2 + m3 ) Il est aisé de vérifier que la matrice D est symétrique.
Il « suffit » de réinjecter ces solutions dans l’équation aux 2 Ici, les variables sont des variables spatiales (x, y, z), mais, fort

valeurs propres pour obtenir les vecteurs propres et les souvent dans les systèmes mécaniques comportant par exemple des
contraintes, la situation est plus complexe : on a alors souvent intérêt
déplacements atomiques correspondant à chaque valeur d ∂L ∂L
propre. à utiliser les notations Lagrangiennes : L = K − V et = .
dt ∂ q̇ℓ ∂qℓ
108 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Si le formalisme est nettemement plus lourd que X ∂2V ∂Sℓ ∂Sℓ′

=
précédemment, la physique est sensiblement la même ; ce- ∂Sℓ ∂Sℓ′ ∂xk ∂xk′
ℓ,ℓ′
pendant la méthode qui vient d’être exposée a le mérite X
d’être d’utilisation quasiment automatique, à partir de la ∂2V
= gk,ℓ gk′ ,ℓ′ (5.13)
connaissance des potentiels d’interaction et des positions ∂Sℓ ∂Sℓ′
ℓ,ℓ′
d’équilibre3 .
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
1 le calcul de l’énergie et de ses dérivées et « naturelle »),
mais aussi celui entre les coefficients de couplage dans les
2 deux systèmes.
0 Il reste à définir les Sℓ .
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
Fig. 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. ~si,ℓ = ~eℓ si i = ℓ ℓ ∈ [1, 4]
Imaginons, par exemple, une molécule tétraèdrique ~s0,ℓ = −~eℓ ℓ ∈ [1, 4]
(fig. 5.14) : a priori, comme on a 5 atomes et trois degrés ~si,ℓ = 0 sinon.
de liberté par atomes, soit quinze degrés de liberté en  x 
tout, la matrice dynamique est (15 × 15). Toutefois la si,ℓ
translation et la rotation d’ensemble de la molécule ne où ~si,ℓ =  syi,ℓ .
nous intéressent pas : 3 degrés de liberté translationnels szi,ℓ
et 3 degrés de liberté rotationnels (pour une molécule tri- Les angles entre les liaisons paraissent aussi être des va-
dimensionnelle) ne sont pas pertinents ; de façon générale, riables assez naturelles, mais c’est un peu plus compliqué
pour une molécule à N atomes, on doit aboutir à 3N −6 va- puisqu’un simple dénombrement donne θ12 (l’angle 102 d de
riables internes et une matrice dynamique (3N − 6 × 3N − sommet l’atome 0 qui se situe entre les liaisons 0 − 1 et
6), soit (9 × 9) ici. Comme nous sommes dans une approxi- 0 − 2), θ13 , θ14 , θ23 , θ24 , θ34 , c’est-à-dire six angles, or il
mation harmonique, on considère que les déplacements n’en faut que cinq puisqu’on a déjà quatre variables S1 à
~i , ∀i ∈ [1, N ] des atomes par rapport à leurs positions S4 et qu’on en attend 9 en tout : c’est que ces angles ne
ρ
d’équilibre ~ri sont petits, ainsi on peut écrire une relation sont pas indépendants. On peut poser
linéaire entre les variables internes Sℓ , ℓ ∈ [1, 3N − 6] et
~i − ~r0 − ρ
~ri + ρ ~0 ~hi
les déplacements atomiques : ~εi = =
|~ri + ρ
~i − ~r0 − ρ ~0 | |~hi |
XN X
Sℓ = sα α
i,ℓ ρi La différence entre ~εi et ~ei est que le premier comprend les
i=1 α=x,y,z déplacements ρ ~i : à l’équilibre ces vecteurs sont identiques.
On a :
où α représente les trois directions de l’espace et les sα i,ℓ cos θi,j = ~εi · ~εj
sont les coefficients de ce développement au premier ordre.
Si l’on écrit comme précédemment k = 3(i − 1) + α et On peut différencier cette expression :
xk = ρα i , alors d (cos θi,j ) = − sin θi,j dθi,j = d~εi · ~εj + ~εi · d~εj
X
Sℓ = gℓ,k xk avec gℓ,k = sα où
i,ℓ
k
d~hi |~hi | − ~hi d|~hi |
d~εi =
|~hi |2
ou q 
S =G·x 1 2~hi · d~hi
or d~hi = ρ~i − ρ~0 , et d|hi | = d |~hi |2 = =
2 |~hi |
en notations matricielles. A priori, la matrice G n’est pas
carrée puisqu’elle est (3N − 6 × 3N ). ~ei · (~
ρi − ρ~0 ) = Si , ainsi :
Ainsi les ceofficients qui apparaissent dans l’équation ~i − ρ
ρ ~0 Si
(5.12) peuvent s’écrire : d~εi = − ~ei
|~ri − ~r0 | |~ri − ~r0 |
∂2V En posant que les éléments différenciels dθi,j = ηi,j sont les
Ck,k′ = variations angulaires correspondant au mouvements dits
∂xk ∂xk′
« de libration », on obtient après quelques lignes de calcul :
3 Voir par exemple : E. B. Wilson Jr., J. C. Decius, P. C. Cross,

Molecular vibrations (1955) reéd. Dover (1980), chap. 4. |~ei ∧ ~ej | ηi,j =
Physique numérique, Philippe Depondt 109
 
ρ~0 − ρ~i ~0 − ρ~j
ρ Si Sj s’écrivent alors
· ~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 = −
|~e1 ∧ ~e2 | |~r2 − ~r0 | |~r1 − ~r0 | on peut généraliser sans difficultés. . . autres que « tech-
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 :

1X
4
1X uk
ρk }) =
V ({~ ~0 ) 2 +
ρi − ρ
ki (~ 2
cij ηij (5.14) xk,ℓ = √ ei(ωt−q(ℓa+Xk ))
2 i=1 2 mk
i = 1, 3
où q est le vecteur d’onde de l’onde plane. Jusqu’ici, nous
j = i + 1, 4
10
X n’avons rien fait de nouveau par rapport à la chaı̂ne unidi-
1 mensionnelle à un type d’atomes, sinon des aménagements
= ki Si2
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  
2 −iqX1 up −iq(Xp −a) u1 −iqX1
(5.13). −ω u1 e = cp,1 √ e − e +
m1 mp m1
On constate que, dans cet exemple, la difficulté ne tient  
u2 u1 −iqX1
pas tant à la méthode elle-même qui n’a rien de parti- c2,1 √ e−iqX2 − e
m1 m2 m1
culièrement nouveau par rapport à ce que l’on a déjà vu  
dans les paragraphes précédents, mais dans une mise en 2 −iqXk uk−1 −iqXk−1 uk −iqXk
−ω uk e = ck−1,k √ e − e +
œuvre de la géométrie de la molécule. mk mk−1 mk
 
uk+1 uk −iqXk
ck+1,k √ e−iqXk−1 − e
5.3.1.3 Dynamique de réseau mk mk+1 mk
 
Cette technique qui utilise la matrice dynamique est −ω 2 up e−iqXp = cp−1,p √ up−1 e−iqXp−1 − up e−iqXp +
extensible à un réseau périodique d’atomes, c’est-à-dire mp mp−1 mp
 
un cristal. Elle recouvre que qu’on appelle la « dyna- u1 −iq(Xp +a) up −iqXp
c1,p √ e − e
mique de réseau » et elle est très utilisée pour interpréter mp m1 mp
des expériences de spectroscopie optique ou neutronique
qui servent à déterminer les modes de vibrations présents Après quelques manipulations simples, cela donne :
dans des systèmes qui peuvent être assez compliqués. cp,1 e−iq(Xp −X1 −a) cp,1 + c2,1
Sa limite cependant est que les interactions entre les ω 2 u1 = − √ up + u1
m1 mp m1
atomes doivent pouvoir être traités dans l’approxima-
tion harmonique ce qui impose plusieurs contraintes : c2,1 e−iq(X2 −X1 )
− √ u2
que les positions d’équilibre soient déjà connues, donc la m1 m2
structure microscopique du matériau établie et que les ck−1,k e−iq(Xk−1 −Xk ) ck−1,k ck+1,k
déplacements atomiques restent suffisamment petits pour ω 2 uk = − √ uk−1 + uk
mk mk−1 mk
qu’un développement limité au premier ordre des forces
soit possible. ck+1,k e−iq(Xk−1 −Xk )
− √ uk+1
Prenons, pour simplifier les notations, le cas unidimen- mk mk+1
sionnel : nous avons une chaı̂ne unidimensionnelle infinie cp−1,p e−iq(Xp−1 −Xp ) cp−1,p + c1,p
(et non finie comme dans le § 5.3.1.2.1) avec p atomes ω 2 up = − √ up−1 + up
mp mp−1 mp
par maille, ces mailles étant indéfiniment répétées. Chaque
atome est en principe repéré par 2 indices, ℓ le numéro de c1,p e−iq(X1 −Xp +a)
− √ u1
la maille (qui va de −∞ à +∞) et k le numéro de l’atome mp m1
dans la maille ℓ (k ∈ [1, p]). La position d’équilibre de
l’atome k, ℓ est donc On constate qu’une fois de plus on tombe sur un
problème aux valeurs propres, la matrice dynamique étant
Xk,ℓ = ℓa + Xk maintenant p × p, donc a priori moins grosse qu’avant. . .
toutefois, comme le vecteur d’onde apparaı̂t dans la ma-
où a est le paramètre de maille et Xk la position dans la trice, il faudra résoudre le problème un grand nombre de
maille. Les déplacements des atomes par rapport à ces po- fois, soit une fois pour chaque valeur souhaitée du vec-
sitions d’équilibre sont xk,ℓ ; les équations du mouvement teur d’onde. La matrice dynamique elle-même est devenue
110 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

complexe à cause des termes en eiqx , toutefois les termes Il existe cependant une solution : les tirages au sort ou
symétriques par rapport à la diagonale sont conjugués Monte-Carlo comme on l’a vu au paragraphe 4.11.6.
l’une de l’autre : la matrice est hermitique et il suffira
de choisir un sous-programme de bibliothèque approprié.

5.3.2 Simulations Monte-Carlo.

Dans un autre ordre d’idées, on peut ne pas connaı̂tre
la structure microscopique d’un matériau et donc la
chercher sans se préoccuper de la dynamique. Si l’on
connait les constituants de ce matériau, on peut recher-
cher l’état d’équilibre de ce système d’atomes à condition
de connaı̂tre les potentiels d’interaction atome-atome :

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 Fig. 5.16 – Système de spins posés sur un réseau triangu-
potentielle de deux atomes i et j connaissant leur distance laire, par simulation Monte-Carlo. Une structuration com-
ri,j , mais il arrive que l’on doive faire des choses plus com- plexe en vortex s’établit (E. Yu. Vedmedenko, A. Ghazali,
pliquées pour tenir compte du fait, par exemple, que l’in- J.-C.S. Lévy Phys. Rev. B 59 (1999) 3329).
teraction entre deux atomes puisse être perturbée par la
présence d’un troisième.
Les applications en sont nombreuses, voir par exemple la
f 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
transitions de phase. On peut également introduire dans
l’énergie potentielle des contraintes comme la pression
extérieure et faire des études en fonction de cela.
Contrairement à ce que l’on pourrait penser, cette
méthode est relativement rapide par rapport à d’autres
méthodes microscopiques. On est, certes, dans le domaine
du calcul lourd, les temps de calcul se chiffrent en heures
ou en jours, mais on a, avec un ordinateur moyennement
puissant, la possibilité de traiter des « gros » systèmes, jus-
qu’à environ un million d’atomes, ce qui est largement suf-
fisant pour un nombre incroyablement élevé de problèmes.
La restriction principale vient de ce qu’on n’a pas accès
aux mouvements atomiques en fonction du temps ou aux
x fréquences des modes de vibration, ou seulement de façon
très indirecte.
Fig. 5.15 – Quand on recherche numériquement le mi-
nimum d’une fonction, on part d’un point de départ et
l’on fait une analyse locale de la fonction afin de trou-
ver un point –meilleur– qui peut servir de nouveau point
de départ (flèche pleine). La plupart des algorithmes est 5.3.3 Simulations de dynamique molé-
incapable de suivre la trajectoire indiquée par la flèche culaire.
tiretée. . .
Si l’on veut étudier la dynamique d’un système
C’est un problème de recherche du minimum d’une fonc-
d’atomes, le plus simple est de s’attaquer à la résolution
tion d’un grand nombre de variables, les positions ato-
numérique des équations du mouvement (classiques) de ce
miques ; il existe des méthodes pour faire cela (e.g. gra-
système :
dient conjugué), mais lorsqu’elles convergent vers un mini-
mum, il est très difficile de savoir s’il s’agit d’un minimum
local ou DU minimum de la fonction (figure 5.15) ! mℓ ~r̈ ℓ = f~ℓ (~r1 . . . ~rℓ′ . . . ~rN ), ∀ℓ ∈ [1, N ]
Physique numérique, Philippe Depondt 111

où :   vants (voir par exemple les figures 5.18 et 5.19) :

∂V nombre d’atomes : N ≃ 104
 ∂xℓ  longueurs d’onde accessibles : λ ≤ 10nm
 
 
f~ℓ = −grad~ V = −  ∂V  pas de temps d’intégration : δt ≃ 10−3 ps
ℓ  ∂yℓ  durée accessible : τ ≃ 103 ps
 
 ∂V  fréquences accessibles : 10−2 tHz ≤ ν ≤ 10tHz
∂zℓ A priori, on travaille à E = K + V = Cste et à volume
et, par exemple avec un potentiel d’interaction de paire de constant, mais on peut aussi fixer P et T . Maintenir la
type Lennard-Jones (figure 5.17) : pression constante, plutôt que le volume est utile pour si-
muler des transitions de phase ou des changements struc-
 12  6 ! turaux, voire simplement tenir compte de la dilatation.
1X 1X σij σij
V = V (~rij ) = εij −2 Maintenir la température constante permet de traiter par
2 i,j 2 i,j rij rij
exemple des phénomènes dissipatifs, tels que diffusion de
(5.16) la chaleur à l’échelle microscopique.
On a perdu, par rapport à la méthode de Monte-Carlo,
1 deux ordres de grandeur pour le nombre d’atomes maxi-
mum 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
−0.5 de systèmes fort différents et très divers comme les grains
d’un tas de sable ou les étoiles dans une galaxie !
−1

0 1 2 3 4 5 5.3.4 Simulations ab-initio.

Toutefois, la faiblesse des méthodes ci-dessus, simula-
Fig. 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
PBC d’un type d’atome donné n’est pas le même selon que
l’atome considéré est dans le cœur de l’échantillon ou
en surface : la forme de l’interaction de cet atome avec
Substrate Adsorbate ces voisins peut en être affectée
– des atomes ou des molécules dont les nuages
électroniques sont fortement modifiés par la présence
ou non d’autres atomes,
PB

– si l’on comprime le milieu de façon que les noyaux

C

se rapprochent suffisemment pour modifier les nuages

électroniques
– ...
On peut introduire des potentiels à trois corps, voire
Fig. 5.18 – Un exemple de simulation de dynamique plus, afin de tenir compte de l’effet que la présence d’un
moléculaire pour étudier le frottement d’un adsorbat sur troisième atome peut avoir sur l’interaction entre deux
un substrat. La substrat est constitué de 18×18×4 mailles autres atomes, on peut également introduire des charges
cubiques à faces centrées. Chacune des deux surfaces libres qui peuvent se déplacer dans certaines conditions : tous
est recouverte d’une monocouche de 288 atomes d’un autre ces modèles restent cependant assez phénoménologiques.
type (soit un total de 5760 atomes). L’on exerce des forces Toutefois, dès que l’on s’intéresse, par exemple, aux liens
extérieures opposées sur l’adsorbat et le substrat afin de entre propriétés structurales et propriétés électroniques
les faire glisser l’un sur l’autre (Ph. Depondt, A. Ghazali, d’un matériau, on peut aussi tenter de revenir aux prin-
J.-C. S. Lévy, Surf. Science 419 (1998) 29). cipes fondamentaux et faire ce que l’on appelle des si-
mulations ab-initio (à partir du début). Dans ce cas,
Avec un ordinateur « raisonnablement » puissant, l’on on ne fait pas d’hypothèse sur la forme des interactions
atteint sans difficulté majeure les ordres de grandeurs sui- mais on considère un ensemble de noyaux avec leurs
112 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Fig. 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.

nuages électroniques. En principe, on doit alors résoudre et l’équation de Schrödinger se reécrit comme avant
l’équation de Schrödinger de n noyaux de numéro ato-
Xn ψi+1,j,k − 2ψi,j,k + ψi−1,j,k
mique Zi et Zi électrons en interaction. −
δx2
i=1 ψi,j+1,k − 2ψi,j,k + ψi,j−1,k
−
δy 2
5.3.4.1 Une petite contrariété
ψi,j,k+1 − 2ψi,j,k + ψi,j,k−1
−
Malheureusement, on ne peut pas attaquer le problème δz 2
avec des méthodes comme celle étudiée dans le paragraphe +Vi,j,k ψi,j,k = E ψi,j,k
5.2.2.4 : il n’existe pas au monde d’ordinateur assez puis-
sant pour le faire ! Pour illustrer ce propos, revenons à Le triplet (i, j, k) prend alors n3 valeurs5 , ainsi la ma-
l’équation de Schrödinger indépendante du temps à une trice dont on cherche les valeurs propres est de dimension
dimension et à une particule dans un potentiel : c’est le n3 × n3 , soit 106 ×106 si n = 100 : le problème s’est brutale-
cas le plus simple. La fonction d’onde ψ qui décrit l’état du ment amplifié de façon démesurée. . ., et nous n’en sommes
système est une fonction à une variable, et l’on obtient4 : encore qu’à une seule particule ! Passons à un problème a
priori simple, l’atome d’hydrogène : un proton et un neu-
∂ 2 ψ(x) tron, soit deux particules en interaction, à trois dimen-
Hψ = Eψ ≡ − + V (x)ψ(x) = Eψ(x)
∂x2 sions, soit 6 variables. Le même raisonnement nous mène
à estimer l’ordre de grandeur du problème à 1012 × 1012
En discrétisant le problème de la façon habituelle,
(toujours avec 100 points par variable) : même avec un
xi = i δx, Vi = V (xi ), ψi = ψ(xi ) ordinateur très puissant, c’est sans espoir !
Conclusion : il ne suffit pas, pour résoudre un problème,
l’équation se reécrit : de « le mettre dans l’ordinateur » et d’attendre que la force
brute de la machine fasse son œuvre. Il faut donc faire des
ψi+1 − 2ψi + ψi−1 approximations.
− + Vi ψi = Eψi
δx2
Il est aisé de se convaincre que, chercher E et ψi , i ∈ 5.3.4.2 L’approximation de Born-Oppenheimer
[1, n], revient à chercher les valeurs propres et les vecteurs
propres d’une matrice (n × n) : si n est de l’ordre de 100, La première étape consiste à découpler les mouvements
voire davantage, il n’y a rien de bien extraordinaire à cela. des électrons de ceux des noyaux beaucoup plus lourds
Imaginons maintenant le même problème à trois dimen- et beaucoup plus lents (c’est l’approximation de Born-
sions : la discrétisation implique un triplet d’indices (i, j, k) Oppenheimer). Pour le mouvement des noyaux, on se
contente en général d’une dynamique classique. Cette dy-
xi = i δx, yj = j δy, zk = k δk namique est lente par rapport à celle des électrons, ainsi,
on fait l’hypothèse que le nuage électronique est toujours
ψi,j,k = ψ(xi , yj , zk ) Vi,j,k = V (xi , yj , zk ) 5 en général, on renumérote les sites pour n’avoir qu’un seul indice

2 ℓ = i + n(j − 1) + n2 (k − 1) dont on vérifie aisément qu’il varie de 1

4 en posant h̄ = 1. à n3 .
2m
Physique numérique, Philippe Depondt 113

en équilibre, qu’il s’adapte instantanément à un chan- C’est ce qu’on appelle la méthode de Hartree. Elle
gement de configuration des noyaux. D’un point de vue présente un énorme défaut : a priori, les électrons sont
quantique, il ne reste plus qu’à résoudre l’équation de des fermions et leur fonction d’onde devrait être anti-
Schrödinger électronique : pour l’hydrogène, on revient à symétrique, c’est-à-dire changer de signe par permutation
un problème à une particule. Le problème reste cependant de deux électrons :
entier dès lors que l’on s’intéresse à, ne serait-ce qu’un
atome d’hélium isolé. Il faut donc encore aller quelques ψ(~r1 , . . . , ~ri , ~rj , . . . , ~rn ) = −ψ(~r1 , . . . , ~rj , ~ri , . . . , ~rn )
pas plus loin : il existe à ce titre plusieurs approches pos-
Si l’on choisit de remplacer cette fonction d’onde par un
sibles. simple produit de fonctions mono-électroniques, il est clair
que cette propriété ne sera pas remplie. Pour régler cette
5.3.4.3 Les méthodes de Hartree et Hartree-Fock question, on remplace ce produit pas un déterminant, ap-
Imaginons d’abord, pour simplifier, une fonction à deux pelé déterminant de Slater :
 
variables ψ(x1 , x2 ) : on peut en faire un développement  χ1 (~r1 ) χ2 (~r1 ) . . . χn (~r1 ) 
 
à un ordre quelconque par rapport à x2 , sur une base de  χ1 (~r2 ) χ2 (~r2 ) . . . χn (~r2 ) 
ψ(~r , ~
r , . . . , ~
r ) ∼  
fonctions appropriées ϕℓ2 (x2 ) : 1 2 n  ... ... ... . . . 

X  χ1 (~rn ) χ2 (~rn ) . . . χn (~rn ) 
ψ(x1 , x2 ) = cℓ2 ϕℓ2 (x2 )
ℓ2 qui assure la propriété d’antisymétrie : si l’on permute
deux électrons, cela revient à permuter deux lignes et
mais, évidemment, les coefficients du développement cℓ2
donc à changer le signe du déterminant. Ainsi corrigée,
sont des fonctions de x1 , suscptibles d’un développement
la méthode s’appelle la méthode de Hartree-Fock : bien
analogue : X qu’assez lourde et nécessitant un travail non-trivial de
cℓ2 (x1 ) = aℓ1 ,ℓ2 φℓ1 (x2 ) modélisation des fonctions χℓ , elle est très utilisée, no-
ℓ1
tamment par les chimistes théoriciens, pour des calculs de
et : X fonctions d’onde moléculaires.
ψ(x1 , x2 ) = aℓ1 ,ℓ2 φℓ1 (x1 )ϕℓ2 (x2 )
ℓ1 ,ℓ2
5.3.4.4 Théorie de la fonctionnelle densité
On peut, bien sûr généraliser ce genre de raisonnement
à un nombre quelconque de variables. Maintenant, l’ap- La théorie de la fonctionnelle densité (Density func-
tional theory ou DFT7 ) est, elle, une théorie, au départ,
proximation est faite d’entrée de jeu et elle est massive :
on remplace la fonction d’onde poly-électronique par un exacte, mais dont la mise en œuvre pratique oblige à des
approximations.
produit de fonctions d’onde mono-électroniques, ce qui re-
vient à se limiter au premier ordre du développement : L’idée qui sous-tend la méthode est que le détail des
fonctions d’onde de tous les électrons n’est pas ce dont on a
ψ(~r1 , ~r2 , ~r3 . . . , ~rn ) ∼ ϕ1 (~r1 ) ϕ2 (~r2 ) ϕ3 (~r3 ) . . . ϕn (~rn ) réellement besoin : la densité électronique ρ(~r) suffit bien.
Le résultat de cela, si c’était possible, serait de substituer à
On montre après quelques calculs6 que le problème s’écrit : une fonction compliquée de 3n variables ψ(~r1 , ~r2 , . . . , ~rn ),
  une fonction de trois variables, ρ(~r) telle que
XN X
− ∆ i Z i 1 Z
+ < ϕj | |ϕj > ϕi (~ri )
2
I=1 |~ ri − RI | ~
j
|~
r i − ~
rj | ρ(~r) = n |ψ(~r, ~r2 , . . . , ~rn )|2 d~r2 . . . d~rn

= εi ϕi (~ri ) ∀i Il n’est pas évident a priori qu’une telle opération soit

où ∆i est l’opérateur laplacien relatif à l’électron i : possible, car en considérant l’équation de Schrödinger, si
on essaye d’intégrer, en multipliant à gauche par ψ ∗ , sur
∂2 ∂2 ∂2 toutes les positions, sauf une, pour faire apparaı̂tre la den-
∆i = + 2+ 2
∂x2i ∂yi ∂zi sité électronique,
Z Z
~ I la position du noyau I, ~ri celle de l’électron i
R ψ Hψ d~r2 . . . d~rn = ψ ∗ Eψ d~r2 . . . d~rn = E ρ(~r)
∗

et εi l’énergie de l’état ϕi . On obtient un système

d’équations couplées par l’intermédiaire du terme d’in- le deuxième membre ne pose pas de problème parce que
1
teraction électron-électron Ji,j =< ϕj | |ϕj > qui E est un nombre scalaire, et la densité électronique vient
|~ri − ~rj | naturellement. En revanche, le premier membre comporte
mélange les termes liés à i et j. On résout alors ce système un opérateur (avec des dérivées, etc.) que l’on ne peut pas
de manière auto-cohérente : on choisit d’abord un en- commuter avec la fonction d’onde8 .
[0]
semble de fonctions d’onde d’essai ϕi (~ri ) qui permettent Des théorèmes dûs à Hohenberg et Kohn montrent que
de calculer les termes Ji,j . Cela permet de résoudre le si, dans l’approximation de Born-Oppenheimer, on écrit
système d’équations qui donne de nouvelles fonctions l’Hamiltonien comme
[1] [1]
ϕi (~ri ) et des valeurs des énergies εi . De nouvelles va-
leurs de Ji,j sont alors calculées puis de nouvelles fonc- H = Te + Vee + Vext
[2]
tions ϕi (~ri ) et ainsi de suite jusqu’à ce que les solutions 7 à ne pas confondre avec l’autre DFT, la discrete Fourier trans-

trouvées n’évoluent plus. form.

8 Parce que l’opérateur dérivation, par exemple, s’applique à ce
6 il
n’est pas question ici de détailler ces méthodes, mais seulement qui se trouve à sa droite et non à ce qui se trouve à sa gauche :
∂ ∂ ∂
d’en donner a flavor, un parfum, comme disent les anglo-saxons. f ∗ (x) ∂x f (x) 6= f ∗ (x)f (x) ∂x = |f (x)|2 ∂x .
114 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

où l’on a décomposé en énergie cinétique des électrons en tenant compte, par exemple, de la déformabilité des
(Te ), énergie potentielle d’interaction électron-électron nuages électroniques en fonction des positions de noyaux.
(Vee ) et interaction électrons-noyaux (Vext ), les deux pre- Leur gros défaut est que, même s’il existe des méthodes
miers termes ne dépendent que du nombre d’électrons, ils de calcul efficaces, ces méthodes sont terriblement voraces
sont pour ainsi dire universels. Le dernier terme dépend en temps de calcul !
des noyaux et donc du système étudié. L’énergie de l’état Ainsi des ordres de grandeurs réalistes seraient :
fondamental peut alors s’écrire comme une fonctionnelle9
<
de la densité électronique N ∼ 300
Z
E(ρ) = F (ρ) + ρ(~r)Vext (~r)d~r τ ≃ 1ps
Malgré ces défauts, elles ont leurs lettres de noblesse,
où F (ρ) regroupe les deux premiers termes universels et ρ par exemple, les phases à haute pression de la glace (liai-
son hydrogène) ou la silice vitreuse. Ces méthodes font
est la densité électronique -que l’on cherche- de l’état fon-
damental. Pour obtenir ρ, il faut alors chercher la fonction l’objet de programmes, soit commerciaux, soit libres, qui
ρ qui rend E(ρ) minimum avec, bien sûr, la contrainte que se répandent assez rapidement dans les laboratoires pour
Z devenir des outils relativement standards.
ρ(~r)d~r = N Cependant, comme on l’a vu, ces méthodes se limitent
à l’état électronique fondamental. . . lorsqu’on veut s’atta-
le nombre d’électrons dans le système. quer à des états excités, pour comparer les calculs avec des
La petite difficulté qui subsiste et que l’expression de expériences de spectroscopies diverses, il existe d’autres
F (ρ), bien qu’universelle, est inconnue ! (c’est quelque méthodes plus complexes et plus coûteuses encore en res-
chose comme < ψ|Te + Vee |ψ > mais le but de l’opération sources de calcul ! Autant dire que c’est un domaine dans
était justement d’ignorer les fonctions d’ondes). lequel la recherche est active en ce début du XXIe siècle. . .
La méthode de Kohn et Sham10 consiste à réaliser que,
puisque ce qui nous intéresse est la densité électronique
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 !
En effet, la densité électronique ne fait pas apparaı̂tre ex-
plicitement ces effets11 , il faut les introduire explicitement
« à la main » pour ainsi dire. . . C’est ici que se situent les
approximations de cette théorie : les différentes variantes
(qui s’appellent pour les plus répandues LDA et GGA)
partent en général de l’approximation que ρ(~r) est essen-
tiellement homogène, ou du moins, varie lentement.
Les méthodes ab-initio ne sont donc pas des méthodes
sans hypothèse mais elle permettent néanmoins d’at-
teindre les interactions interatomiques très précisément
9 Une fonctionnelle est une fonction dont la variable est une autre
fonction, E est une fonction de ρ, elle-même une fonction de ~ r.
10 Ces théories datent des années 1960.
11 comme le principe d’exclusion qui rend la fonction d’onde an-

tisymétrique par permutation de deux atomes : cela n’apparaı̂t

é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 uti- calculer, par exemple pour une simulation Monte-Carlo
liser 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 :
problème permet parfois des gains considérables : point
-mtune=pentium4. Chaque compilateur a ses propres options, plus
ou moins adaptées à tel ou tel processeur : c’est parfois un peu la- n’est besoin de refaire plusieurs fois un calcul qui donnera
byrinthique. . . toujours, pour des raisons de symétrie, le même résultat.

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

gner 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 : Physique Fondamentale & 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’ins-
l’effort n’est pas énorme : il faut travailler sur des tableaux
truction. 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
bon usage des caches. L’expérience prouve qu’en général,
7.1 L’architecture vectorielle 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 les La facilité de programmation de ces machines a fait leur
uns des autres qui travaillent en suivant le principe « je succès : certains CRAY des années 1990 en particulier
fais ma petite part de travail et je passe à mon voisin ». avaient des registres de très grande taille capable de sto-
Un exemple élémentaire est tout simplement l’existence de cker un grand nombre d’éléments de tableau afin de tirer
mémoires-tampon : si l’on envoie un texte ou une image parti de la rapidité d’accès aux registres et l’on obtenait
en impression sur une imprimante, celle-ci est très lente aisément ainsi de très bonnes performances de calcul pour
par rapport au processeur de l’ordinateur ; donc en pra-
l’époque.
tique, on envoie la tâche d’impression dans une mémoire
dite « tampon »(ou buffer ) de telle façon que le processeur Ce sont toutefois des technologies coûteuses dont les li-
puisse s’occuper d’autre chose pendant l’impression. Plus mites sont assez vite apparues : on verra ce que l’avenir
sérieusement, lorsqu’on travaille dans une boucle avec des réserve, mais il ne semble plus que cette voie continue à
instructions composites sur des tableaux, chaque proces- être activement explorée par les constructeurs, même si
seur fera quelque chose (une addition par exemple) sur un des ordinateurs comportent une part de vectorisation.
é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 les processeurs 7.2 Parallèlisme
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 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Instructions Multiple Data) ou différentes (Multiple Ins-
tructions Multiple Data). En pratique, les problèmes sont
différents selon que l’on travaille avec un petit nombre
de processeurs (ou plutôt de cœurs ; en gros 4 ou 8) qui
partagent le même espace mémoire (mémoire partagée ou
shared memory) ou un grand nombre de processeurs qui
utilisent chacun un espace mémoire propre (mémoire dis-
tribuée ou distributed memory) : dans ce cas la commu-
nication entre processeurs se fait par un réseau qui est
généralement optimisé pour ralentir le moins possible les
calculs.
7.2.1 Mémoire partagée
C’est une situation assez fréquente et qui le devient de
plus en plus : un ordinateur contient plusieurs proces-
seurs, parfois multi-cœurs qui partagent le même espace
mémoire. On peut alors donner des directives de compila-
tion, c’est-à-dire des instructions au compilateur, du type
« parallélise-moi ce morceau de programme », et le com-
pilateur, si on lui donne les bonnes options, parallélise. . .
presqu’automatiquement.
En pratique on utilise généralement OpenMP (pour
Open MultiProcessing) qui est librement distribué : en
fortran cela apparaı̂t comme des commentaires du type :
!$OMP PARALLEL
ou
!$OMP END PARALLEL
de telle sorte qu’un compilateur « non averti » (c’est-à-
dire qui ne connait pas OpenMP ou auquel on n’a pas
fourni l’option de compilation appropriée) puisse compi-
ler le programme sans tenir compte de ces directives. Au
contraire, le compilateur qui connait OpenMP va tenir
compte de tout ce qui commence par !$OMP. On écrira
alors des choses comme :
!$OMP PARALLEL
do i = 1, n
...
enddo
!$OMP END PARALLEL
et le compilateur répartit la boucle sur les processeurs dis-
ponibles, chacun prenant sa part de données. Il faut ce-
pendant ê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 du-
pliqué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
d’autant que les centres de calculs se mettent à en propo-
ser des centaines, voire des milliers (on commence à parler
de calculs répartis sur des dizaines de milliers de proces-
seurs).
7.2.2 Mémoire distribuée
Une autre solution consiste à répartir explicitement le
travail sur les processeurs, tel processeur devant faire tel
morceau du programme sur telles données, tel autre pro-
cesseur faisant autre chose sur d’autres données. En an-
glais, on appelle cela Multiple Instructions Multiple Data
ou MIMD. Chaque processeur fait son travail spécifique
sur ses données. La difficulté est la synchronisation de
ce beau monde, car il arrive que ce que doit faire un
processeur dépende du résultat d’un calcul fait par un
autre, sinon, il suffirait de prendre plusieurs ordinateurs
indépendants qui feraient les calculs séparément. Il existe
des bibliothèques de programmes de passage de messages
(comme MPI pour Message Passing Interface) qui per-
mettent de faire communiquer les processeurs entre eux et
les forcer à s’attendre les uns les autres pour s’échanger
les données dont ils ont besoin. Ainsi, dans un pro-
gramme, on appelle des sous-programmes de bibliothèque,
par exemple :
call MPI_SEND(....)
pour envoyer des données d’un processeur à un autre. En
effet, mettons que l’on soit en train de faire un calcul de
type Monte-Carlo-Metropolis, il faut calculer toutes les
interactions i-j, or il faut répartir les atomes entre les
processeurs : un processeur donné doit donc disposer des
positions de tous les atomes, et non seulement de ceux dont
il a la charge. En fin de course, il faut additionner toutes
les énergies et donc concentrer sur un processeur toutes
les énergies partielles calculées sur tous les processseurs :
encore des communications entre processeurs.
La gestion de ceci par l’utilisateur est plus difficile car il
faut gérer explicitement par programme tous ces échanges,
et équilibrer les charges de travail des processeurs de façon
à ne pas perdre trop de temps dans les attentes.

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 res-
titution !
Malheureusement, le monde réel est parfois contrariant :
certains algorithmes s’accomodent mal de ce genre de trai-
tement et l’on peut avoir besoin de plus que 8 processeurs,
Chapitre 8
Quelques éléments de C++
Le langage fortran est « LE » langage de programma-
tion scientifique par excellence : il a été fait pour cela et il
a constamment évolué depuis les années 1950 pour s’adap-
ter. La version actuellement la plus utilisée a été définie
en 1990 et légèrement modifiée en 1995. Les compilateurs
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
remarquable. Le C en tant que langage de programma-
tion scientifique date des années soixante-dix et peut être
considé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 scienti-
fique et fortran95 reste plus commode à l’usage1 , mais
en vertu de la maxime ci-dessus, ceux qui ont une bonne
maı̂trise du C peuvent vouloir rester dans un monde fa-
milier, d’où les présents Éléments de C++ (qui ne rem-
placent 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>
// inclure les entrées-sorties par fichiers
#include <fstream>
1 Lors d’un colloque, quelqu’un qui simulait des problèmes de com-
bustion complexe dans des turbines aéronautiques, à qui on deman-
dait 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 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
de lignes. Non seulement une même instruction peut être
répartie sur plusieurs lignes, mais on peut mettre autant
de sauts de ligne que l’on veut au milieu de l’instruction. . .
122 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan

Ceci se compile de façon très classique par la com- while(condition) {instructions. . .}

mande : et
c++ hello.cpp -o hello do {instructions. . .} while(condition)
le suffixe cpp indiquant qu’il s’agit bien d’un programme
en C++. 8.3.2 Conditions
On a évidemment :
8.2 Déclarations if ( condition ) { instructions. . . } else { instruc-
tions. . . }
Les variables doivent être déclarées : les types de base Attention, pour les habitués du fortran, il n’y a pas de
sont int (entier), float (réel), double (double précision), then. . .
char (caractère) et bool (booléen). En C++ comme Il y a une variante :
en C, le type complexe n’existe pas. Les noms z = ( condition ) ? x : y ;
de variables obéissent aux règles habituelles, seulement, qui équivaut à
C++ distingue entre les lettres majuscules et minuscules if ( condition ) z = x ; else z = y ;
(Resultat est différent de resultat, les mots-clefs du lan- Les conditions s’écrivent sans grande origina-
gage étant en lettres minuscules : float et non FLOAT ou lité : x >= y, y != z (différent de), a == b ou
Float) a < b && y <= u où && signifie et, et ou s’écrit
En revanche les déclarations peuvent être faites n’im- ||.
porte où dans le programme à condition que ce soit
1o avant la première utilisation et 2o dans le même bloc.
Ainsi, dans le programme suivant qui comporte une boucle 8.3.3 Sauvegardes
faisant varier la variable entière step de 1 à 100 :
Si l’on veut écrire des résultats dans un fichier, il faut
#include <iostream> l’ouvrir, écrire, puis le fermer : ce n’est pas bien original,
#include <fstream> par exemple,
#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 */
float t, dt=0.1 ;
8.4 Tableaux
// boucle et déclaration de step 8.4.1 Tableaux de taille fixe
for ( int step = 1; step <= 100; step++ ) Il n’y a ici rien de très original :
{ t = step*dt ; cout << t << endl ; }
// fin de la boucle et fin du ’bloc’ où step est défini #include <iostream>
#include <fstream>
/* si on met ici une référence à step, #include <string>
ça ne marchera pas ! */ #include <cmath>
// cout << step << endl ; // donc, NE PAS décommenter ! using namespace std ;
}
int main( )
la variable step n’est déclarée que pour la boucle qui /* la taille du tableau doit ^etre définie
constitue le bloc pour lequel elle est déclarée. Si on es- par une constante entière */
saie de compléter le programme en ajoutant la ligne { int const n=100 ;
cout << step << endl ; entre l’accolade qui termine float x[n] ; // déclaration du tableau
la boucle et l’accolade finale, on obtiendra une erreur
à la compilation. Le début et la fin de la boucle sont for ( int step = 0; step < n; step++ )
évidemment marqués par les accolades. { x[step] = step ; cout << x[step] << endl ; }
}

On notera néanmoins quelques points importants : 1o on

8.3 Structures de base diverses ne peut pas délimiter les tableaux comme on veut (par
exemple x[-5:5] n’est pas permis), car on se borne à
8.3.1 Boucles donner le nombre d’éléments du tableau, et 2o le premier
On a déjà vu : élément du tableau est l’élément zéro (les bornes de la
for ( int i = debut ; i < fin ; i++ ) {instruc- boucle sont, dans l’exemple ci-dessus, 0 et 99, soit n-1).
tions. . .} Les tableaux à plusieurs dimensions existent, ce
où debut et fin sont des entiers. sont simplement des tableaux de tableaux (on omettra
dorénavent dans les exemples les préliminaires #include
On peut aussi écrire des choses comme
et using) :
for ( float x=x_min ; x<=x_max ; x=x+dx ) { ins-
tructions. . .} int main( )
ou encore { int const n = 10, m = 5 ;
Physique numérique, Philippe Depondt
float x[n][m] ; // tableau de tableau
for ( int step = 0; step < n; step++ )
{ du secteur pour les redémarrer ensuite, tout simplement
for ( int i = 0 ; i < m ; i++ )
{
x[step][i] = step+pow(i,3.2) ;
cout << step << " " << i << " "
<< x[step][i] << endl ;
} et dans lequel la fameuse loupe de Sherlock Holmes était
} un ustensile indispensable !
} C’est à ce genre de délices que C++ nous convie. . . Il
Noter au passage 1o les deux boucles imbriquées,
2o l’usage correspondant des accolades ainsi que 3o la
façon d’éviter qu’à l’écriture tous les chiffres soient ac-
colés, en insérant des espaces et enfin 4o que la mise à la
puissance du fortran (x**y) n’existe pas plus en C++
qu’en C : il faut utiliser la fonction pow.
Finalement, C++ ne connait pas la manipulation
globale de tableaux : toutes les boucles doivent être
écrites explicitement, et les fonctions intrinsèques du type
sum, dot product ou matmul sont absentes.
8.4.2 Les pointeurs : premiers pas
Les pointeurs font le charme sulfureux du langage C :
ils permettent d’éblouissantes acrobaties et autorisent l’ar-
tiste à donner libre cours à toute sa virtuosité. . . Ils sont
aussi la source de bugs particulièrement retors ! À mani-
puler avec une certaine prudence, donc.
Dans le principe, cependant, c’est assez simple.
Il faut savoir qu’un tableau -dans n’importe quel lan-
gage, y compris fortran- est un pointeur masqué. Un lan-
gage comme le fortran est fait de telle sorte que l’usage
explicite de pointeurs est en général inutile, dans le but
évident de simplifier la vie de celui (ou celle) qui écrit les
programmes. En C et C++, au contraire, tout est fait
pour que toutes les potentialités de ces objets puissent
être utilisées.
Les pointeurs, c’est une vieille histoire, du moins à
l’échelle de l’histoire de l’informatique. En assembleur,
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
unes derrière les autres dans l’ordre. Ainsi, pour définir un
tableau, on doit fournir 1o l’adresse du premier élément,
2o le type de variable, c’est à dire en pratique le nombre
d’octets occupé par un élément (4, 8 voire 16) et 3o le
nombre d’éléments. C’est ce que l’on fait quand on déclare
un tableau. L’adresse du p-ième élément du tableau est
donnée par :
adresse du premier element+
(p − 1)(nombre d’octets par element)
En assembleur, alors qu’on ne dispose pas de tableau,
c’est exactement cela qu’on fait : on définit une variable
spéciale, appelée pointeur qui contient l’adresse du pre-
mier élément du tableau, variable que l’on incrémente de
la quantité voulue pour accéder aux éléments du tableau.
Quand ça marche, ça marche très bien : j’en témoigne
bien volontier ! Quand ça ne marche pas. . . c’est une autre
histoire ! J’ai des souvenirs douloureux datant de l’époque
123
où, pour gagner de l’espace mémoire, on programmait par-
fois en assembleur, des souvenirs d’écrans devenus soudai-
nement tous noirs, ou d’ordinateurs qu’il fallait débrancher
parce qu’un pointeur dans un de mes programmes était
allé écraser une adresse mémoire réservée au système d’ex-
ploitation. . . La chasse à l’erreur, dans ces conditions, était
un exercice requérant une acuité intellectuelle supérieure
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
bien souvent que l’on n’ait pas le choix.
Concrétement, imaginons que nous ayons déclaré une
variable, scalaire pour commencer, par exemple, par :
float x ;
Son adresse dans la mémoire vive s’écrit alors : & x
Déclarons alors une variable de type pointeur à l’aide de
l’astérisque * :
float * px ; // déclaration d’un pointeur
On note que le type de la variable vers laquelle on pointe2
est fourni, afin de donner le nombre d’octets qu’elle va oc-
cuper dans la mémoire. On peut alors écrire :
px = & x ;
L’adresse de x est stockée dans le pointeur px. Pour don-
ner la valeur 1.414 à x, il y a maintenant deux façons de
procéder :
x = 1.414 ; // méthode classique
ou alors on stocke 1.414 à l’adresse pointée par px
*px = 1.414 ;
Évidemment, dans le cas simple montré ici, la première
est de loin préférable. Imaginons cependant la séquence
suivante :
float x; // variable réelle
float * px ; // pointeur vers une variable réelle
px = & x ; /* initialisation du pointeur sur
l’adresse de x */
px = px + 1 ; /* incrémentation du pointeur de quatre
octets : variable suivante */
*px = 1.414 ;
on a placé la valeur 1.414 dans une nouvelle case mémoire
située 4 octets (soit un réel) après x : il vallait mieux être
sûr qu’il n’y avait là rien de vital ! On réalise alors que l’on
peut, en quelque sorte, se promener en toute liberté dans
la mémoire vive de son ordinateur et y faire toutes sortes
de choses exaltantes. . .
8.4.3 Tableaux dynamiques
On a vu précédemment que pour déclarer un ta-
bleau statique, il fallait que la taille du tableau soit une
constante : cela signifie que cette valeur ne peut pas être
modifiée à l’exécution du programme ; en fait elle doit
pouvoir être établie à la compilation. Ainsi, même si la
déclaration du tableau est faite au milieu des instructions
exécutables (c’est permis), sa taille est prédéterminée lors
de l’écriture du programme, on ne peut pas, par exemple,
l’entrer au clavier. En fortran, on répond à cette ques-
tion par des tableaux allocatable ; en C++, on utilise
un pointeur-tableau :
2 ça, c’est un progrès sensible par rapport à l’assembleur. . .
124 Licence de physique L3 : Physique Fondamentale & 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 ;
cout << j << " " << machin(j) << " " << j << endl ;
définies avant d’être utilisées sauf si l’on définit un proto-
}
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 variable
#include <string>
#include <cmath> j du programme principal n’est pas modifiée par la fonc-
using namespace std ; tion machin, alors que le calcul s’effectue bien dans la fonc-
tion. C’est que l’argument j est passé « par valeur » : la
/* début de la fonction entière machin 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 ima-
#include <iostream> ginaire), 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 : Physique Fondamentale & 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é, expo-
nentielle, 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é-
Fig. 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 expli-
N’importe quel élève de 4ème sait (en principe) comment citement -on se demande comment- mais simplement sont
il faut procéder : entourés de zones où x prend, en valeur absolue, des va-
leurs « 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 ca-
ax + b − b = −b ractè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/a1 .
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 for-
melles de l’expression (retrancher b des deux cotés du signe
égal, diviser des deux cotés par a, faire les simplifications 9.2 Quelques exemples
qui s’imposent) pour obtenir la solution qui s’écrit : x =
une expression. Les logiciels de calcul formel font cela : ils 9.2.1 ax + b = 0
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 fau-

singuliers pour a = 0, ce qui est pourtant la caractéristique drait supposer que l’on ne connait pas la solution analytique.

127
128 Licence de physique L3 : Physique Fondamentale & 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érique2. 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) ; %1(2/3) − 12 a b R T + 4 a2 + 2 a %1(1/3)
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 solution3 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 RT
!  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 « ra-
√ (1/3)
1 %1 4 a (−3 b R T + a) cine 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 le-
3 b (8 a − 27 b R T ) 2 2 quel 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 g3 + 8 m2 g2 c)
h := T → fsolve   − d c Z2
M c 3 (5 m2 g c 2 − f 4 g k2 + m2 g3 + 4 m2 g2 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 : Physique Fondamentale & 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)) Fig. 9.2 – Trajectoire du projectile z(x).

plot(’[fx(t),fy(t),t=0..10]’,x=0..2,y=-0.01..1) ;
est le pas de temps utilisé, 3o la syntaxe (les subs en par-
1

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 tave (sensiblement moins coûteux, puisque gratuit. . . voir
1.4 1.6 1.8 2

x
http ://www.octave.org) ferait parfaitement l’affaire.
On obtient sans surprise que le projectile n’a pas une Les commandes (placées dans un fichier de commandes
trajectoire parabolique (qui serait symétrique par rapport 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
Fig. 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 banales4 , 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 trai-
ter 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
initiale » produit par un autre programme d’initialisa-
tion ; on a d’ailleurs prévu de tester l’existence de ce fichier
(instruction 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 cla-
vier ; 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 pa-
ramètres de la simulation.
program saturn
! 5 cela fait gagner le temps de conversion binaire (en machine) vers
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 binaire5 .
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 no-
tera au passage, l’introduction d’une interaction répulsive
en r−12 à très courte portée destinée à tenir compte très
approximativement des collisions entre astéroı̈des : ces col-
lisions sont considérées comme élastiques dans ce cas, ce
qui est d’un réalisme douteux, mais on pourrait choisir
autre chose.
ASCII et réciproquement à la lecture.
132 Licence de physique L3 : Physique Fondamentale & 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 vo-
f(i,3) = fijr*zij lume 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 à sur-
xij = r(i,1)-r(j,1) veiller 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 &
Fig. 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 des
! de l’energie potentielle 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 ce système
! verlet commence ici d’unités, le pas d’intégration temporel est de δt = 10−4 ,
do j = 1, 3 et il y a 10000 pas pour ce « run » d’essai. La durée
do i = 1, n d’exécution dépend évidemment de la puissance de l’ordi-
vr(i,j) = vr(i,j) + f(i,j)*dt/m(i) nateur utilisé : sur un PC à 500MHz, il a fallu 15mn, or le
r(i,j) = r(i,j) + vr(i,j)*dt
système n’a guère eu le temps, dans ses unités de temps à
enddo
lui, d’évoluer sensiblement (on le voit par la faible varia-
enddo
! verlet finit ici tion de l’énergie potentielle), il faudra faire des simulations
k = 0. ! energie cinetique 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 viole
m(i)*(vr(i,1)**2 + vr(i,2)**2 + vr(i,3)**2) ainsi un principe fondamental de la physique doit obli-
enddo gatoirement avoir une raison valable pour le faire ! La
k = 0.5*k première hypothèse qui vient à l’esprit est que le pas
Physique numérique, Philippe Depondt 133

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

Tab. 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’exploi-
tation 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 cla-
vier, 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 Fig. 9.5 – Energie potentielle gravitationnelle en − r1 (en
session, rentrer chez soi et revenir le lendemain pour voir −30

ce que le programme a fait pendant ce temps. . . Un autre rouge), et celle en − 1r + 10r12 (en vert). Il est aisé de calculer
utilisateur qui aurait ouvert une autre session entre-temps qu’avec 500 astéroı̈des et un rayon d’orbite moyen r = 1,
peut très bien ne pas s’apercevoir qu’il y a quelque chose la distance moyenne entre deux astéroı̈des est un peu plus
qui tourne en même temps que ses propres applications ! grande que la distance à laquelle le terme répulsif com-
3. at 2 mence à intervenir : les astéroı̈des sont donc « presque »
mongroprog au contact, du moins au début de la simulation si on les
^D 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) mainte- On obtient ainsi un résultat assez satisfaisant (figure
nue enfoncée en même temps que la touche d : cela permet 9.6) : les énergies potentielles et cinétiques varient en sens
de marquer la fin de la séquence d’instructions concernées opposés, la somme restant constante. Il faudrait ensuite
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

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-
Fig. 9.6 – Évolution temporelle des énergies après intro-
mage d’augmenter sensiblement le temps de calcul pour
duction du terme répulsif.
quelques événements indisciplinés.
Il faut se rappeler que l’interaction gravitationnelle di-
134 Licence de physique L3 : Physique Fondamentale & 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 commen-
cer à 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, calcu-
ler la distribution des distances des astéroı̈des à Saturne,
ceci en fonction du temps. Si des anneaux se forment,
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 Ma-
thematics, 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 ana-
lysis 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