YAO : Un logiciel pour les modèles

Transcription

1 YAO : Un logiciel pour les modèles numériques et l'assimilation de données Sylvie Thiria, Fouad Badran, Charles Sorror Rapport de recherche (22 juin 2006) 1

2 Table des matières 1 Introduction 3 2 Principes Théoriques de l'assimilation Variationnelle Introduction et notation Calcul de l'adjoint[27] Méthode incrémentale Quelques extensions Transformation du vecteur d'état Prise en compte du bruit du modèle Fonctions de validation Graphe Modulaire Concept de graphe modulaire Tangent linéaire d'un graphe modulaire Adjoint d'un graphe modulaire Représentation d'une application par graphe modulaire Mise au point d'expériences de simulation et/ou d'assimilation 22 4 YAO Présentation générale Concepts généraux, dénitions, vocabulaire Fichier de description Structuration d'une application sous YAO: Le chier d'instructions Schéma global d'agencement des calculs dans YAO Exemple pratique d'application : LE SHALLOW-WATER (TP didactique) Discrétisation Modélisation Par graphe modulaire YAO Etude de cas Implémentation dans YAO Fichier de description Programmation du hat et des modules Fichier d'instructions Exemples supplémentaires Achage avec gnuplot Conclusion et Perspectives 54 6 Remerciements 55 7 Annexes Démonstration de la formule de la procédure backward Simulation du modèle direct Test de la fonction objective Exécution d'une assimilation (cas 1)

3 1 Introduction La modélisation numérique est de plus en plus utilisée comme complément à l'étude d'un phénomène physique se déroulant dans le temps, dans l'espace à une, deux ou trois dimensions (1D, 2D, 3D) ou bien tout à la fois dans le temps et l'espace. Dans une première étape le modèle numérique permet de choisir et d'adapter les équations permettant de reproduire les lois physiques qui sous tendent le phénomène. Une fois vérié le bon comportement de ces lois il est alors utilisé pour l'étude du phénomène lui même. Cependant, les modèles ainsi crées restent toujours imparfaits. La paramétrisation des phénomènes, les discrétisations, l'incertitude sur les conditions initiales et les conditions limites introduisent des approximations dont il faudra tenir compte au moment d'étudier le comportement du phénomène ou de prédire les évolutions de celui-ci. De nouvelles techniques qui utilisent à la fois la modélisation et la résolution de problème inverse ont vu le jour, elles se regroupent sous le nom d'assimilation des données. Celles-ci tentent de faire évoluer le modèle physique ou les paramètres qui le contraignent (conditions initiales,...) en introduisant un nouveau type d'information : les observations. Elles utilisent alors le modèle du phénomène ou modèle direct et se servent des observations pour contrôler les modications nécessaires. Il existe deux grandes familles de technique pour faire de l'assimilation de données : les méthodes séquentielles et les méthodes variationnelles ([6, 21, 23, 25, 26, 28]), les secondes étant plus adaptées si l'on veut prendre en compte d'une manière globale les variations du phénomène pendant une période de temps donnée. Toutes sont aujourd'hui de plus en plus utilisées car elles permettent de faire interagir l'ensemble des informations disponibles (connaissances théoriques sur le phénomène et observations de celui-ci) dans l'espace et dans le temps. L'ecacité de l'approche est visible si l'on considère leurs bonnes performances, on peut faire référence, parmi d'autres, à l'amélioration actuelle obtenue sur les prévisions météorologiques qui assimilent les observations satellitaires et in situ depuis une vingtaine d'années. La technique choisie par les centres de prévision météorologique est en général l'assimilation variationnelle dont le principe repose sur la minimisation d'une fonction de coût (objective). Il faut pour cela déterminer le gradient de la fonction par rapport aux variables à contrôler. Ce calcul nécessite la programmation du code adjoint du modèl direct (parfois aussi celui du linéaire tangent de ce même modèle pour certains algorithmes) qui permet de rétropropager le gradient de l'erreur sur les valeurs de sortie du modèle vers les variables d'entrée. Il faut donc décider d'investir dans la réalisation de ces développements, survient alors la diculté de programmer ces codes (code adjoint, tangent linéaire) qui ne relèvent pas d'un sens physique commun, mais plutôt d'une démarche purement mathématique. Jusqu'à présent, deux approches sont utilisées pour créer ces codes adjoints à partir du code du modèle direct :. 3

4 - Le code adjoint peut être généré à la main. Dans ce cas, il est souhaitable de choisir le nom des variables en suivant des règles précises qui facilitent la dérivation composée. Après cette première phase d'analyse et d'écriture qui est longue et délicate, le code doit être entièrement écrit.. - Le code adjoint peut être généré d'une manière automatique à partir du code de l'application directe [14, 15, 16, 17, 19, 18]. Cette approche répond à un besoin actuel qui consiste à exploiter de très gros code existant dont on est sur du bon fonctionnement. Le code adjoint généré de manière automatique est alors dépendant du langage de programmation dans lequel il est écrit. Il contient des instructions qui ne sont pas nécessaires et doit être nettoyé avant son utilisation. Cette opération doit d'autre part être recommencée si l'on fait évoluer le code direct et que l'on désire faire évoluer également son adjoint. Il est dicile de modier directement le code adjoint, son écriture n'étant pas obligatoirement très lisible.. D'autres méthodes existent actuellement qui permettent d'eectuer ces mêmes études (Krigeage, Filtrage de Kalman), les méthodes variationnelles sont cependant celles qui semblent devenir les plus populaires étant données leurs capacités à prendre en compte toute une trajectoire d'assimilation. Leur principale diculté est d'être longue à mettre en oeuvre, il faut écrire le modèle tangent, le modèle adjoint, gérer les observations qui peuvent intervenir en n'importe quel lieu et à n'importe quel temps, gérer aussi les diérentes fonctions de coût ainsi que les matrices de variance-covariance d'erreur qui interviennent dans le processus. Une méthode nouvelle d'écriture de codes de modèles numériques est développée au LOCEAN pour l'assimilation variationnelle de données. Elle est basée sur la représentation du modèle numérique du phénomène physique étudié sous forme de graphe modulaire. Ce formalisme nous a ammené à la conception d'un outil général : Le logiciel YAO qui va être présenté dans ce document. En déchargeant l'utilisateur de l'implémentation des diérents algorithmes nécessaires, YAO se propose d'être une aide à la réalisation d'inversion variationnelle et d'une manière plus générale à l'assimilation variationnelle. Il permet à l'utilisateur de réduire sa part de programmation et de ne se concentrer ainsi que sur la spécication de son problème, en particulier sur les dépendances physiques qui existent entre les diérentes variables qui constituent le phénomène physique. Tout code écrit à partir de YAO bénécie de façon quasi-automatique du code adjoint qui permet de calculer le gradient d'une fonction de coût. Un grand avantage de cette méthode est sa exibilité et la facilité avec laquelle il est possible de modier le modèle pour le faire évoluer. La méthodologie a été testée sur diérents exemples (modèle Météo ISBA, modèle traceur OPA) ; elle a montré sa capacité à produire facilement des modèles adjoints et à permettre l'assimilation des données en 4D-Var (prise en compte des observations à n'importe quel moment durant le temps d'assimilation). Le champ d'utilisation de YAO n'est cependant pas limité aux seules simulations physiques. Il peut être utilisé pour d'autres domaines d'application. YAO s'est donc avérer être une solution ecace pour surmonter plus aisément l'investissement nécessaire à la réalisation des modèles (direct, tangent et adjoint) dont il est reconnu qu'il s'agit habituellement d'un travail lourd et contraignant. Dans les paragraphes qui suivent nous rappelons tout d'abord les principes théo- 4

5 riques et le cadre mathématique général de l'assimilation variationnelle, puis nous introduisons le formalisme de graphe modulaire. L'outil YAO et ses fonctionalités ferons ensuite l'objet d'une présentation qui sera appuyée par la réalisation d'un TP sur le shallow-water. Enn, des évolutions futures de YAO seront envisagées. Ÿ 5

6 2 Principes Théoriques de l'assimilation Variationnelle 2.1 Introduction et notation Ce paragraphe présente l'ensemble des notions mathématiques nécessaires à la mise en oeuvre des techniques d'assimilation variationnelles. Traditionellement on classe les assimilations en diérents types selon le nombre dimension que l'on considère : 3D-Var signie que l'on considère un phénomène physique décrit dans l'espace à trois dimension et 4D-Var que l'on considère son évolution dans le temps. L'assimilation variationnelle demande la connaissance d'un modèle numérique ou modèle direct M qui décrit, dans le temps, l'évolution du phénomène physique que l'on étudie. Si l'on prend par exemple un problème géophysique, le modèle direct permet de relier les variables géophysiques que l'on étudie aux observations. En faisant varier certaines des variables géophysiques (les variables de contrôle) l'assimilation cherche à inférer les variables physiques qui ont engendré les valeurs d'observations. Ces variables physiques peuvent être par exemple des conditions initiales ou des paramètres mal connus du modèle M. Les variations considérées se font à partir d'un ensemble de valeurs initiales données aux variables de contrôle et ne s'autorisent souvent qu'à explorer un domaine limité en introduisant des valeurs d'ébauche desquelles il ne faut pas trop s'écarter. D'une manière générale, il s'agit de déterminer le minimum d'une fonction de coût J qui mesure l'écart entre les observations et la valeur calculée par le modèle M. Le minimum recherché est toujours obtenu à partir de la méthode du gradient. Selon les algorithmes que l'on considère il faut alors utiliser des modèles qui se déduisent de M : le tangent linéaire et l'adjoint. Si le modèle est continu et dérivable ces deux modèles se déduisent aisément des équations du modèle M. Le tangent linéaire revient à étudier pour une valeur donnée des variables de contrôle (ou point de référence) la sensibilité du modèle M à de petites perturbations de ces variables. Il se calcule en ce point de référence en linéarisant le modèle M, calcul qui correspond à la valeur de la matrice Jacobienne en ce point. Le modèle adjoint revient, lui, à étudier les variations des variables de contrôle en réponse à une perturbation des valeurs de sortie calculées par le modèle M. Il faut donc dérouler en sens inverse les calculs du tangent linéaire, ce qui correspond à utiliser la transposée de la matrice Jacobienne. Lorsque des observations sont disponibles ces modèles permettent de faire de l'assimilation variationnelle de données en minimisant la fonction J et de retrouver les variables de contrôle. Nous présentons maintenant de manière formelle les notations mathématiques et les algorithmes les plus classiques utilisés actuellement. Dans cette présentation nous avons adopté le formalisme et les notations présentés dans l'article [20]. nous notons : M : le modèle direct décrivant l'évolution (en général non linéaire) entre 2 pas de temps de discrétisation t i,t i+1. x(t 0 ) : le vecteur d'état initial en entrée du modèle et qui est à contrôler. M i (x(t 0 )) ou M(t i, t 0 ) correspond à l'état du modèle au temps t i à partir de t 0. On notera x(t i ) = M i (x(t 0 )) M(t i, t i+1 ) : le tangent linéaire qui correspond à la jacobienne du modèle M calculé en x(t i ). On dénit le tangent linéaire du modèle M i calculé en t 0 : 6

7 M i (x(t 0 )) = 0 j=i 1 M(t j+1, t j ) L'adjoint du modèle M i est la tranposé du tangent linéaire : i 1 M i (x(t 0 )) T = M(t j+1, t j ) T j=0 x b : un vecteur d'ébauche qui correspond à une estimation à priori du vecteur x(t 0 ). y o : l'ensemble des observations sur diérents pas de temps. Le vecteur y o i correspond donc aux observations au temps t i, ce vecteur peut être vide s'il n'y a pas d'observation au pas de temps t i. Le modèle M permet d'estimer des quantités qui sont le plus souvent observées à partir d'un opérateur dit d'observation (H ). Dans le domaine de la géophysique cet opérateur permet, par exemple, de comparer les sorties du modèle M qui calcule la température à la surface de la mer à des observations enregistrées par un radiomètre qui se trouve à bord d'un satellite. On comprend également, que les observations ne peuvent pas être obtenu en tout point de l'espace étudié, ni à tout instant. Il est nécessaire de connaitre l'opérateur qui permet de transformer les valeurs de sortie de M en valeurs observables. C'est l'opérateur H qui permet donc de comparer, là ou les observations sont disponibles, les valeurs observées et celles calculées par la composition HoM. La fonction de coût J va donc s'appliquer dans le domaine des observations, comme mentionné précédemment il sera nécessaire d'exprimer le tangent linéaire et l'adjoint de l'opérateur H. On note donc : H : l'opérateur d'observation qui permet de calculer les variables d'observation y i au temps t i à partir du vecteur d'état x(t i ). On suppose par la suite que : y o i = H(M i (x(t 0 ))) + ε i (ε i étant une variable aléatoire de moyenne nulle). H i : la matrice du modèle tangent linéaire de l'opérateur H calculé en x(t i ). Enn, l'assimilation des données cherche à résoudre des problèmes qui sont le plus souvent sous contraint. Il faut pour obtenir des solutions réalistes apporter le plus possible d'information pour maintenir la cohérence existant au niveau des diérentes variables de contrôle retrouvées et des quantités estimées par le modèle M. Les variables physiques et les observations sont connues avec certaines erreurs qui sont le plus souvent fortement corréllées. Dans les méthodes d'assimilation ceci est pris en compte en introduisant au niveau de la fonction de coût des matrices de variance-covariance. La matrice de variance-covariance sur les erreurs d'observations permet de maintenir la cohérance entre les diérentes valeurs retrouvées en sortie de l'opérateur d'observation, celle sur l'écart à l'ébauche maintient la cohérence spatiale des diérentes variables de contrôle entre elles. Dans la suite on note : R : l'estimation de la matrice de covariance sur les erreurs d'observation ε i. B : l'estimation de la matrice de covariance sur les erreurs de l'ébauche x b. Avec ces notations, la fonction de coût J se présente en général sous la forme suivante : J(x(t 0 )) = 1 (y i y i ) T R 1 (y i y i ) (x(t 0) x b ) T B 1 (x(t 0 ) x b ) (1) i 7

8 Avec y i = H(x(t i )) 2.2 Calcul de l'adjoint[27] D'une manière générale, soit un scalaire J mesurant la distance entre un modèle G et ses observations et dépendant de y. Pour minimiser J, on est amené à calculer le gradient de J par rapport à des variables x du modèle tel que y = G(x). La perturbation δj est donnée par : δj =< y J, δy > (2) <> désignant le produit scalaire. On a : δy = G(x)δx (3) G(x) est le jacobien de G (opérateur linéaire au point x), que l'on note également G x. On rappelle que : soit u Au un opérateur linéaire continu d'un espace de Hilbert L dans un espace de Hilbert F. Il existe un opérateur linéaire continu A de F dans L, et un seul, tel que l'égalité suivante entre produits scalaires soit vériée pour tout vecteur u de L et tout vecteur v de F < Au, v >=< u, A v > A est l'adjoint de A. Lorsque L et F sont de dimensions nies, les matrices qui représentent A et A dans des bases orthonormées sont transposées l'une de l'autre (ou transconjuguées dans le cas de composantes complexes). On en tire que : En portant (3) dans (2) on a : on en déduit : < v, Au >=< A T v, u > δj =< y J, G x δx >=< G T x y J, δx >=< x J, δx > x (J) = G T x y (J) ce qui permet le calcul de x connaissant y en prenant l'adjoint G T x qui est la transposée de G x. de G(x) L'assimilation de données variationnelle consiste à minimiser la fonction J par rapport à l'état initial x(t 0 ). Le gradient x0 J est égal à : x0 J = M T i (x(t 0 )H T i [R 1 (y i yi o )] + B 1 (x(t 0 ) x b ) (4) i=i..n la procédure de minimisation est réalisée en choisissant un algorithme d'optimisation parmi l'ensemble de ceux proposés par les techniques d'optimisation. Dans le domaine de la géophysique un des plus utilisé pour l'assimilation variationnelle est le minimiseur m1qn3[16, 17], développé par l'inria. On peut également, de manière à favoriser pour certains problèmes la convergence, utiliser une méthode approchée de descente de gradient, appelée algorithme incrémental [29, 11] qui est plus rapide. Procéder de la sorte revient à modier la fonction J. La présentation de cette variante fait l'objet du paragraphe suivant. 8

9 2.3 Méthode incrémentale. La minimisation de la fonction J par rapport à x(t 0 ) suppose que l'on positionne l'algorithme de minimisation à un état initial x g (t 0 ), ainsi on a x(t 0 ) = x g (t 0 ) + δx(t 0 ). On utilise l'approximation par le tangent linéaire : y i = H(M i (x(t 0 ))) H(M i (x g (t 0 ))) + H i (M i (x g (t 0 ))δx(t 0 ) (5) En posant en plus d i = y o i H(M i (x g (t 0 ))) on peut exprimer J par : J[δx(t 0 )] = 1 2 [δx(t 0) (x b (t 0 ) x g (t 0 ))]B 1 [δx(t 0 ) (x b (t 0 ) x g (t 0 ))] (6) n [H i M i (x g (t 0 ))δx(t 0 ) d i ] T R 1 [H i M i (x g (t 0 ))δx(t 0 ) d i ] i=1 Cette nouvelle formulation de J représente une expression quadratique en δx et correspond à une approximation de J(x(t 0 )) autour de x g (t 0 ). Le problème est de minimiser J(δx(t 0 )) par rapport à la seule variable δx(t 0 ), les autres termes étant constants. Cette phase de minimisation sera dite la boucle interne. Elle correspond à quelques itérations de la méthode du gradient. A chaque itération de la boucle interne, il faut donc calculer le gradient δx J : δx J = B 1 [ δx(t 0 ) (x b (t 0 ) x g (t 0 )) ] + n M T i H T i R 1 [H i M i (x g (t 0 ))δx(t 0 ) d i ] (7) Au cours des itérations de la boucle interne, l'approximation par la formule 5, risque de devenir trop grossière. Pour cette raison on fait un nombre limité d'itérations, puis on recalcule la vraie valeur de y i = H(M i (x(t 0 ))). La phase de préparation de la boucle interne est appelé boucle externe. La boucle interne est donc imbriquée dans la boucle externe. Nous pouvons résumer les calculs à chaque itération de chacune de ces bloucles de la façon suivante : boucle externe : - remplacer x g (t 0 ) par x g (t 0 )+δx. Il est à noter qu'à la toute première itération x g (t 0 ) doit être initialisée, (en général égale à l'ébauche). - calculer les y i = H(M i (x g (t 0 ))) et les d i pour la nouvelle expression de J[δx(t 0 )]. - initialiser δx(t 0 ) (généralement, on prend δx(t 0 ) = 0). - boucle interne : - calculer δx J et J[δx(t 0 )] selon les formules 4 et 5. - corriger δx(t 0 ) avec une méthode de minimisation adéquate. La gure 1 illustre l'algorithme incrémental en montrant comment progresse la minimisation par l'imbrication de ces deux boucles. i=1 9

10 Fig. 1 La courbe en trait plein correspond à la fonction de coût J(x(t 0 )). Chacune des paraboles en pointillé correspond à la fonction J[δx(t 0 )] initialisée à chaque itération k de la boucle externe. La boucle interne réalise une descente de gradient sur la parabole correspondant à l'approximation. La boucle externe, quand à elle, permet d'avancer en se repositionnant sur la fonction J(x(t 0 )) (courbe pleine) et de faire une nouvelle approximation correspondant à la parabole suivante dans la minimisation. 2.4 Quelques extensions Transformation du vecteur d'état en prenant v = B 1 x = U 1 x, l'expression 1 2 (x(t 0) x b ) T B 1 (x(t 0 ) x b ) de la fonction de coût devient (v(t 0 ) v b )(v(t 0 ) v b ). Dans cette formulation, le vecteur de contrôle admet la matrice unité comme matrice de variance-covariance. Cette formulation présente plusieurs avantages notamment en ce qui concerne la convergence de l'algorithme de minimisation de la boucle interne. Certaines méthodes [29] propose de dénir directement U 1, par exemple en dénissant U 1 = F 1 D 1 K 1 où : - K 1 produit un ensemble de variables 2 à 2 non corrélées par exemple en retirant toute relation dynamique physique. - D 1 correspond à une matrice de normalisation. - F 1 est l'inverse d'un opérateur de lissage spécial qui agit séparément sur chacune des variables (non corrélées). L'implication de cette formulation et la méthode incrémentale qui lui est associée suppose une estimation de x l à la n de la lième itération de la boucle externe par : x l = x l 1 + δx l avec δx l = Uδv l où U correspond au tangent linéaire de l'opérateur U. La boucle interne aura comme objectif l'optimistaion de la fonction coût par rapport à δv Prise en compte du bruit du modèle Le modèle n'étant pas une reproduction parfaite de la réalité il est donc entaché d'erreur. Ainsi, Si on note par x t le vecteur qui correspond à la situation réelle 10

11 et on note par x f le vecteur prévu par le modèle, en posant x t (t0) = x(t0) on a alors : et x f (t i ) = M(x t (t i 1 )) x t (t i ) = x f (t i ) + η i On suppose que le vecteur η i correspond au bruit du modèle au temps t i, et qu'il admet une matrice de variance covariance Q. On suppose en plus que pour tout i et j les variables η i et η j sont indépendants. Il s'agit alors d'estimer, en plus des variables de contrôle, les diérents vecteurs η i. Ainsi, la nouvelle fonction J s'écrit : J(x(t 0 ), η 1, η 2,..., η n ) = 1 2 (x(t 0) x b ) T B 1 (x(t 0 ) x b ) n (H(x(t i )) y i ) T R 1 (H(x(t i )) y i ) i=1 (8) n ηi T Q 1 η i i=1 Avec x(t i ) = M(x(t i 1 ) + η i 1 ) En procédant à des approximations successives de l'expression (8) et en dénissant les variables i 1 z i = H i M i 1...M 0 δx + H i M i 1...M k η k 1 + H i η i 1 k=1 Où M i est la matrice du tangent linéaire du modèle M calculé au vecteur x i = M(t i, t 0 ) (état du modèle au temps t i à partir de t 0 ). En posant d i = y 0 i H(x i ) (cette fois les lettes sont bonnes) et δx = x(t 0 ) x b, la fonction coût devient alors : J(δx 0, η, z) = 1 2 δxt 0 B 1 δx n (z i d i ) T R 1 (z i d i ) i=1 Il faut alors minimiser J sous la contrainte : n ηi T Q 1 η i i=1 i 1 z i = H i M i 1...M 0 δx 0 + H i M i 1...M k η k 1 + H i η i 1 k=1 L'introduction des coecients de Lagrange (m i ) permet de passer au problème dual qui se formule alors sous la forme d'une minimisation d'une fonction coût quadratique G(m) sans contrainte. Des formules de passage permettent alors le calcul de la solution du problème initial à partir de la solution du problème dual. 11

12 L'algorithme de gradient qui permet l'optimisation de la fonction duale G(m) introduit un calcul qui peut se faire par rétropogation à travers le graphe modulaire. L'algorithme dual n'est pas encore implémenté dans YAO, mais la conception de graphe modulaire, sous-jacent à YAO, permettrait de l'intégrer par la suite. 2.5 Fonctions de validation Lorsqu'on veut pratiquer des expériences d'assimilation variationnelles, il est important de pouvoir s'assurer de la validité des codes employés. Les diérents tests ci-dessous sont couramment employés à cette n. Test de la fonction objective : il consiste à vérier le développement de Taylor de la fonction de coût J: à l'ordre 1 : J(x(t 0 )+α.dx) J(x(t 0 )) < x(t0 ) J, α.dx> 1, α 0 où <,> désigne le produit scalaire à l'ordre 2 : ( 1 J(x(t0 )+α.dx) J(x(t 0 )) α 2 < x(t0 ) J, α.dx> 1 ) K, α 0 où α est un coecient, K est une constante proportionnelle au hessien. Test du tangent linéaire. De façon similaire, on vérie le développement de Taylor sur le modèle M lui-même : à l'ordre 1 : à l'ordre 2 : 1 α M(x(t 0 )+α.dx) M(x(t 0 )) M(x(t 0 )), α.dx 1, α 0 ( M(x(t0 )+α.dx) M(x(t 0 )) M(x(t 0 )), α.dx 1 ) K, α 0 où α est un coecient, K est une constante proportionnelle au hessien. Test de l'adjoint : il s'agit de vérier l'égalité du produit scalaire suivant : < M(x(t 0 )).dx, dy >=< dx, M T (x(t 0 )).dy > dx, dy avec une tolérance sur la précision machine à apprécier selon l'erreur relative ainsi calculée : <M(x(t 0 )).dx, dy> <dx, M T (x(t 0 )).dy> <M(x(t 0 )).dx, dy> Ce test n'apporte aucune indication sur la validité de la programation des dérivées, il indique simplement la cohérence entre le modèle tangent, et sa transposition (i.e. l'adjoint). Ÿ 12

13 3 Graphe Modulaire Concept de graphe modulaire Dénitions : module : Un module F est une entité de calcul, il reçoit un vecteur en entrée et calcule un vecteur en sortie. Un graphe Γ est formé de plusieurs modules, un module reçoit ses entrées d'autres modules ou du contexte extérieur au graphe et transmet ses données en sortie à d'autres modules ou au contexte extérieur. connexion de base : On schématise les transmissions des données entre modules par des connexions qui seront appelées par la suite les connexions de base. Une connexion de base qui lie la ième sortie d'un module F p à la jème entrée d'un module F q indique que la ième valeur calculée par F p sera transmise à la jème entrée de F q. Les transmissions des données vers l'extérieur (respectivement à l'intérieur) du graphe seront représentées par des connexions de base partant de sorties de certains modules (respectivement aboutissant à des entrées de certains modules). graphe modulaire : Un graphe modulaire est un ensemble de modules interconnectés. Les modules représentent les sommets du graphe et un arc (orienté) du module F p vers le module F q signie que F p transmet une partie de ses sorties à F q. Un modèle physique M peut être représenté par un graphe modulaire Γ. La gure 2-a ci-dessous représente un sous ensemble de modules d'un modèle. Ainsi, le module F p transmet sa sortie y p1 à l'entrée x q1 de F q et sa sortie y p2 à l'entrée x q2 de F q, cette même sortie y p2 sera aussi transmise à l'entrée x l1 de F l. La gure 2-a représente donc les connexions de base décrivant la transmission des données, elle montre qu'une seule connexion de base peut aboutir à une entrée donnée, mais que plusieurs connexions de bases peuvent être issues d'une même sortie. La gure 2-b montre deux arcs du graphe modulaire associé, en général un arc du graphe modulaire représente plusieurs connexions de bases. Figure 2: (a) connexions de base entre entrées et sorties de modules. (b) arcs du graphe entre modules. Le graphe modulaire décrit donc l'ordonnancement du calcul dans un modèle (voir gure 3). Un arc de F p vers F q indique que le module F q ne peut déclencher son calcul qu'après celui de F p. Par contre, les connexions de base seront utilisées an de transmettre les données. 13

14 Figure 3: graphe d'ordonnancement. Le graphe modulaire est un graphe sans circuit, il existe donc au moins un sommet d'entrée (sans prédécesseurs) et au moins un sommet de sortie (sans successeurs), on distingue donc trois types de modules : - Les modules d' entrée du graphe (sans prédécesseurs) reçoivent leurs données uniquement du contexte extérieur du graphe et transmettent leur sorties à d'autres modules ou au contexte extérieur. - Les modules de sortie du graphe (sans successeurs dans le graphe) transmettent leurs sorties uniquement au contexte extérieur du graphe et reçoivent des données d'autres modules ou du contexte extérieur. - Les modules internes du graphe recoivent nécessairement des entrées des modules prédécésseurs et éventuellement du contexte extérieur et transmettent les résultats aux modules successeurs et éventuellement au contexte extérieur. Le graphe modulaire étant sans circuit, il est alors possible de numéroter les modules suivant un ordre appelé ordre topologique. Ainsi, relativement à cet ordre, l'existence d'un arc de F p à F q (F p F q ) implique nécessairement que p < q. L'ensemble des entrées d'un module F p constitue un vecteur noté x p, l'ensemble de ses sorties constitue un vecteur noté y p (y p = F p (x p )). De ce qui précède, un module donné F q ne peut être activé que s'il dispose de son vecteur d'entrée x q, ce qui implique que tous ses modules prédécésseurs F p aient préalablement été activés. Les entrées correspondant à des connexions de base entrant de l'extérieur sont initialisées par le contexte extérieur. L'ordre topologique indique un enchaînement possible du calcul dans le modèle. La propagation du calcul dans le graphe modulaire se fait d'une manière naturelle, selon la procédure forward suivante : 14

15 Algorithm 1 forward 1) Parcourir les modules du graphe modulaire en passe avant, dans le sens de l'ordre croissant topologique. Pour chaque module rencontré : - S'il s'agit d'un module d' entrée, initialiser ses entrées par les données correspondantes du contexte extérieur. - Pour les autres cas ( module de sortie ou interne), si le module prend une partie de ses entrées du contexte extérieur alors initialiser ces entrées par les données correspondantes du contexte extérieur, initialiser les autres entrées par les sorties correspondantes des modules prédécesseurs. - Déclancher les calculs du module pour en obtenir le résultats sur ses valeurs de sortie (y p = F p (x p )). 2) Récupération du résultat sous la forme d'un vecteur y, constitué par les données transmises au contexte extérieur par les diérents modules. Globalement, un graphe modulaire reçoit une partie de ses données sur les entrées de ses modules d' entrée, il propage le calcul dans ce graphe en récupérant éventuellement d'autres données du contexte extérieur. L'ensemble des données qui seront transmises au contexte extérieur constitue un vecteur y, ce vecteur correspond aux résultats à restituer au contexte extérieur du graphe modulaire. Ainsi, un graphe modulaire peut être considéré lui-même comme un module F (y = M(x)). La représentation par graphe modulaire s'applique donc à diérents niveaux d'intégration, ce qui permet de former des modèles de plus en plus complexes. La suite du paragraphe montre comment, grâce à la notion de graphe modulaire, on calcule le tangent linéaire et l'adjoint d'un modèle. Les calculs nécessaires demandent d'obtenir le résultat de multiplication matricielles faisant intervenir les matrices jacobiennes de chaque module. Dans ce qui suit, pour faciliter la présentation et la compréhension, nous utilisons les notations matricielles, les résultats des calculs peuvent être obtenus sans exprimer explicitement les matrices jacobiennes (par exemple en utilisant des générateurs automatiques) Tangent linéaire d'un graphe modulaire. On suppose que dans le cadre d'un graphe modulaire Γ d'un modéle M on sait calculer le tangent linéaire de chaque module F q, celui-ci se calcule pour une perturbation dx q (en un point x q ). On note par F q la matrice correspondante au tangent linéaire, qui est égale à la matrice jacobienne de F q calculée en x q, la perturbation correspondante en sortie du module est égale à dy q = F q dx q. De la même façon que le vecteur d'entrée x q, le vecteur dx q provient des perturbations dy p en sorties des modules prédécesseurs de F q ou des perturbations transmises par le contexte extérieur. Le tangent linéaire du modèle global représenté par un graphe Γ peut se calculer par une propagation avant dans le graphe de façon similaire à la procédure forward (algorithme 2). Un exemple de ce calcul est donné gure 4. 15

16 Algorithm 2 lin_forward Cet algorithme s'applique après que toutes les entrées x q de tous les modules aient été calculées (pour cela, il aura sut d'appliquer une fois l'algorithme forward pour un vecteur d'entrée x déni dans le contexte extérieur du graphe Γ ). 1) Initialiser la perturbation dx du vecteur d'entrée x du graphe Γ (ceci correspond à toutes les connexions de bases recevant des données du contexte extérieur). 2) Parcourir les module dans le sens de l'ordre topologique. Calculer, d'une manière similaire à la procédure forward, leur tangent linéaire dy q = F q dx q au point x q. 3) Récupérer le résultat sous la forme d'un vecteur dy constitué des pérturbations transmises au contexte extérieur. Figure 4: calcul du linéaire tangent dans un graphe modulaire. soit un module F q pour lequel le vecteur x q (de composante x q,i ) a déjà été calculé, et une perturbation dx q (de composante dx q,i ). On calcule dy q = F q dx q ce qui correspond au calcul du tangent linéaire du module F q. Les composantes dy q,j peuvent à leur tour être utilisés par les modules successeurs pour former leur propres composantes dx q,i Adjoint d'un graphe modulaire. Comme pour le modèle tangent linéaire, on suppose qu'on sait calculer le modèle adjoint de chaque module. Ainsi, pour un module F p, ayant en entrée un vecteur x p, s'il reçoit un vecteur dy p de même dimension que son vecteur de sortie, son modèle adjoint calculé en x p est alors dx p = F T p dy p, qui a la même dimension que le vecteur d'entrée de F p. La matrice F T p est la transposée de la matrice jacobienne du module F p calculée au point x p. On démontre alors (voir annexe 7.1), qu'on peut calculer le modèle ajoint du modèle global M (représenté par son graphe Γ ) pour chaque vecteur dy ayant la même dimension que son vecteur de sortie (dx = Γ T dy). On a besoin pour faire ce calcul de parcourir le graphe dans 16

17 l'ordre topologique inverse, ce qui correspond à utiliser les arcs en sens opposé, il s'agit du parcours en passe arrière, ou rétropropagation, du graphe modulaire (backward). Le parcours en passe arrière présente une diculté par rapport au parcours en passe avant. En eet, la transmission des données se fait toujours par l'intermédiaire des connexions de base. Comme l'illustrait la gure 2-a, lors du parcours en passe avant, une et une seule donnée est transmise à une entrée particulière. Par contre, lors du parcours en passe arrière, plusieurs données peuvent être transmises à une sortie particulière d'un module F p (exemple de y p2 de la gure 2-a). Dans le cas de l'adjoint, un calcul intermédiaire s'impose, il consiste à préparer le vecteur dy p en sortie du module F p avant de faire le calcul dx p = F T p dy p. On démontre (voir annexe 7.1) que la jème composante de dy p doit être calculée en faisant la somme de toutes les données du type dx q,i qui lui seront transmises, par retropropagation le long de toutes les connexions de bases prenant leur entrée en y pj. Ainsi, dans le cas de la gure 2-a, on doit calculer dy p2 = dx q2 + dx l1. Les diérentes données dx p,i retropropagées sont, soit issues d'un calcul par un module successeur de F p du graphe modulaire, soit calculées (ou initialisées) par le contexte extérieur du graphe modulaire. Finalement, le résultat du calcul de l'adjoint dx du modèle global (dx = M T dy) est constitué par les composantes des vecteurs dx p qui correspondent à des entrées prenant leur valeur du contexte extérieur du graphe du modèle. Ces opérations sont résumées par algorithme 3. La gure 5 montre un exemple des calculs à eectuer. Algorithm 3 backward Cet algorithme s'applique après que toutes les entrées x p de tous les modules aient été calculées une fois avec l'algorithme forward pour un vecteur d'entrée x. 1) Initialiser le vecteur dy des sorties du graphe Γ du modèle M (ceci correspond à toutes les connexions de bases transmettant des données vers le contexte extérieur ). 2) Visiter les modules dans l'ordre inverse à l'ordre topologique (parcours en passe arrière du graphe). Pour chaque module F p rencontré, eectuer le calcul de dy p (comme indiqué dans ce paragraphe) et calculer l'adjoint dx p = F T p dy p, cet adjoint étant calculé au point x p (on suppose par hypothèse que ce calcul est possible). 3) Recupérer le résultat du calcul de l'adjoint dx. Ce vecteur est constitué par les composantes des vecteurs dx p qui correspondent à des connexions de bases prenant leurs entrées du contexte extérieur au modéle. 17

18 Figure 5: calcul du l'adjoint dans un graphe modulaire. Il s'agit du même graphe que celui de la gure 4. Les notations sont équivalentes à ceci près que l'indice en p remplace celui en q. Les èches en pointillé représentent le parcours en passe arrière pendant lequel le calcul adjoint est eectué. Pour ce calcul, on rappelle cependant que chaque compsante dy p,j d'un module est constitué de la sommes des dx q,i de ces modules successeurs. Cette opération est représentée par le symbole Σ sur le graphe. Remarque Les deux algorithmes (2, 3), supposent que l'on sait faire le calcul du tangent linéaire et de l'adjoint pour chaque module F p. Les modules peuvent avoir des complexités très diérentes. Dans un cas simple, où le module est une fonction analytique, on peut calculer explicitement la matrice jacobienne F p et faire le produit F p dx p et F T p dy p. Concernant les modules plus complexes, on peut faire appel à des programmes qui font ces calculs (par exemple programme obtenus après utilisation d'un générateur automatique, voire même, par un autre graphe modulaire). Ainsi le formalisme de graphe modulaire permet de combiner diérentes méthodes pour construire des modèles de calcul complexes. Les algorithmes (2, 3) permettent, grâce au parcours avant et arrière du graphe, de calculer directement les résultats du tangent linéaire et de l'adjoint pour des modèles complexes Représentation d'une application par graphe modulaire Réaliser une étude de sensibilité ou une assimilation de données variationnelle suppose que l'on est capable de prendre en compte des graphes de grande complexité et que l'on gére les échanges (entrées, sorties) avec l'extérieur du graphe. On peut repérer plusieurs partie du graphe présentant des comportements différents. On distingue en particuilier le graphe qui correspond au modèle M = M t (M t 1 (...M 0 )) et celui qui représente l'opérateur H qui apparaissent dans les formules présentées au chapître précédent. Nous noterons par Γ M, Γ M t,γ H les graphes de calcul correspondant. Le graphe représentant le problème physique 18

19 dans son entier sera noté ΓΨ. Il correspond à l'organisation globale de l'ensemble des opérations liant les diérents graphes Γ. Comme précédemment, le graphe ΓΨ est déni par des échanges avec l'extérieur qui prend en charge, par exemple, l'ensemble des problèmes liés à la fonction de coût (matrice de variance covariance, expression moindre carré...). Nous expliquons dans la suite du paragraphe cette organisation. Réaliser une simulation ou une assimiltion de données dans un modèle géophysique M = M t (M t 1 (...M 1 )) opérationnel suppose que l'on est capable de dénir le graphe modulaire représentant l'ensemble des calculs qui vont s'eectuer dans la fenêtre de travail. Cet ensemble de calculs présente la plupart du temps une certaine répétitivité due au fait qu'un même phénomène physique se répète lorsque l'on se déplace dans l'espace ou dans le temps. L'ensemble de ces opérations caractérise ce que l'on appelle en géophysique une maille, endroit ou physiquement les grandeurs géophysiques sont estimées. De la même manière, le graphe modulaire Γ M va prendre en compte cette notion de répétitivité et permettre les échanges spatio-temporels. Ainsi, le graphe modulaire de Γ M intègre 3 niveaux d'abstraction (voir gures 6 et 7) : 1) On détermine d'abord un sous graphe modulaire dit de base Γ g qui décrit l'ensemble des opérations intervenant à un point de grille (gure 6.a). 2) La dénition d'un modèle (1D-2D,3D) à un instant t donné est donc un graphe modulaire dont les noeuds sont les sous graphes modulaires Γ g, les arcs décrivant les échanges spatiaux entre points de grilles. Cela dénit le graphe (Γ M t ) entre mailles. On utilise comme auparavant, des connexions de bases entre modules de points de grille diérents pour décrire les calculs à eectuer (gure 6.b). Figure 6: deux niveaux d'abstraction de graphe: Au niveau le plus bas, on construit le graphe de maille Γ g (a). Au niveau spatiale (b) le même graphe Γ g est répliqué pour chaque maille formant ainsi le graphe de l'espace Γ M t (en 2D dans cet exemple). Les connexions spatiales entre graphe Γ g correspondent aux connexions de base entre modules. 3) La prise en compte du temps demande que l'on le déplie dans le temps le graphe Γ M t. On procède de la même manière pour avoir enn le modèle complet Γ M recherché. Γ M sera représenté par un graphe linéaire dont les noeuds 19

20 sont représentés par les graphes modulaires Γ M t, les arcs ou connexions de base décrivent les échanges d'un pas de temps à l'autre. Comme cela a été déni précédemment, on retrouve les mêmes notions d'entrée et de sortie pour chacun des graphes Γ g, Γ M t et Γ M. Les connexions de base entrantes venant de l'extérieur de Γ M peuvent provenir par exemple de l'initialisation, de conditions limites. Les connexions de base sortantes allant vers l'extérieur vont communiquer leurs valeurs pour calculer par exemple une fonction de coût. Bien entendu les graphes Γ M t et Γ M ne se construisent pas explicitement. Il n'est nécessaire que de décrire le graphe de base Γ g, sachant que ses connexions de bases entrantes et sortantes permettent d'établir automatiquement l'ordonnancement des deux autres graphes. L'exemple qui suit, montre sur un exemple 1D (illustré par la gure 7) le dépliment temporel qui permet de comprendre l'éboration de Γ M. On considère un modèle, dont l'évolution de l'espace des états entre deux temps consécutifs est régie par un modèle d'évolution numérique discrétisé M. Prenons, pour simplier, un modèle en colonne de coordonnée z. avec 4 variables d'état u, v, w et h. La discrétisation, numérique conduit à exprimer pour chaque variable sa dépendance fonctionnelle par rapport aux autres variables qui peuvent se situer sur des points de coordonnées quelconques. Supposons que la dicrétisation nous donne, par exemple, les équations suivantes (Il s'agit ici d'un cas entièrement ctif qui n'a aucun sens physique ou autre) : u z (t) = u z (t 1) + h z 1 (t) FO v z (t) = K (u z (t)) 2 F1 w z (t) = u z (t) + v z (t) F2 h z (t) = v z (t) + w z (t) F3 Ce système d'équations, lorsqu'il est appliqué, en chaque point de maille, pour passer d'un temps t 1 au temps t, correspond au modèle M. Si, par exemple, la variable u est celle que nous voulons contrôler, l'ensemble des composantes u z (0) correspondrait à ce que nous avions noté x(t 0 ) au chapitre 2, c'est le vecteur d'état initial en entrée du modèle et à contrôler. Nous associons respectivement à chacune des ces variables u, v, w et h, un module F0, F1, F2 et F3. Ces équations se traduisent donc par un enchaînement de modules qui correspond à un graphe modulaire simple. F0 calculera u z (t) en fonction de u z (t 1) et de h z 1 (t), c'est à dire avec la sortie de F0 au même point de maille, mais au temps précédent et celle de F3 au point de maille z 1, (etc pour F1, F2 et F3). Sur la gure 7 le graphe en une maille représente cette situation. En chaque maille, le module d' entrée du graphe modulaire correspond aux entrées de F0 et son module de sortie correspond aux sorties de F3 (F1 et F2 sont des modules interne). Dans ce type de schéma, on est évidemment confronté à la phase d'initialisation et à la gestion des conditions limites. Sur notre gure, la prise en charge de ces éléments est représentée par ce que nous avons appelé l'extérieur du graphe. Ce 1er graphe modulaire simple constitue notre graphe de base générique Γ g. A partir de ce 1er niveaux d'abstraction, la gure 7 illustre les niveaux d'abstraction suivants Γ M t et Γ M. 20

21 Figure 7: exemple d'un graphe modulaire simple. Pour une maille : F0 est le module d' entrée, F1 et F2 sont des modules internes, F3 est le module de sortie. Calculer, en un temps t, tous les modules en chaque maille selon leur ordre dans le graphe correspond au calcul de M i (x(t 0 )).. L'opérateur H exprime la partie de la physique liée à l'observation. la réalisation de son graphe pour un temps t quelconque (ΓH t ) suit un mécanisme d'élaboration similaire à celle de ΓM t. Cependent, il n'intervient qu'à certains pas de temps au endroit où il y a des observations (donc pas nécessairement tous). Il n'existe pas d'arc entre les diérents temps de cet opérateur. Comme le montre la gure 8, les entrées sorties se font de ΓM j vers ΓH j et de ΓH j vers l'extérieur pour participer, par exemple, au calcul de la fonction de coût. Cette gure pourrait laisser croire que l'on duplique l'espace mémoire pour ΓH, bien entendu, dans la pratique il n'en est rien, une seule et même zone mémoire est utilisée à chaque fois. 21

22 Figure 8: graphe d'une application La gure 8 illustre une application complète. Celle ci est constituée du graphe repésentant le problème physique ΓΨ (zone foncée) et de la partie qui lui est extérieur (zone hachurée en jaune) qui contient les données et les algorithmes qui permettent d'eectuer toute sorte de traitement sur ce graphe. Par exemple on peut prendre en compte des forcages, charger des observations, calculer la fonction de coût en utilisant diérents algorithmes (3D-Var, 4D-Var, incrémental), lancer des tests de validation (test de la fonction objective, test de l'adjoint), récupérer des résultats pour les visualiser Mise au point d'expériences de simulation et/ou d'assimilation Le formalisme de graphe modulaire qui vient d'être présenté constitue la base du fonctionnement du logiciel YAO. Il procure à YAO des algorithmes ecaces pour obtenir les calculs relatifs au tangent linéaire et à l'adjoint pour l'assimilation 3D-Var et 4D-Var. Une expérience de simulation et/ou d'assimilation demande d'intégrer et d'organiser ces calculs selon les diérentes méthodologie présentées au chapitre 2 et plus généralement dans la littérature. Pour cela, la modélisation géophysique doit être eectuée et les opérateurs d'observations spéciés. Ces opérations correspondent à la partie dénie au paragraphe précédent comme le graphe de l'application ΓΨ. Il faut aussi dénir les conditions dans lesquelles va s'eectuer l'expérience (conditions initiales, forçages, temps et lieux auxquels seront disponibles les observations) et prendre également en compte les matrices de variance-covariance sur les erreurs d'ébauche et d'observation qui permettent de lier les variables entre elles. Chaque application demande de choisir une fonction de coûts et un algorithme de minimisation adapté au problème traité. Sur un autre registre, il faut aussi posséder des outils de tests et de visualisation permettant de contrôler le déroulement de l'assimilation et de pouvoir juger des résultats. L'ensemble de ces opérations se situent dans la partie dénie au paragraphe précédent comme l'extérieur du modèle. YAO organise ces diérentes étapes sous forme de composants diérenciés qui ont des rôles spéciques : 22

23 Gestion de diérentes sortes de données nécessaires à l'application (paramètres, forçage,...). Choix de la fonction de coût: C'est à ce niveau que doivent être intégré les matrices (ou opérateurs) de variance-covariance sur les erreurs d'ébauche et d'observation. Certaines fonctions de coût, comme celle présentée au chapitre 2.1 et sa version incrémentale sont directement disponibles dans YAO. Il est par ailleurs possible d'intégrer d'autres méthodes (par exemple la méthode duale) qui vont pouvoir communiquer avec le graphe modulaire de l'application. La fonction doit alors être programmée par l'utilisateur et demande une connaissance plus approfondie de la structure du logiciel YAO. Choix du minimiseur : avec YAO il est possible d'utiliser les minimiseurs de l'inria, M1QN3 et M2QN1 [16, 17]. Bien entendu d'autres algorithmes de minimisation peuvent être interfacés. Outils de vérication: Dans YAO il est nécessaire de savoir calculer l'adjoint et le tangent linéaire de chaque module. Ceci peut se faire de diérentes manières et il importe de pouvoir vérier qu'à ce stade tous les adjoints et tangents linéaires qui ont été calculés sont exacts. YAO facilite ces vérications en permettant d'accéder à diérents tests de validité: test de l'exactitude des jacobiens {par approximation des dérivées}, test sur l'application globale du tangent linéaire, de l'adjoint et de la fonction de coût. Visualisation des résultats: La bonne conduite d'une expérience de simulation et/ou d'assimilation demande de visualiser le comportement des diérentes variables, des gradients et des fonctions de coût pendant la période considérée. YAO permet d'accéder à l'ensemble de ces quantités et l'utilisateur peut donc en communicant avec le graphe de l'application les transmettre vers l'extérieur pour écrire les programmes ou utiliser les outils de visualisation qu'il juge utile. La section 4.7 présente la décomposition complète d'une application montrées sur les équations du shallow water, sur laquelle sont présentées plusieurs expériences d'assimilation. Ÿ 23

24 4 YAO 4.1 Présentation générale Les deux premières parties du document ont présentés le cadre général de l'assimilation des données sous jacent à l'utilisation du logiciel YAO. Supposant connue la modélisation d'une application sous forme de graphe modulaire, YAO va prendre en charge une part des codes à écrire comme ses fonctions associées de passe avant et arrière (forward, backward). Le graphe modulaire correspond alors à l'espace de la modélisation dans lequel les calculs vont se dérouler. En orant un cadre de développement, YAO prépare et facilite l'implémentation informatique de ces modèles numériques ce qui permettra d'en eectuer des simulations. De plus, si l'on suppose connu les adjoints de chaque module, YAO code automatiquement l'adjoint du graphe, ce qui permet de faire également des expériences d'assimilation de données. YAO permet l'étude de problèmes en une, deux ou trois dimensions au choix, auxquelles on peut ajouter la dimension temporelle si cela s'avère nécessaire. Il ore la possibilité de dérouler plusieurs trajectoires simultanément qui peuvent être elles-mêmes porteuses de plusieurs espaces (bien que le couplage spatiale d'espaces de maillage diérents ne soit pas assuré actuellement). Il prévoit aussi la prise en compte de modèle d'opérateur d'observation et de covariance pour le calcul de la fonction de coût. L'un des soucis qui a aussi prévalu est que l'utilisateur n'ait à se concentrer que sur les tâches de haut niveau de son application dont l'essentiel doit se dénir par : - la déclaration des modules et de leur graphe - la programmation des modules c'est à dire essentiellement la programmation des fonctions des modules et de leurs dérivées. Dans ce but, on a essayé au mieux de simplier la syntaxe des commandes et l'écriture du code. De ce fait : * YAO est adaptable, Il permet de maintenir l'exactitude d'un code lorsque des modications de celui-ci doivent avoir lieu. On peut par exemple : - modier les modules et en utiliser diérentes versions. - créer de nouveaux modules et les intégrer dans le modèle. - modier le graphe d'ordonnancement de l'exécution des modules. * YAO est évolutif, en eet : - YAO donne la possibilité d'intervenir à diérents moments dans le déroulement des calculs (que nous appelons des points d'intervention) ce qui permet une grande souplesse dans la création de modèles. - YAO possède un jeu d'instructions propre qui permet son fonctionnement, mais l'utilisateur peut créer en plus ses propres instructions qui viendront enrichir celles qui existent déjà. - On peut créer une (ou plusieurs) bibliothèque de modules communs (i.e. utilisables par diérentes applications). - Un jeu de macros contribue à rendre indépendant la programmation des modules de l'implémentation technique faite par YAO. Les schémas aux diérences nies est le domaine de prédilection de YAO. Cela découle de la localité supposée de l'approche de graphe modulaire présenté au chapitre 3 ainsi que du domaine sur lequel cette méthode a été appliquée initialement ([13, 24]) et à partir duquel YAO a été conçu. 24

25 Enn, parmi les diérentes fonctionnalités apportées par le logiciel YAO, signalons les suivantes qui méritent plus particulièrement d'être mentionnées : YAO - prévoit un interfaçage avec les minimiseurs m1qn3 et m2qn1 de l'inria, - peut intégrer automatiquement des réseaux de neurones, - permet de prendre en compte des termes d'ébauche, des opérateurs d'observation et de covariance d'erreur dans le calcul de la fonction de coût y compris dans sa version incrémentale, - propose des fonctions de validation pour eectuer les tests exposés à la section Il dispose aussi de diérentes fonctions d'entrée/sortie. Le langage de développement d'une application sous YAO est le C/C Concepts généraux, dénitions, vocabulaire Dans sa conception, YAO ne s'attache pas à un type de problème en particulier, il se veut générique et modulaire. Pour ainsi dire, Il ne s'intéresse pas au contenu des objets qu'il manipule. Pour préciser les idées, disons que YAO permet de construire une `application'. Du point de vue strict de YAO, cette notion est abstraite, il ne s'agit que d'un ensemble d'objets que l'on regroupe quelqu'en soit la provenance, pourvu que les règles de YAO soient respectées. On considère tout de même, qu'une application correspond à une modélisation qui va faire l'objet d'une `description'. Pour construire le graphe modulaire de cette modélisation, cette description doit spécier entre autre chose, les caractéristiques des ` espaces' des modèles (dimension 1D-2D-3D et taille) et celles des `trajectoires' (temps) auxquelles ils sont rattachés. Elle permet de déclarer les `modules' utilisés par l'application pour construire le graphe. Outre les modules eux mêmes, elle doit référencer au moins un chier source global à l'application qui contiendra certaines fonctions obligatoires pour YAO. Ce ou ces sources globaux, dit `chapeau' (ou hat) peuvent contenir d'autres données ou fonctions utiles aux applications qui les emploient. 25

26 Figure 9: Dans OPA (application sur la circulation générale des océans) développé au LOCEAN on trouve plusieurs modèles bio-géochimiques (NNPZDDOM, P3ZD, PISCES,...). En hydrologie, l'application ISBA (qui est un modèle sol, végétation, atmosphère) référence également plusieurs modèles (ISBA-FR, ISBA-DF,...). YAO ne fait pas d'objection à ce qu'une application utilise les objets d'autres applications. C'est ce que nous voulons montrer ici où par exemple, pour une nouvelle application, nous pouvons utiliser des objets d'opa (le source chapeau hat 2, les modules modul i et modul k ) et d'autres de ISBA (hat c, modul y, modul t ). On voit que pour YAO, la notion d'application est large. Elle autorise la réutilisation d'objets déjà créés ce qui en permet les échanges entre applications. Le schéma de la gure 9 clarie la situation en illustrant cette possibilité. Nous décrivons maintenant plus en détail l'ensemble des constituants nécessaires à l'élaboration d'une application. 4.3 Fichier de description Pour décrire une application, une terminologie a été élaborée. Elle consiste en des directives qui dénissent des caractéristiques du modèle physique à implémenter. En particulier, il faut : Spécier les trajectoires qui portent les informations temporelles utiles à l'application. Il s'agit en particulier du nombre de pas de temps nécessaire à l'initialisation et à la trajectoire. Lorsqu'il y a plusieurs trajectoires, des informations supplémentaires doivent être données qui permettent à YAO d'enchaîner les diérents pas de temps de chaque trajectoire. Introduire les espaces (de calcul) et leur dimensions (jusqu'à 3), correspondant aux modélisations (par graphes modulaires) à réaliser. Le plus souvent, 26

27 ces dimensions correspondent à l'espace physique, mais pas nécessairement. De la même manière, on peut introduire des opérateurs d'observation et de covariance. Ces espaces sont rattachés à une trajectoire. Une trajectoire peut comporter plusieurs espaces. Déclarer, et créer les modules qui expriment les équations du modèle, et les doter des attributs qui leur correspondent : nombre d'entrées et de sorties, sont-ils à contrôler, participent t-ils de la fonction de coût, etc... Un module est associé à un espace. La gure 10 montre un exemple très simple de programmation d'un module d'une application YAO. Construire le graphe, c'est à dire créer les connexions de base établissant les liens entre les sorties et les entrées des diérents modules. Cela peut être fait par référence absolue ou relative aux coordonnées spatio-temporelles. Par exemple, dans un espace 2D, et pour un module Z au point i, j, t de maille courant, on peut indiquer que sa n ime entrée provient de la m ime sortie d'un module A aux coordonnées rélatives i + 1, j 2, t 1. La syntaxe d'établissement des connexions de YAO permet quelques raccoucis comme on le montre gure 11, Indiquer l'ordre de parcours de l'espace, c'est à dire l'ordre dans lequel les mailles doivent être calculées, mais aussi l'ordre de calcul des modules dans la maille. La séquence de calcul des espaces de chaque trajectoire doit également être spécié. Figure 10: Programmation d'un module : en paramètre d'entrée, on récupère les variables réelles (double ou oat) conformément aux connexions qui ont été établies. La première fonction (forward) est utilisée pour le calcul du modèle direct. La fonction backward doit coder le Jacobien du module (dérivée des sorties par rapport aux entrées). Elle sera utilisée pour le linéaire tangent ou l'adjoint. (YS1, YJ1I1,... sont des macros créées par YAO pour faciliter la programmation : YSi correspond à la ième sortie; YJjIi correspond à la dérivée de la jième sortie par rapport à la ième entrée). 27

28 Figure 11: Quelques exemples de création de connexions entre modules. Un connectivité de voisinage peut être créée par une unique déclaration; (a), (b), (c) et (d) en représentent des illustrations qui correspondent à la connectivité d'un module A situé à diérents points de coordonnées vers le module Z à un point ijt courant. Toutes ces informations doivent être consignées dans un chier de description. Ce dernier sera utilisé par YAO pour génèrer le code adéquate qui en respecte les spécications. 4.4 Structuration d'une application sous YAO: Les parties standards et spéciques sont bien distingués et séparées ce qui facilite la compréhension et la maintenance. Globalement, une application se compose : Pour la partie spécique que l'utilisateur doit prendre en charge : - du chier de description du modèle (évoquée ci-dessus), - du ou des sources chapeau : Intégrant des fonctions obligatoires et des données et/ou fonctions spéciques et globales, - des sources des modules : Programmation des diérentes fonctions qui contiennent les calculs à eectuer pour simuler les lois physiques du schéma direct et de leur dérivée. Pour la partie standard fournie automatiquement par YAO : - du code propre à YAO : L'interpréteur de commandes, les fonctions standards (comme par exemple celles d'entrée-sortie, de gestion des observations, de run, de validation, etc.), la boite à outils, des variables et constantes globales. - du code généré par YAO : Particulièrement pour les modules et selon leurs attributs : calcul du coût, ajustement,..., parcours de l'espace en passe avant et arrière en référençant les fonctions des modules, puis leurs dérivées. Avec l'ensemble de ces éléments, la procédure de YAO va créer un exécutable. 28

29 4.5 Le chier d'instructions L'exécutable préalablement créé par la procédure YAO pourra interpréter un jeu d'instructions (ou commandes) qui lui est soumis via un chier texte (chier d'instructions) ou éventuellement en mode interactif. La séquence des instructions peut permettre d'initialiser le modèle, état et/ou paramètres initiaux, de dénir les tailles des mailles, la valeur des pas de temps, de charger des observations, de prendre en compte un terme d'ébauche pour la fonction de coût, de lancer une expérience d'assimilation en ayant préalablement choisi le nombre d'itérations, déni des critères d'arrêt pour la convergence de l'algorithme de minimisation, etc. Pour YAO, une instruction consiste simplement en un nom suivi ou non de paramètres. YAO founit plusieurs instructions standard qui remplissent les fonctionnalités de base comme on vient de l'évoquer, mais il est aussi possible, pour des besoins spéciques, que l'utilisateur enrichisse le jeu d'instructions de YAO par les siennes propres (qu'il devra déclarer dans le chier de description et programmer dans le chapeau). La gure 12 illustre le déroulement complet de la procédure YAO. Il convient d'attirer l'attention sur le fait que, seules les modications du chier d'instructions ne nécessite pas le relancement de la procédure. Ce qui veut donc dire a contrario, que dès que l'on modie un autre élément de l'application (chier de description, source d'un chapeau ou d'un module) il faut relancer la procédure. Ainsi, créer ses propres instructions, pour par exemple, positionner diéremment des paramètres, facilite la manipulation du modèle. Figure 12: Représentation schématique de la procédure YAO : En premier lieu, YAO génère le code à partir du chier de description des spécications du modèle. Ce code généré, le code prédéni de YAO et les sources des modules utilisateurs sont intégrés en une seule application qui est compilée et linkée pour produire un exécutable. Ce dernier associé à un chier d'instructions qui le pilotera produira les résultats. 4.6 Schéma global d'agencement des calculs dans YAO Nous voulons ici permettre au lecteur de se familiariser plus concrètement avec la 29

30 façon dont les calculs sont organisés par YAO. Nous nous plaçons dans un cas classique d'assimilation (3D-Var ou 4D-Var). La gure 13 nous permettra d'illustrer notre propos. An d'appréhender plus concrètement un cas pratique, le lecteur pourra également se repoter au TP sur le shallow water (section 4.7). Figure 13: schéma globale d'organisation d'un modèle Cette gure représente un schéma d'assimilation d'un modèle (3D) M dont le but sera la minimisation de la fonction de coût J(x 0 ). Le modèle M a été décrit par un graphe modulaire générique en un point de maille (Γ g). Ce graphe, qui correspond à un schéma de calcul, sera répliqué automatiquement par YAO pour toutes les mailles. Le modèle M se déroule sur une trajectoire (trait en gras sur la gure), soit en passe avant (forward) soit en passe arrière (backward) comme le montre les èches en pointillé. YAO a prévu la possibilité, pour l'utilisateur, de reprendre la main à diérentes étapes de ces calculs. C'est que nous avons appelé des points d'intervention qui se matérialisent par des appels de fonctions. Ces fonctions sont donc obligatoires (même si elles ne font rien). Elles sont en général codées, à toute n utile, dans le chier chapeau (ce peut par exemple être des forçages,...). Outre le Modèle M, on peut utiliser des opérateurs d'observation (H) ou de covariance d'erreur (R 1, B 1 ). Avec YAO, la création de tels opérateurs s'eectue de façon similaire à la création d'un modèle M. Par contre, le déclanchement de ces opérateurs est guidé par la présence de variables d'observation sur un pas de temps (que nous avons représentées par des sur certaines mailles de notre gure) pour l'opérateur R 1 et par celle de termes d'ébauche pour B 1. Nous rappelons, que ces opérateurs ne sont pas alloués sur toute la trajectoire; il n'est nécessaire d'en créer qu'une seule occurence qui ne sera utilisée que sur chacun des pas de temps d'observation. Le corpus de description de YAO permet de gérer correctement ces 30

31 congurations. Par ailleurs, YAO autorise la prise en compte d'observations sur n'importe quel point de maille et à n'importe quel pas de temps. Décrivons, dans ses grandes lignes, un enchaînement logique des tâches à eectuer : 1) Tout d'abord, il faut initialiser le modèle, ce qui est réprésenté par la partie en pointillé du début de la trajectoire. Pour cela, l'utilisateur peut créer une (ou des) fonction spécique qui xera les valeurs des modules d'entrée et certaines variables ou paramètres généraux du modèle. 2) Il faut ensuite prendre en compte les observations. Cela peut ce faire avec les fonctions d'entrées/sorties de YAO. 3) On peut alors lancer un run d'assimilation. YAO prévoit des instructions pour choisir certains des paramètres nécessaires (coecient de la fonction de coût, nombre d'itérations, critère d'arrêt,...), mais aussi diérents algorithmes liés à la minimisation (M1QN3, M2QN1, incrémental). Nous pouvons préciser ici qu'un cycle d'assimilation est composé d'une passe avant (forward), d'une passe arrière avec rétropropagation des quantités à adjointiser (backward); il s'agit en général des gradients d'erreur de la fonction de coût, et enn d'une itération de minimisation qui ajuste les variables de contrôles. Dans YAO, c'est par le biais du chier d'instructions que peuvent être exécutées ces diérents étapes de traitement. Ÿ 31

32 4.7 Exemple pratique d'application : LE SHALLOW-WATER (TP didactique) Le modèle du shallow-water (appelé aussi modèle de Saint-Venant) à deux dimensions (2D) dans le plan horizontal (x, y) découle de l'intégration verticale des équations de Navier-Stokes à trois dimensions (3D). Les équations de ce modèle décrivent un écoulement linéaire d'un uide non visqueux en eau peu profonde à surface libre. L'évolution en est décrite par le système d'edp suivante : où : u t = g. h x + f.v γ.u v t = g. h y f.u γ.v ( ) h t = H. u x + v y u et v sont les vitesses du courant sur les axes x, y respectivement, h est {l'amplitude, la hauteur} de la surface libre, g est le terme de gravité réduite, f est le paramètre de Coriolis, γ est un coecient de dissipation, H est la hauteur d'eau moyenne Discrétisation. Le schéma numérique représentant le système d'edp présenté se résoud en utilisant spatialement la grille C d'arakawa selon des incréments x et y (gure 14), et temporellement en enchaînant une discrétisation de type leap frog de pas t suivi d'un ltre d'asselin pour assurer la stabilité. La discrétisation spatiale se fait sur une grille régulière 2D. La grille C d'arakawa dispose spatialement les diérentes variables de façon régulière comme le montre la gure 14-a. On observe que chaque variable individuellement n'est présente qu'en certains points (x,y). L'espace est discrétisé, le maillage utilisé selon des indices (i,j ) va nous permettre de regrouper les 3 variables (u,v,h) à calculer. Le calcul de la variable u (resp v) au point (x,y) nécessite la connaissance de la valeur de v (resp u) en ce même point. On l'estime en faisant la moyennne des valeurs de v (resp u) spatialement adjacentes. Par ailleurs, comme il apparaît la gure 14-b, nous considèrerons que notre modèle est bordé de murs (comme dans une piscine), les vitesses (u, v) sur ces conditions aux limites sont donc nulles. Sachant que le sens de u est de gauche à droite, celui de v de bas en haut, comme le montre les èches en pointillé, on prend en compte les conditions aux limites en annulant les vitesses (u) qui entrent dans un mur ou celles (v) qui en sortent. Sur la gure 14, les bords sont représentés par les zones hachurées. Les parties intérieurs, en gras sur la gure, correspondent à l'espace dans lequel notre modèle évolue. 32

33 Figure 14: Grille C d'arakawa, maillage et conditions limites. la grille C d'arakawa (a) donne une répartition spatiale de chaque variables les unes par rapport aux autres selon des points de coordonnées x, y. Dans le cadre d'un schéma aux diérences nies, la discrétisation nécessite de mailler cet espace (b), chaque maille étant repéré par des indices i, j. Le schéma temporel du leap frog s'exprime de la facon suivante : soit : x t = x t+1 x t 1 2 t = F (x t ) + G(x t 1 ) x t = x t t. (F (x t 1 ) + G(x t 2 )). où x t = (h t,, u t, v t ), F correspond à la partie dynamique des équations et G à la partie physique. Il s'agit d'un schéma d'ordre 2 pour lequel on ne dispose pas initialement du terme en t 2. On eectue donc une phase d'initialisation pour laquelle on utilise le schéma temporel d'euler qui est d'ordre 1. Pour éliminer les oscillations temporelles induit par les schémas de type leap-frog, on utilise le ltre d'asselin. Son application nécessite d'introduire, pour chaque point de grille, trois variables intermédiaires ĥ, û et ˆv. La fonction du ltre d'asselin est donnée par : ˆx t = filtre(ˆx t 1, x t, x t+1 ) = x t + α(ˆx t 1 2x t + x t+1 ) où x représente respectivement les variables h, u et v et où α est un paramètre de ltrage. Après initialisation, le schéma numérique à implémenter est le suivant : Pour la dynamique : u ijt = û ijt 2 +2 t ( g [h x i+1jt 1 h ijt 1 ] + f [v ) ( 4 ijt 1 + v ij+1t 1 + v i+1jt 1 + v i+1j+1t 1 ] γ.û ijt 2 ) g v ijt = ˆv ijt 2 +2 t [h y ijt 1 h ij 1t 1 ] f [u 4 i 1j 1t 1 + u i 1jt 1 + u ij 1t 1 + u ijt 1 ] γ.ˆv ijt 2 h ijt = ĥijt 2 2 t.h ( uijt 1 u i 1jt 1 x Pour le ltre d'asselin : û ijt = u ijt + α(û ijt 1 2u ijt + u ijt+1 ) ˆv ijt = v ijt + α(ˆv ijt 1 2v ijt + v ijt+1 ) ĥ ijt = h ijt + α(ĥijt 1 2h ijt + h ijt+1 ) + v ij+1t 1 v ijt 1 y 33 )

34 4.7.2 Modélisation Par graphe modulaire YAO Nous allons maintenant construire notre graphe modulaire. Nous décidons de dédier un module pour chacun des termes à calculer. Nous aurons donc 6 modules nommés Hphy, Uphy, Vphy pour les variables physiques (h, u, v) et Hl, Ul et Vl pour les variables intermédiaires issues du ltrage (ĥ, û, ˆv). Les liens entre les entrées et sorties de modules (connexions de base) issu du positionnement relatif spatio-temporel des modules entre-eux se déduisent des indices des variables dans les équations discrétisées. Figure 15: Graphe modulaire pour les modules Hphy et Hl. Par exemple, la gure 15 illustre le graphe relatif aux module Hphy et Hl. On remarque qu'ils ont 5 entrées pour le premier, et 3 pour le second, ces deux modules n'ont qu'une seule sortie. D'une manière similaire on devra décrire le graphe pour les 4 autres modules (il n'est cependant pas absoluement nécessaire d'en faire le dessin). On rappelle, que cette descrition correspond au calcul à eectuer en une maille, YAO prenant en charge le dépliment en espace et en temps. On remarque que l'évaluation des variables physiques (h, u et v) au temps t demande de connaître les champs au temps t 1 et les champs ltrés (ĥ, û et ˆv) au temps t 2. La discrétisation proposée ne s'applique qu'à partir du temps t = 2 et utilise des champs aux temps t = 0 et t = 1 qu'il faut déterminer dans une phase d'initialisation. Toujours daprès le schéma de la gure 15, on voit que le calcul de ĥ au temps t (ĥijt) nécessite la connaissance de h au temps suivant (h ijt+1 ). An d'assurer un déroulement séquentiel des calculs, le champ h ijt+1 devra être calculé avant le champ ĥijt. Il y a donc une distinction entre le temps du modèle géophysique (pour lequel ĥijt est avant h ijt+1 ) et le temps de déroulement du calcul (pour lequel h ijt+1 est calculé avant ĥijt). Il en ira de même pour les autres variables, û et u d'une part, et ˆv et v d'autre part. La gure 16 illustre le déroulement des itérations de calcul nécessaire pour initialiser la trajectoire et contrôler le champ initial. Elle permet de comprendre l'imbrication des calculs liés au saute mouton et au ltre d'asselin 34

35 Figure 16: Saute mouton et ltre d'asselin. Les carrés représentent les modules. On a indiqué, à côté la variable calculée avec l'indication de l'indice temporel. Les itérations de calculs sont indiqués sur la gauche avec la notation Yt. On remarque que les variables physiques (h) au temps 2 et ltrés (ĥ) au temps 1 sont calculées à l'itération 3. Dans YAO, c'est le nombre d'itérations de calcul qui doit être déclaré. L'étude de cas qui suit, va contrôler le champs de hauteur au temps 0. Le début du processus se fait en initialisant ce champ et en aectant la même valeur au champ ltré. Pour garder une cohérence entre les champs physiques et les champs ltrés, on crée en amont, une itération supplémentaire qui les lie (Yt=0 sur la gure). Dans la suite, nous traitons une étude de cas présentée ci-après pour laquelle l'implémentation dans YAO sera détaillée Etude de cas Caractéristiques du modèle donnons sont les suivantes : Les caractéristiques du modèle que nous nous grille 50x50 : x = y = 5000 mètres 100 pas de temps : t = 1500 secondes soit approximativement 1 jours, 17 heures paramètre de Coriolis f = 10 4 s 1 gravité réduite g = 10 1 s 2 coecient de dissipation γ = 10 5 hauteur moyenne du uide H = 100 mètres 35

36 hauteur initiale en forme de cloche centrée à l'origine : ĥ ij0 = b e 1 2( i x x σx )) 2 e 2( 1 i y y σy ) 2 avec b = 15mètres (hauteur au point de centrage) x = y: moyenne = mètres σx = σy : écart type = mètres initialisation des vitesses û, ˆv à l'équilibre géostrophique : û ij0 = g f ĥij0 j y y et ˆv σy 2 ij0 = g f ĥij0 i x x σx 2 Expériences d'assimilation Avec cette conguration, nous allons réaliser différentes expériences d'assimilations. Nous nous plaçons dans le cadre d'une expérience jumelle 1. Les observations seront donc générées à partir du modèle selon la conguration qui vient d'être décrite. Cas 1 : Assimilation et contrôle de la hauteur ĥ à partir d'une perturbation de ĥ en prenant : b = 5mètres. Attention ici, les vitesses initiales (c'est à dire celles avec lesquelles ont été générées les observations) ne sont pas modiées. Pour ce 1er cas : - On visualisera le résulat du modèle direct (avec gnuplot) pour vérier que le modèle programmé a le comportement attendu. - On lancera un test de la fonction objective. Cas 2 : Idem que le cas 1 sauf que cette fois, on perturbera les vitesses en se mettant à l'équilibre géostrophique par rapport à la même perturbation de la hauteur. Cas 3 : Idem que le cas 2, sauf que cette fois, on contrôlera aussi les vitesses u, v. Cas 4 : Idem que le cas 3, en rajoutant un terme d'ébauche et un opérateur de covariance sur le changement de variable des vitesses w = U 1 (x). 4.8 Implémentation dans YAO 2 Nous donnons ici les informations nécessaires pour la réalisation du TP. Pour avoir davantage d'information sur les possibilités de YAO, il conviendra de se reporter à la documentation utilisateur. Dans ce qui suit, nous reprenons les diérents éléments tels qu'ils ont été présentés aux paragraphes 4.3 à 4.6 (chier de description, source chapeau, sources des modules et chier d'instructions). Nous nous limitons tout d'abord au cas 1 de nos expériences d'assimilation. Nous verrons ultérieurement ce qu'il conviendra de modier ou de compléter pour passer aux cas suivants Fichier de description On rappelle qu'il s'agit d'un chier texte dans lequel on doit donner les spécications du modèle à l'aide de directives (en gras), mots clés (en italique) et 1 Une expérience jumelle consiste à utiliser comme valeurs d'observations celles calculées par le modèle lui même avec un état initial donné qu'on veut contrôler. Pour qu'un coût soit eectif, il faut perturber cet état initial. Le but de l'assimilation est alors de retrouver l'état initial non perturbé (appelé état vrai) à partir de l'état initial perturbé (appelé rst guess). Cette situation est idéale puisqu'elle est sans biais (pas d'erreur modèle, ni d'erreur sur les observations). 2 Pour eectuer ce TP, nous supposons que l'utilisateur possède un niveau susant de programmation en langage c. 36

37 paramètres (ces formats de caratère servent simplement ici à la clareté de la présentation, s'agissant d'un chier texte, ils n'ont pas lieu d'être). Les diérents termes peuvent être saisis soit en minuscule soit en majuscule. L'ordre d'apparition des directives doit être respecté. Un commentaire est repérable par une ligne dont le 1er caractère est '#', ou encore par le caractère ' ' en n de directive. 37

38 Voici le chier de description à créer, il s'appellera : shalw.d La directive defval permet de dénir des valeurs réutilisables par la suite. Les valeurs indiquées ici serviront pour la dénition de la taille de notre modèle, ici, SZX et SZY seront utilisés pour la dénition de l'espace, SZU, SZT et SZA pour celle de la trajectoire (voir ci-après directive traj et space). SZX et SZY servent à donner les dimensions de l'espace et la taille de chaque axe. ici il y a 2 dimensions (2D). Le premier axe sera de taille SZX, le second, de taille SZY. SZU correspond à une borne inférieur de nombre de pas de temps qui sert à eectuer le calcul courant (ce qui correspond à la phase d'initialisation). SZT correspond lui au nombre d'itérations demandé pour de la trajectoire. SZA doit correspondre au nombre de pas de temps total de l'application : SZA=SZU+SZT. La directive hat_name permet d'indiquer le nom de chier chapeau( shalw) créé par la suite pour l'application. Il doit y en avoir au moins un dans lequel doivent se trouver certaines fonctions obligatoires, et dans lequel, l'utilisateur peut également dénir des variables et fonctions globales. Ce chier source joue le rôle de programme principal de l'application. 38

39 La directive option conditionne certaines parties de génération de code. Ici par exemple, o_gradtest permet de générer le code nécessaire pour pouvoir utiliser les fonctions de validation (test de la fonction objective, de l'adjoint, du tangent linéaire et des dérivées). Quant à o_m1qn3, il permet de pouvoir utiliser l'interfaçe avec le minimiseur m1qn3 (INRIA) prévu par YAO. Il existe d'autres options notamment pour l'utilisation de réseaux de neuronnes, de l'algorithme incrémental, le choix du type de réel (oat ou double), ou des traces de débogage. La directive traj sert à déclarer la trajectoire à laquelle on donne un nom (Toce). Le premier paramètre, M, pourrait servir à typer la trajectoire (pour le moment, ce paramètre n'est pas utilisé mais il faut laisser la valeur 'M'). La trajectoire va s'appliquer avec une phase d'initialisation de SZU et pour un nombre d'itérations SZT. La directive space sert à déclarer un espace auquel on donne un nom (Soce). De même que pour la trajectoire, il faut garder le typage 'M'. L'espace va s'appliquer selon les 2 axes SZX et SZY et la trajectoire Toce. YAO référence les axes créés par 'YA1 ' pour le 1er et 'YA2' pour le second. Ces références seront utilisées par la suite pour choisir l'ordre de parcours de l'espace (cf directive order). La directive modul permet de déclarer un module et d'en indiquer les attributs à l'aide de mots clés. Cette directive doit être suivie du nom du module (exemple 'Hl'), immédiatement après on doit trouver le mot clé 'space' suivi du nom de l'espace auquel sera rattaché le module (exemple 'Soce'). L'ordre des informations suivantes n'a ensuite plus d'importance : -> input et output permettent d'indiquer les nombres d'entrée et de sortie du module. -> tempo indiquera à YAO qu'il doit mémoriser les états calculés sur tous les pas de temps ce qui est nécessaire pour le calcul des dérivées et au référencement des pas de temps passés. -> target est utilisé lorsqu'il s'agit d'un module dont on veut contrôler les sorties. -> le mot clé cout signie que le module pourra être porteur d'observations et participera alors au calcul de la fonction de coût. ctin est la directive qui sert à créer les connexions du graphe. Elle permet donc d'alimenter les entrées d'un module pour un point ijt courant avec les sorties des modules précédemment calculés sur un point de coordonnée quelconque. Par exemple, la dernière déclaration signie que au point ijt de calcul courant, la 7ième entrée du module Vphy proviendra de la 1ère sortie du module Uphy au point de coordonnée i,j,t-1. En fait, une syntaxe plus consise à été élaborée qui aurait ramené à 15 le nombre de décalrations au lieu des 28 dans cet exemple. Pour ne pas complexier ce TP, nous en resterons à ces connexions de base point à point. La directive order suivi du mot clé modinspace (comprendre module in space) et d'un nom d'espace (Soce) indique à la fois l'ordre de parcours (des axes) de cet espace et l'ordre d'exécution des modules. Les axes référencés par YAi (YA1 pour le 1er axe et YA2 pour le second) sont xés et parcourus dans l'ordre où ils sont mentionnées. En chaque maille parcourue, les fonctions des modules seront appelées dans l'ordre indiqué. Pour une trajectoire, c'est le mot clé spaceintraj qui doit être utilisé pour indiquer l'ordre des calculs des espaces de la trajectoire. Ici nous n'avons qu'un seul espace (Soce) et une seule trajectoire (Toce). Chaque directive order doit être contre-balancée par le mot clé forder qui en indique la n. Avec YAO, l'utilisateur à la possibilité de créer ses propres instructions (qui seront reconnues par l'interpréteur de YAO). Ces instructions sont à programmer dans un chier chapeau (voir ci après), mais doivent être déclarées au préalable dans le chier de description. C'est ce à quoi sert la directive insert_fct. arg permet de signier que la fonction attend un passage de paramètres sous la forme d'un tableau de pointeurs sur des chaînes de caractères (à la manière d'un passage d'arguments lors du lancement d'un programme c (int argc, char *argv[]). La directive se termine par le nom de la fonction-intruction. La fonction xdisplay nous servira à acher la valeur central de la hauteur d'eau à chaque itération d'assimilation, ce qui nous permettra d'avoir une idée dont cette dernière se comporte. La fonction xivg sera utilisée pour initialiser nos variables globales (paramètre de Coriolis, gravité réduite,...). xgauss nous permettra d'initialiser la hauteur d'eau selon une clôche gaussienne. Elle prend en paramètre la hauteur au point de centrage, les moyennes et écarts types sur les axes x et y qui dénissent ce point. Enn, xvitgeo à pour but d'initialiser les vitesses u et v à 39

40 l'équilibre géostrophique Programmation du hat et des modules Signalons tout d'abord que YAO génère quelques macros dont le but est de faciliter la programmation. Il s'agit d'une part de variables globales déclarées par YAO qui peuvent et doivent être utilisées pour les besoins du code; en voici quelques unes : - Yt ou YTemps : pas de temps de calcul courant - Yi, Yj, (et Yk si on avait eu 3 dimensions) sont les coordonnées (indicées à partir de 0) de la maille courante sur respectivement les axes des x, des y, (et des z) de l'espace courant. YA1, YA2, (et YA3) sont les tailles de ces mêmes axes déterminées par la directive space. Par ailleurs, les valeurs des sorties de n'importe quel module mod sont accessibles avec la syntaxe suivante : YS_mod(s,i,j,k,t) où s est l'indice de sortie, i,j,k sont les coordonnées spatiales et t la coordonnée temporelle. Ces indices commencent à zéro, et ils ne doivent être présents qu'en accord avec la dimension du module concerné. Par exemple, pour un module 2D sans dimension temporelle, il faudra utiliser : YS_mod(s,i,j). Une syntaxe équivalente existe pour les gradients, il sut d'utiliser YG_ au lieu de YS_. Programmation du source chapeau (hat) : shalw.h Nous rappelons que ce chier source peut être vu comme le programme principal de l'application. Nous y trouverons donc les éléments suivants : - les variables globales comme les tailles des discrétisations, le paramètre de Coriolis, la valeur de gravité réduite, etc. - les prototypages de fonctions lorsque cela s'avèrera nécessaire - les fonctions obligatoires qui permettent éventuellement à l'utilisateur de prendre la main pendant les diérentes étapes de calcul. - les fonctions spéciques à dévelloper pour les besoins de l'application Les panneaux ci-après donnent le code à produire, ils sont suivis des commentaires nécessaires. 40

41 Source chapeau shalw.h : 41

42 source chapeau shalw.h (suite) : Au début du code, nous trouvons tout d'abord les diérentes variables globales qui seront utiles par la suite. Les lignes de commentaires qui y sont associées devraient être sussantes pour les identier. 42

43 Puis viennent les fonctions obligatoires. Pour notre TP, nous utiliserons les suivantes : after_it : cette fonction est appellée après une itération de base. Une itération de base consiste en : une passe avant (forward), une passe arrière avec rétropropagation du gradient (backward), et une minimisation (c'est ce que nous avions aussi appelé un cycle de d'assimilation). Nous faisons appelle, dans cette fonction, à une fonction spécique d'achage (xdisplay) qui nous permettra de nous faire une idée de l'évolution de la minimisation à chaque cycle de minimisation. forward_before et forward_after : A chaque pas de temps de la passe avant, YAO fait d'abord un appelle à la fonction forward_before avant de lancer le calcul du (ou des) modèle de la trajectoire, après seulement il appelle la fonction forward_afer. Nous allons nous servir de ces deux fonctions pour gérer la phase initiale du shallow water. Au 1er pas de temps, nous annulons notre variable dedt, mais comme nous devons pouvoir l'utiliser pour les pas suivants, nous la sauvegardons préalablement (rôle de la variable svdedt). Si l'on regarde les modules *phy.h, on pourra remarquer que l'annulation de dedt revient à appliquer l'identité sur la variable des modules de ltre. Au deuxième pas de calcul, nous devons appliquer Euler, il nous sut pour cela de diviser par 2 la variable de discrétisation du temps, c'est ce qui est fait. Dans forward_after, il est important d'eectuer le codage inverse pour rétablir la bonne valeur de discrétisation temporelle à appliquer pour les pas suivants. backward_before et backward_after : Ces 2 fonctions sont le pendant des deux précedentes mais appliquées à la passe arrière. Il faut donc y refaire le même type de manipulation pour garder la cohérence des calculs. select_io : Cette fonction permet d'interagir avec les fonctions d'entrées-sorties de YAO pour par exemple en dénir des selections. Elle reçoît en entrée des paramètres qui nous renseignent sur le contexte de l'entrée/sortie et que l'on peut tester. Pour les besoins de la visualisation, nous souhaitons intervenir ici lors de nos sauvegardes avec l'instruction savestate (voir ci-après), d'où le test indic==yio_savestate qui correspond à ce cas. Par ailleurs, il faut savoir que la variable Yiofp correspond au pointeur de chier d'entrée/sortie courant. Nous nous servons de cette fonction pour intervenir sur le formatage du chier dans lequel nous allons sauvegarder les données de visualisation et qui doit être dans un format compatible avec gnuplot qui est l'utilitaire graphique que nous utiliserons. En particulier, il faut une ligne blanche entre chaque block (=ensemble lignes/colonnes) de données à acher, par contre il n'est besoin que d'un retour chariot pour séparer les lignes d'un même block. Ces considérations expliquent les tests sur iaxe et jaxe qui correspondent aux coordonnées spatiales, et à partir desquels il est décidé de faire 1 ou 2 retours à la ligne selon le cas. Les autres fonctions obligatoires, dont nous n'avons pas besoin ici, que nous laisserons donc vides sont : appli_start, before_it, cost_function et adjust_target. Intéressons nous maintenant aux fonctions spéciques de l'application. Pour notre exemple, nous souhaitons que ces fonctions puissent être lancées dans le ots des instructions (ce qui, nous le rappelons, présente l'avantage de ne pas avoir à relancer la génération-compilation de l'application lorsque l'on souhaite simplement modier les paramètres qui leurs sont éventuellement passés). Ces fonctions ont donc été préalablement déclarées dans le chier de description comme vous avez pu le constater. Dans notre exemple, nous avons eu besoin et choisi de créer les 4 fonctions suivantes : xdisplay : Cette fonction nous sert à acher la valeur central de la hauteur d'eau à chaque itération d'assimilation pour en suivre l'évolution. SZX et SZY sont un exemple d'utilisation de valeurs dénies par le chier de description avec la directive defval. Elles nous permettent de nous positionner sur le point central. La fonction ache la valeur en ce point du module Hl en cours de contrôle, et celle du gradient correspondant. La fonction xivg est utilisée pour initialiser nos diérentes variables globales (dx, dy, dt, paramètre de Coriolis, gravité réduite,...). Par exemple, pour initialiser le pas de discrétisation 43

44 temporelle dt à partir du chier d'instruction, on aura à saisir dans ce dernier : xvig dt 5000 dans ce cas, argv[0] contiendra xvig, argv[1] contiendra dt et argv[2] contiendra la chaîne 5000 qui conviendra de traduire en valeur numérique. Pour les autres variables, il en ira de même, le 2ème argument nous servant donc à identier la variable concernée. xgauss : programmation de la hauteur d'eau initiale en forme de clôche gaussienne. Il s'agit de calculer, pour chaque point de coordonnée ij0 : ĥ ij0 = b.e 1 2( x x σx ) 2.e 1 2 ( ) 2 y y σy où : b est la hauteur maximale (en mètre) x, x et σ x, (resp y, y et σ y ) sont les coordonnées, la moyenne et l'écart type sur l'axe des x (resp y). Les paramètres à passer, dans cet ordre, à la fonction xgauss sont : b, x, σ x, y, σ y, Ils seront respectivement aectés aux variables globales gb, gmx, gsx, gmy et gsy. De plus, pour calculer les point de coordonnées x et y, il sut de multiplier les indices des mailles en i et j par les variables de discrétisation des axes (c'est ce à quoi correspondont les multiplications i*dx et j*dy). En chaque point i,j l'expression ci-dessus peut alors être appliquée. Enn, xvitgeo à pour but d'initialiser les vitesses û et ˆv à l'équilibre géostrophique, situation dans laquelle la force de Coriolis s'équilibre avec le gradient de pression. Cette relation s'exprime ainsi (nous avons gardé les mêmes notations que pour la fonction xgauss) : Exprimons ĥ x { f.û = g. ĥ y f.ˆv = +g. ĥ x ĥ puis y, on obtient : ĥ x = 1 b.e 2( x x σx ) 2.e 1 2 ( ) 2 y y σy. x x σx 2 soit { û = g ˆv = f g f. ĥ y. ĥ x, puis ĥ y = b.e 1 2( x x σx ) 2.e 1 2 ( ) 2 y y σy. y y σy 2 En remarquant que les parties gauches de ces expressions correspondent aux calculs faits dans la fonction xgauss, on obtient, pour chaque point ij0 : û ij0 = g y y f.ĥij0 σy 2 et ˆv ij = g x x f.ĥij0 σx 2 Nous en avons ni avec le module chapeau, nous pouvons maintenant passer à la programmation des modules. 44

45 Programmation des modules Pour chaque module de calcul on doit trouver un source header de même nom (exemple Hphy.h pour le module Hphy). Les modules que nous présentons maintenant, découle directement de la discrétisation et du graphe modulaire préalablement établis. Nous avons donc, pour chacune de nos quantités de hauteur et de vitesse, des modules qui correspondront à la physique proprement dit, et d'autres qui réalisent le ltre d'asselin. Les modules receveront en paramètre d'entrées les valeurs de sortie des modules prédécésseurs dans l'ordre qui a été déni par la directive ctin. YAO permet de choisir de type de réel oat ou double pris par défaut. Le type YREAL créé par YAO correspond au type de réel choisit, c'est donc lui qui DOIT être utilisé en paramètre. Nous allons de plus utiliser les macros suivantes dénit par YAO dont la portée est limitée au module : - YSs représente la sième sortie du module. - YJsIe correspond à la dérivée de la sième sortie par rapport à la eième entrée du module. Un module de calcul doit contenir 2 fonctions : - la fonction forward est celle qui est sollicitée pour calculer le modèle direct. - la fonction backward devra coder la matrice jacobienne utilisée pour l'adjoint et/ou le linéaire tangent. Nous allons maintenant passer en revu les diérents modules. A chaque fois, nous avons rappelé l'équation issue de la discrétisation à laquelle correspond le code de la fonction forward. Nous laissons l'utilisateur apprécier et vérier la programmation des dérivées dans la fonction backward. Il ne sera pas non plus inutile de se rappeler la programmation des fonctions faites dans le source chapeau (shalw.h). Modules codant la physique : - module source Hphy.h : ( uijt 1 h ijt = ĥijt 2 u 2 t.h i 1jt 1 x ) + v ij+1t 1 v ijt 1 y 45

46 - modules source Uphy.h : u ijt = û ijt t ( g x [h i+1jt 1 h ijt 1 ] + f 4 [v ijt 1 + v ij+1t 1 + v i+1jt 1 + v i+1j+1t 1 ] γ.û ijt 2 ) Le test (Yi==YA1-1) permet de gérer la condition au limite de la vitesse u sur l'axe des x. YA1-1 correspond aux mailles qui se trouvent au bord à droite de notre espace et pour lesquelles le courant est annulé (voir gure 14). 46

47 - modules source Vphy.h : v ijt = ˆv ijt t ( g y [h ijt 1 h ij 1t 1 ] f 4 [u i 1j 1t 1 + u i 1jt 1 + u ij 1t 1 + u ijt 1 ] γ.ˆv ijt 2 ) Le test (Yj==0) permet de mettre un courant nul pour la vitesse v dont le ux provient des mailles en bordure du mur en bas à droite de notre espace (voir gure 14). 47

48 Modules codant le ltre d'asselin : - modules source Hl.h, Ul.h et Vl.h ĥ ijt = h ijt + α(ĥijt 1 2h ijt + h ijt+1 ) û ijt = u ijt + α(û ijt 1 2u ijt + u ijt+1 ) ˆv ijt = v ijt + α(ˆv ijt 1 2v ijt + v ijt+1 ) La programmation étant la même pour ces 3 modules, nous ne la faisons gurer qu'une seule fois. En fait, il existe un mot clé (clonol ou clonof associé au module) qui éviterait d'avoir à coder plusieurs modules lorsque que leurs fonctions sont identiques. Le test (Yt<=2) permet de traiter de façon particulière les 2 premiers pas de calcul qui servent de phase d'initialisation de la trajectoire. Pour cette phase, les variables nécéssaires au calcul du ltre d'asselin n'étant pas encore déterminées, on se contente de propager les valeurs précédentes en appliquant simplement l'idéntité (voir gure 16). Génération, compilation de l'application Tous les éléments nécessaires à l'application sont désormais prêt. Nous pouvons donc la créer ce qui se fait en lançant la procédure YAO. La syntaxe en est la suivante : YaoH prjname où prjname est le nom du chier de description. Le suxe.d ne doit pas être indiqué car il sera automatiquement rajouté par la procédure. Dans notre cas nous devons donc taper : YaoH shalw S'il n'y a pas d'erreur, le procédure crée un exécutable shalw immédiatement utilisable à conditions bien sur, d'avoir des instructions pour l'alimenter; c'est l'objet du prochain chapitre Fichier d'instructions Il s'agit d'un chier texte qui, comme son nom l'indique, doit contenir une suite d'instructions. Celles-ci seront lues et exécutées en séquence par l'application que 48

49 nous avons créée. Si une erreur est détectée lors de l'exécution d'une instruction alors la séquence est interrompue et l'application s'arrête. On considère en eet que dès qu'une erreur se produit, elle rend hypothètiques les instructions suivantes. La syntaxe d'une instruction est simple, elle comprend simplement le nom de l'instruction suivi ou pas d'un ou plusieurs paramètres. Le chier dans lequel nous saisirons nos instructions s'appelera shalw.i. Nous le présentons maintenant dans les encadrés qui suivent en procédant pas à pas en plusieurs étapes : Etape 1 : Initialisation du modèle : Il s'agit : - de choisir les paramètres du modèle (dt, dx,...) à l'aide de notre fonction xivg - de calculer le champ initial de la hauteur d'eau (ĥ) en forme de clôche avec notre fonction xgauss - et de calculer les vitesses initiales à l'équilibre géostrophique : fonction xvitgeo Etape 2 : Validation du modèle : Nous voulons nous assurer ici, que notre programmation est correcte. Nous nous proposons d'une part de vérier que le modèle direct a le comportement attendu, et d'autre part de faire un test de la fonction objective qui nous donne une abilité sur le code adjoint. 49

50 - Visualisation du modèle direct : Nous allons devoir lancer un calcul en passe avant de toute la trajectoire. Il nous sut pour cela de lancer l'instruction forward. Mais auparavant, nous devons nous assurer que le calcul commencera au début de la trajectoire, c'est le rôle de l'instruction set_modeltime 0. Après ce calcul, il nous est possible de sauvegarder sur disque le résultat des calculs pour n'importe quelle variable du modèle. Nous utilisons pour cela l'instruction savestate avec les arguments suivants : - Hl : nom du module - 1 : n de sortie du module - ij : indique l'ordre de parcours de l'espace pour la sauvegarde. Ici, on xe i (donc le 1er axe), et on parcourt j (i.e. le second axe). - 5% : se rapporte aux pas de temps à sauvegarder. 5% permet de dire qu'on ne veut qu'1 pas de temps sur 5 (cela permet de limiter la taille de la sauvegarde). - A : en format ASCII - 0 : permet de ne sauvegarder que les valeurs seules (nb: avec 1, 2 ou 3, on pourrait avoir des informations sur les coordonnées) - HlT : nom que nous donnons à notre chier de sauvegarde. Pour visualiser les données sauvegardées, nous allons utiliser gnuplot, en créant deux chiers (hsplot.gp et hanim.gp) dont nous donnons le code ci-après au paragraphe Avec gnuplot, les données doivent se présenter par block (=ensemble de lignes/colonnes) chaque block étant séparé par une ligne blanche. La chaîne de caractères de séparation des entrées/sorties par défaut de YAO, qui est le retour chariot (RC ou '\n'), ne convenant pas, la gestion du formatage du chier est assurée par le fonction select_io (voir plus haut). Dès lors, nous devons neutraliser la chaîne de caractères de séparation par défaut, c'est le rôle de l'instruction set_iosep, qui lorsqu'aucun paramètre ne lui est passé à pour eet de la remplacer par une chaîne vide. set_iosep doit donc être placé avant l'instruction de sauvegarde. Lorsque l'application sera lancée et qu'elle aura créé le chier de sauvegarde HlT, la visualisation de la simulation du modèle direct pourra à son tour être eectuée en tapant gnuplot hsplot.gp sur une console, ou directement en ligne dans le chier d'instructions à condition de faire précéder cette ligne de commande par le caractère '! ' (nb: lorsque l'intérpréteur d'instructions de YAO rencontre en 1er caratère le point d'exclamation, la suite de l'instruction est traitée par un appel système auquel elle est passée). Une illustration du résultat est montré à l'annexe Test de la fonction objective : Ce test consiste à vérier le développement de Taylor : à l'ordre 1 : et à l'ordre 2 : J(x 0 +α.dx) J(x 0 ) < J(x 0 ), α.dx> 1, α 0 ( ) 1 J(x0 +α.dx) J(x 0 ) α 2 < J(x 0 ), α.dx> 1 K, α 0 où α est un coecient, K est une constante proportionnelle au hessien. L'instruction testof correspond à ce test. Les paramètres passés sont le pourcentage de perturbation (pdx) de x 0 pour calculer dx, la valeur initiale du coecient α, le facteur de décroissance (fdec) de α pour le faire tendre vers 0 et le nombre de boucles (nbloop) pour la décroissance de α. A chaque itération de calcul, on fait donc décroître α (: α = α fdec ). Ici, on à pris les valeurs suivantes : pdx = 0.02, α = 10, fdec = 10, nbloop = 10. Pour rendre ce test opérant, il faut qu'un coût puisse être calculé; il nous faut donc des observations. L'instruction outobs nous permet d'en créer à partir de l'état courant du modèle. En paramètre, on doit indiquer : le nom du module (Hl) qui doit être déclaré 'cout' dans le chier de description, le n de la sortie (1) et une liste de pas de temps (SZA) sur lesquels on veut mettre des observations. On se rappelera que SZA a été déni dans le chier de description, et qu'il correspond au dernier pas de temps du modèle. Nous avons maintenant nos observations, mais cela n'est pas susant, encore faut t'il créer un coût, c'est à dire un écart par rapport à ces observations. Pour cela, il nous sut de perturber l'état initial avec lequel les observations ont été créées, c'est la raison de la ré-utilisation de la fonction xgauss, mais avec un paramètre 50

51 de hauteur diérent cette fois. l'instruction cost lms sert à valoriser le coecient de la fonction de coût (qui vaut 1 par défaut). Notre fonction de test de la fonction objective testof peut dès lors être lancée. Pour lancer ces premières vérications, il sut de lancer l'application en tapant : shalw étant entendu que le chier shalw.i ait bien été préalablement enregistré. L'utilisateur pourra vérier que le compte rendu de l'instruction testof est le même que celui de l'annexe 7.3. Etape 3 : Assimilation (cas 1) : Si l'étape précédente nous a apporté toute satisfaction, nous pouvons valablement nous engager dans l'expérience de l'assimilation. Certaines des instructions de l'étape 2 peuvent être supprimées (savestate, testof), mais les autres doivent subsister. Pour cette étape, la nouveauté va consisté essentiellement à lancer une instruction de 'run' de l'assimilation. Comme auparavent, on se sera d'abord mis en situation. Pour apprécier l'évolution de la minimisation de la fonction de coût, on peut utiliser l'instruction print_cost ON pour en acher la valeur à chaque itération. Dans ce TP, nous utilisons le minimiseur M1QN3 de l'inria. Pour ce dernier, plusieurs paramètres doivent être positionnés qui correspondent à des niveaux d'impression, des modes d'exécution, des critères d'arrêts ou des nombres d'itérations. Il serait trop lourd de détailler ici toutes les instructions qui s'y rapportent, nous renvoyons le lecteur à la documentation utilisateur. Nous avons cependant tenté dans notre exemple de mettre un minimum de commentaire qui laisse entrevoir de quoi il retourne. Ces paramètres positionnés, nous pouvons lancer l'assimilation avec l'instruction runm. A l'issu de cette exécution, il peut être intéressant de sauvegarder l'état analysé pour le comparer à l'état initial vrai, c'est la raison pour laquel nous faisons de nouveau appel à l'instruction savestate en prenant soin de changer le nom du chier de sauvegarde. L'application peut être relancée avec ce chier d'instructions modié. Il peut être utile de rediriger les sorties vers un chier si l'on veut par exemple tracer la fonction 51

52 de coût, nous proposons: shalw > execas1.txt. Dans l'annexe 7.4 nous montrons un extrait de ce chier, ainsi que la courbe d'évolution sur la fonction de coût (tracée avec gnuplot) Exemples supplémentaires Nous allons nous intéresser maintenant aux autres cas évoqués au paragraphe Cas 2 : Perturbation des vitesses en les mettant à l'équilibre géostrophique de la hauteur perturbée. Par rapport au cas 1, il sut simplement de rajouter la fonction xvitgeo après la perturbation du champ de la hauteur (à 5 mètres) avec xgauss, puisque, en eet, xvitgeo calcul les vitesses, à l'équilibre géostrophique, à partir de la hauteur. Si donc la hauteur est perturbé, les vitesses le seront aussi. Relancer l'application, et constater le comportement de l'assimilation dans cette situation. Cas 3 : Contrôler les vitesses Cette fois, c'est dans le chier de description qu'il faut intervenir. Il sut de rajouter pour chacun des modules de calcul des vitesses (Ul et Vl) le mot clé target. Attention cependant, s'agissant d'une modication du chier de description, il ne faut pas oublier de relancer la procédure YAO pour mettre à jour l'application qui tiendra compte de cette modication. Par rapport au cas 2 précédent, il n'y a pas lieu de modier le chier d'instructions. L'application peut de nouveau être lancée. Cas 4 : Terme d'ébauche et opérateur de covariance Achage avec gnuplot Pour visualiser l'animation du shallow-water avec gnuplot, vous devez créer les deux chiers hsplot.gp et hanim.gp comme présenté ci-après. Le 1er permet de paramétrer l'achage, l'autre de boucler sur la lecture des données pour en obtenir l'animation. L'utilisateur curieux de la signication et de l'utilisation des commandes gnuplot peux se rendre sur le site ociel de gnuplot ( Le code que nous donnons ici est en principe codé en conformité avec les paramètres indiqués pour notre TP. Par exemple, le nombre maximum de séquences à acher (variable imax) doit être cohérent avec la sauvegarde des données eectuées avec savestate, de même que si le nom de chier ('HlT') est modié, il faut aussi penser à le modier dans la commande splot ci-dessous. Ayant créé le chier, il sut, pour lancer la visualisation, de taper : gnuplot hsplot.gp contenu du chier hsplot.gp : 52

53 set zrange [-5:15] set pm3d set cbrange [-1:10] imax=21 idx=0 load "hanim.gp" reset #coordonnée axe z (qui correspond à la hauteur) #palette couleur 3d #échelle de couleur #nombre maximum de séquences à acher #index de début de séquence #script d'animation (splot des séquences de hauteurs) contenu du chier hanim.gp : splot 'HlT' matrix index idx with pm3d idx=idx+1 if (idx<=imax) reread pause -1 "Hit return to nish" #ache une séquence (selon l'index) du chier HlT #incrément de l'index pour passer à la séquence suivante #re-exécute les instructions de ce chier si on a pas atteind #le nombre maximun de séquences à acher Ÿ 53

54 5 Conclusion et Perspectives L'approche de graphe modulaire a été le point de départ de YAO, cependant plus le nombre des fonctionalités de YAO augmente et plus il se rapproche d'une plateforme de développement devenant ainsi un outil de conception de plus en plus intégrée. Au delà de l'exemple du Shallow water présenté dans ce document qui sert à faciliter la compréhension de la logique sous jacente à YAO et montre la manière de conduire une assimilation, plusieurs applications ont été réalisées en géophysique. Les modèles déjà implémentés qui ont tous abouti à la réalisation d'expériences jumelles sont ceux utilisés dans des laboratoires de recherche en géophysique: - Modèle biogéochimique 3D NNPZDDOM, assimilation du phytoplancton de surface pour contrôler des taux de croissance, de mortalité de broutage. - Modèle de transfert radiatif NEUROVARIA, inversion des reectances satellitaires pour contrôler des paramètres atmosphériques et océaniques (paramètres aérosol et chlorophyle) - Modèle d'interface sol-végétation -atmosphère ISBA, assimilation de la température de surface pour contôler les taux d'humidité à diérentes profondeurs - Modèles géoacoustiques SPE et WAPE, inversion des pressions acoustiques échantillonnées sur une verticale pour contrôler les caractéristiques physiques du fond marin (densité, célérité du son, atténuation, épaisseur de la couche de sédiment) et/ou le prol de vitesse. - Modèle biogéochimique 1D PISCES, assimilation des concentrations en Nanophytoplancton ou Diatomées pour contôler des paramètres de production de mortalité et de broutage correspondants. La rapidité de développement des diérents codes et la réalisation d'expériences jumelles par des étudiants dans le cadre de stage de Master 2 ou en thèse ont montré la facilité du maniement des modèles physiques apporté par le logiciel YAO dans sa version actuelle. Initialement YAO a été conçu pour permettre de coder des schémas aux diérences nies et s'est trouvé adapté à des problèmes qui peuvent s'exprimer de manière locale. Le bon fonctionnement des assimilations déjà réalisées ont montré que cette approche était eectivement adaptée pour les schémas numériques qui traduisent les phénomènes physiques sous jacents aux modèles qu'il a permis de traiter. D'autres problèmes sont maintenant en cours d'étude qui montrent la possibilté d'adapter et/ou d'utiliser YAO de façon à dépasser ce cadre. La mise au point d'un modèle acoustique aux modes normaux nécessite par exemple la recherche de valeurs et vecteurs propres. Les algorithmes qu'il faut alors coder ne respectent plus la logique de localité. Ce problème à été surmonté en utilisant le dérivateur automatique TAPENADE ([19, 18]) pour la partie du code correspondant à cette recherche. La notion de graphe modulaire s'est ainsi trouvée élargie à un niveau de granularité plus élevé: le graphe fait communiquer des modules dont les adjoints peuvent être obtenus de diérentes manières. La maniabilté apportée par YAO reste toujours opérante dans ce type de situation, elle apporte une aide importante pour réaliser les expériences d'assimilation. Citons par exemple le maintient de la cohérente au cours de l'évolution du modèle (cohérence du modèle avec son adjoint et son tangent linéaire), la minimisation de la fonction de coût ou la gestion des observations. Cette notion de décomposition pourra s'avérer importante au moment ou YAO sera doté d'une interface graphique permettant de 54

55 visualiser le graphe et les connexions de base, les modules pourront être visualisés automatiquement à diérents niveaux en regroupant les calculs. Les diérents graphes pourront faire ressortir l'enchaînement des phénomènes physiques entre eux ou, comme le feraient des zooms successifs, entrer dans la complexité des calculs. Les phénomènes que l'on veut prendre en compte impliquent maintenant de coupler plusieurs modèles (atmosphère et océan, activité biologique et processus dynamique,...), l'ambition de YAO est de permettre d'eectuer des assimilations pour ces modèles couplés. Chaque modèle est un graphe, YAO doit permettre d'eectuer la fusion des diérents graphes et donc de propager les diérents calculs inhérents à l'assimilation. Signalons enn que la notion de graphe sans circuit et sa décomposition par niveau doit permettre une parallélisation automatique d'un code et son exécution sur plusieurs processeurs. L'ensemble des évolutions envisagées pour YAO (interface graphique, couplage, parallélisme,...) le rapproche de plus en plus d'un AGL (Atelier de Génie Logiciel) dédié à des modélisations de diérentes nature. 6 Remerciements Nous remercions le CNES, le SHOM et NAOC (contrat européen) pour leur participation nancière mais aussi tous ceux qui ont aidé au développement de YAO (Mustapha Lebbah, Julien Brajard, Carlos Mejia, Michèl Crépon, Mohamed Berrada, Cyril Moulin, Catherine Ottlé). Ÿ 55

56 References [1] Berrada M. and al. Variational data assimilation in oceanographic modeling and geoacoustic inversion: A semi-automatic adjoint approche. Journal of Marine Systems 2005 (in revision). [2] Berrada M and al. Adjoint PE inversion method for the physical characterization of a shallow water environnement. J. Acoust. Soc. Am (in revision). [3] Berrada M. and al. Semi-automatic adjoint PE modeling for geoacoustic inversion. ICTCA 2005 (in revision). [4] Bottou L. Une Approche Théorique de l'apprentissage Connexioniste; Application à la reconnaissance de la parole. Thèse de Doctorat de l'université Paris Sud, Centre d'orsay [5] Bouali L. Impact respectif des principaux groupes de phytoplancton sur le cycle du carbone océanique : Développement d'une méthode d'optimisation du modèle de biogéochimie marine de l'ipsl(pisces) par assimilation de données satellitaire à l'aide du logiciel YAO. Rapport de stage [6] Bouttier F. and Courtier P. Data assimilation, concepts and methods. Training course notes of ECMWF, European Center for Medium-range Weather Forecasts, Treading, UK., 53, [7] Brajard J., Jamet C., Moulin C., Thiria S.; Use of a neuro-variational inversion for retrieving oceanic and atmospheric constituents from satellite ocean colour sensor : application to absorbing aerosols ; Neural Networks (in press) [8] Brajard J., Jamet C., Moulin C., Thiria S.; Validation of a Neuro-Variational Inversion of Ocean Colour Images ; Neural Networks (in revision) [9] Brajard J., Jamet C., Moulin C., Thiria S.; Atmospheric correction and oceanic constituents retrieval with a neuro-variational method, International Journal of Remote Sensing (in revision) [10] Courtier P., Talagrand O. (1990), Variational assimilation of meteorological observations with the direct and adjoint shallow-water equation ; Tellus, 42A, [11] Courtier P., Thépaut J.N. and Hollingsworth A.; A strategy for operational implementation of 4D-VAR using an incremental approche. Q. J. R. Meteorol. Soc.120, [12] Derber J., Bouttier F.; A reformulation of the background error covariance in the ECMWF global data assimilation system, Tellus A, [13] Ghoul A. Approche Modulaire pour l'assimilation de Données - Application à un modèle océanique tridimentionnel de bio géochimie. Mémoire de DEA en Intelligence Articielle, Université Paris XIII [14] Giering R., Tangent linear and Adjoint Model Compiler, Users Manual. Center for global Change Sciences, Department of Earth, Atmospheric, and Planetary Science, MIT, Cambridge, MA, December Unpublished. Puddle.mit.edu/~ralf/tamc 56

57 [15] Giering R. and Kaminski T. : Recipes for Adjoint Code Construction Article in ACM Trans. Math. Software, [16] Gilbert J.Ch. and Lemaréchal C. (1989). Some numerical experiments with variable-storage quasi-newton algorithms. Mathematical Programming 45, [17] Gilbert J.Ch. Numerical methods for large-scale minimization. ECMWF Seminar on Numerical Methods in Atmospheric Model, ECMWF, Reading, Berkshire RG2 9AX, England, 9-13 September [18] Hascoët L., The data-dependence graph of adjoint programs, Research Report 4167, INIRIA, Sophia-Antipolis, France, [19] Hascoët L., Vázquez M., and Dervieux A.: Automatic Dierentiation for Optimum Design, Applied to Sonic Boom Reduction Conference proceeding, Computational Science and Its Applications ICCSA 2003, Proceedings of the International Conference on Computational Science and its Applications, Montreal, Canada, May 1821, Part II, Springer, 2003 [20] Ide K., Courtier P., Ghil M. et Lorenc A.C., 1997, Unied Notation for Data Assimilation: Operational, Sequential and Variational, J. Meteor. Soc. Japan, 75 (1B, Numéro Spécial 'Data Assimilation in Meteorology and Oceanography: Theory and Practice'), [21] Le Dimet F.-X. and Talagrand O. (1986). Variational algorithms for analysis and assimilation of meteorological observations : theoretical aspects. Tellus, 38A: [22] Longépé N. Assimilation variationnelle de données dans le modèle d'interface sol-végétation-atmosphère ISBA. Rapport de stage de 4ème année d'electronique et Système de Communication [23] Louvel S. Etude d'un Algorithme d'assimilation Variationnelle de Données à Contrainte Faible. Mise en Oeuvre sur le Modèle Océanique aux Equations Primitives MICOM. Thèse de Doctorat. Université de Toulouse III [24] Ouis S. Assimilation d'un Traceur Océanique, une méthodologie neuronale. Mémoire de DEA en Intelligence Articielle, Université Paris XIII [25] Sportisse B. et Quélo D. Assimilation de données. 1ère partie : Eléments théoriques. Report October Cerea. [26] Talagrand 0. (1991), The use of adjoint equations in numerical modeling atmospheric ciculation ; proceeding of the workshop on Automatic Dierentiation of Algorithms ; Theory, Implementation an Application, SIAM. [27] Talagrand O. et Courtier P. Les équations adjointes, application à la modélisation numérique. Communication à l'atelier de Modélisation de l'atmosphère, Direction de la Météorologie, Toulouse, Octobre [28] Talagrand O. Assimilation of Observations, an Introduction. Journal of the Meteorological Society of Japan, 75, ,

58 [29] Weaver A.T., Deltel C., Machu E., Ricci S. and Daget N.; 2005, A multivariate balance operator for variational ocean data assimilation, submitted to Q. J. R. Meteor. Soc. 58

59 7 Annexes 7.1 Démonstration de la formule de la procédure backward Etant donné un modèle M représenté par un graphe modulaire Γ, qui calcule pour un vecteur d'entrée x un vecteur de sortie y. On suppose dénie en fonction de y une fonction J (y) dérivable, il est alors possible de calculer les dérivées partielles J y i par rapport aux composantes du vecteur y. Si on considère un module F p du graphe modulaire Γ qui admet en entrée un vecteur x p de dimension n p et calcule en sortie un vecteur y p de dimension m p. Ce module correspond à une fonction vectorielle : y p = F p (x p ) = (F p,1 (x p ), F p,2 (x p ),..., F p,mp (x p )) Il s'agit de calculer J x p,i où x p,i représente la i ieme composante du vecteur x p. Nous remarquons d'abord, que le vecteur x p permet le calcul du vecteur y p qui à son tour permet le calcul des vecteurs de sortie y q des modules F q successeurs de F p dans le graphe Γ. Ainsi, étant donné y p,j, la j ieme composante de y p, on lui associe l'ensemble S p,j qui est formé par l'ensemble des couples (q,k) où F q représente un module successeur de F p admettant comme k ieme variable d'entrée la variable y p,j. Tenant compte de ces notations et des règles de dérivation de la composition de fonctions, on tire alors : D'autre part, J x p,i = m p j=1 J y p,j = J y p,j y p,j x p,i = (q,k) S p,j m p j=1 J y p,j F p,j x p,i (9) J x q,k x q,k y p,j (10) Or par dénition x q,k y p,j = 1 car x q,k = y p,j. De (9) et (10) on obtient alors la relation suivante : m J p = J x p,i j=1 x q,k (q,k) S p,j F p,j x p,i (11) La formule (11) montre que la connaissance des dérivées partielles par rapport aux entrées des modules F q, successeurs de F p, permet le calcul des dérivées partielles J x p,i (par rapport aux entrées du module F p ). Du point de vue du graphe modulaire, S p,j représente l'ensemble des extrémités terminales des connexions de base prenant leur entrée de la j ieme sortie de F p. Si on note la formule (11) devient : β j = J x q,k (q,k) S p,j 59

60 J x p,i = m p j=1 β j F p,j x p,i (12) Ainsi, la connaissance des dérivées partielles par rapport aux variables de sorties : J y permet d'initialiser l'algorithme Backward. La formule (12) permet i d'eectuer le calcul par rétroporopagation. 7.2 Simulation du modèle direct Les images ci-dessus montre l'évolution du modèle shallow-water tel qu'il a été déni dans le TP. Si aucune erreur n'a été comise, l'exécution du script d'animation gnuplot doit reproduire cette évolution. La 1ère image correspond à notre clôche initiale gaussienne dont le point culminant est à 15 mètres. L'évolution de cette courbe consiste en un aaissement et à la formation de petites vagues circulaires qui s'éloignent du point central. 7.3 Test de la fonction objective Lorqu'on lance le test de la fonction objective en respectant les indications données dans le TP, l'achage suivant doit apparaître à l'écran (ou dans un chier de redirection) : 60

61 Yao#>testof testof : NEW : use of new function set_dxalea () Objective Function TEST : with:ÿpdx = e-02, (a)lpha = e ŸŸŸŸŸŸŸfdec= e+01, (n)bloop= 8 nb 1) dx = Xo * pdx ŸŸ 2) a(n) = a(n-1)/fdec ŸŸŸŸŸŸŸŸŸŸŸ g = (J(Xo+a.dx) - J(Xo)) / (@J/@Xo).a.dx ŸŸŸŸŸŸŸ a decrease ŸŸŸ ordre 1: (g)-->1 Ÿ ordre 2: [(g-1)/a]-->k ŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸ Cost function: J(Xo) = e+02 J(Xo+a.dx) (@J/@Xo).a.dx : 1: e+00 : -1-> e-01 -K-> e-03 Ÿ e e+00 : 2: e-01 : -1-> e-01 -K-> e-03 Ÿ e e-01 : 3: e-02 : -1-> e-01 -K-> e-03 Ÿ e e-02 : 4: e-03 : -1-> e-01 -K-> e-03 Ÿ e e-03 : 5: e-04 : -1-> e-01 -K-> e-03 Ÿ e e-04 : 6: e-05 : -1-> e-01 -K-> e-03 Ÿ e e-05 : 7: e-06 : -1-> e-01 -K-> e-01 Ÿ e e-06 : 8: e-07 : -1-> e-01 -K-> e+01 Ÿ e e-07 Quelques indications : la colonne a decrease correspond à la décroissance du coecient α. La colonne suivante (9.95e 01, 9.995e 01,...) correspond à la tendance vers 1 du développement de Taylor à l'ordre 1 avec la décroissance de α et la 3ème colonne (5.0e 03,...) à celle de la tendance vers une constante K à l'ordre 2. Après quelques boucles de calcul, le test commence à être dégradé, cela est dû à la limite de la précision machine du calculateur. 7.4 Exécution d'une assimilation (cas 1) Voici ci-dessous, un extrait de l'achage obtenu pendant l'exécution d'un run d'assimilation. La ligne qui commence par '> > >' est un achage produit l'instruction print_cost ON de YAO. On y trouve le n de l'itération d'assimilation (Yiter 1), la trajectoire concernée (Toce) le pas de temps auquel le coût est cumulé (pdt=101), le temps en seconde écoulé depuis le début du run (0s) et nalement la valeur de la fonction de coût (Total cost = e+02). De son coté, notre fonction xdisplay à provoqué l'achage de la ligne qui commence par 'point' avec les indices i,j du point central, la valeur et le gradient de Hl en ce point. Yao#>RUNM start run time: Tue Apr 25 10:12: > > > Yiter 1 traj Toce pdt=101 after 0s: Total cost = e+02 point:25,25, Hfil= > > > Yiter 2 traj Toce pdt=101 after 1s: Total cost = e+01 point:25,25, Hfil= > > > Yiter 3 traj Toce pdt=101 after 2s: Total cost = e+01 point:25,25, Hfil= > > > Yiter 4 traj Toce pdt=101 after 3s: Total cost = e+01 point:25,25, Hfil= > > > Yiter 5 traj Toce pdt=101 after 4s: Total cost = e+00 point:25,25, Hfil= > > > Yiter 197 traj Toce pdt=101 after 198s: Total cost = e-05 point:25,25, Hfil= e-06 > > > Yiter 198 traj Toce pdt=101 after 198s: Total cost = e-05 point:25,25, Hfil= e-06 > > > Yiter 199 traj Toce pdt=101 after 199s: Total cost = e-05 point:25,25, Hfil= e-06 > > > Yiter 200 traj Toce pdt=101 after 200s: Total cost = e-05 Yao#>(5) Nombre de simulation atteint start run time...: Tue Apr 25 10:12: Ÿ end run time...: Tue Apr 25 10:15: Ÿ run duration...: 201s Yao#>savestate Hfil 1 ij 5% A 0./HfilA state(s) selected saving module Hfil 61

62 On peut constater la minimisation de la fonction de coût puisqu'elle est passé de 2.847e+2 à 2.598e-5. La gure 17 montre cette décroissance progressive de la focntion de coût pendant l'assimilation. Figure 17: Décroissance de la fonction de coût en log (en abscisse: nombre d'itérations; en ordonnée: valeur de la fonction). Cette courbe à été obtenue en créant un chier contenant les valeurs de la fonction de coût à chaque itération. Pour cela on a utilisé la ligne de commande linux suivante : grep cost execas1.txt awk '{print $12}' > costcas1 où execas1.txt est le chier dans lequel ont été redirigé les sorties de l'exécution de l'assimilation, et costcas1 sera le chier dans lequel les valeurs seront récupérées. La commande grep selectionne toutes les lignes qui contiennent le mot 'cost', puis la commande awk permet d'en extraire la 12ème colonne uniquement qui correspond à la valeur du coût. Ensuite, sous gnuplot, il faut saisir les 2 lignes suivantes : set logscale y plot "costcas1" with lines On peut également constater qu'au cours de la minimisation de la fonction de coût, on s'est eecvtivement rapproché de façon satisfaisante de la vraie valeur du point central (1.49e+01). Qu'en est-il des autres points? La gure 18 montre que c'est bien tout le champs qui a été reconstitué. 62

63 Figure 18: Champs de hauteur initiale aux diérentes phases du processus d'assimilation : (a) valeur vraie; (b) rst guess qui correspond à l'état initial avant la minimisation, (c) champ retrouvé (aussi appélé analyse), la diérence (d)=(a)-(c) est trés acceptable. Ÿ 63