mercredi 14 août 2013

Mise en oeuvre des modèles météo WRF-ARW et WRF-NMM - Partie 4 - Compilation de WRF-ARW et WPS

Dans la précédente partie de ce tutoriel, Partie 3 - Préparation de l'environnement, vous avez préparé votre environnement et compilé les librairies requises. Nous allons pouvoir entrer dans le vif du sujet afin de compiler WRF avec le coeur dynamique ARW, ainsi que le pré-processeur WPS.

Les différentes options de compilation


On attaque le vif du sujet. Si vous avez suivi les instructions jusqu'ici, cela devrait se passer sans trop de mal. Nous allons maintenant présenter rapidement les différentes variantes de WRF et les options de compilation qui s'adapteront à votre projet.

Tout d'abord, sachez que WRF peut être compilé sous de multiples formes pour différentes applications : cas réels (ce qui nous intéresse ici) et divers cas idéalisés pour des simulations particulières (on ne s'y intéressera pas ici). Mais surtout, WRF peut utiliser deux coeurs dynamiques différents (méthodes d'intégration des équations) ayant chacune leurs caractéristiques sur le plan physique :
  • ARW : modèle hydrostatique. Ne permet pas de simuler explicitement la convection. Permet toutes les options de compilation.
  • NMM : modèle non hydrostatique. Permet de simuler explicitement la convection. Il ne sera disponible que pour certaines options de compilation.
Chaque coeur sera compilé séparément, et produira un exécutable différent.
WRF peut exploiter les environnements multiprocesseurs de différentes manières. Cela est déterminé au moment de la compilation :
  • serial : n'utilise qu'un seul processeur. Cette option fonctionne avec tous les coeurs et posera le moins de problème à la compilation. A préférer dans un premier temps, pour vous faire la main.
  • smpar : mémoire partagée. Utilise un seul processus multi-thread. Cette option ne fonctionne qu'avec le coeur ARW. Elle semble de plus nettement moins performante que MPI, sans doute en raison d'un overhead pour la synchronisation des threads. Elle nécessitera quelques librairies en plus.
  • dmpar : mémoire distribuée. Utilise le système MPI pour distribuer les tâches sur plusieurs processus, ce qui permet une utilisation multiprocesseur sur une ou plusieurs machines en réseau (cluster). C'est l'option qui apportera le plus de souplesse et le plus de performances en permettant une répartition maximum de la charge. Elle fonctionne avec tous les coeurs. Là encore, des librairies additionnelles seront nécessaires.
  • smpar+dmpar : combinaison des deux ci-dessous. Chaque processus MPI sera multithread, ce qui évite sur une même machine de lancer plusieurs processus pour répartir la charge. En théorie, moindre utilisation mémoire, mais selon la doc, cette option est un peu moins performante que dmpar tout seul, plus complexe à mettre en oeuvre et donc déconseillée. Je n'ai pas testé cette option, je ne la traiterais donc pas.
D'autres options concernent le "nesting". Il s'agit de pouvoir simuler en une opération sur des domaines imbriqués les uns dans les autres. Cela permet de simuler par exemple en résolution moyenne sur toute l'Europe, puis sur la France en haute résolution, en utilisant les conditions le domaine Europe comme condition aux limites. On déterminera les capacités de "nesting" au moment de la compilation. On choisira pour ce tutoriel l'option "basique". D'autres options existent, qui permettent d'avoir un domaine qui se déplace dans le temps (par exemple pour suivre un cyclone), ces options ne seront pas couvertes par cette documentation.

Compilation de WRF 

 

Dans tout ce chapitre, nous aborderons la compilation avec le coeur ARW. Nous aborderons le coeur NMM dans un autre chapitre dédié. L'opération se déroule en deux étapes :
  • on compile d'abord le modèle WRF
  • on compile ensuite le préprocesseur WPS

Configuration des sources WRF

Rendez-vous dans le dossier WRFV3. Assurez-vous d'avoir bien créé les variables d'environnement de la section précédente.

Tapez la commande configure :

# ./configure

Le menu suivant vous est proposé. Les options peuvent varier suivant votre système, adaptez mon propos en conséquence. Soyez attentif à tout message affiché qui pourrait laisser penser que votre environnement est mal configuré.
------------------------------------------------------------------------
Please select from among the following supported platforms.

   1.  Linux x86_64 i486 i586 i686, PGI compiler with gcc  (serial)
   2.  Linux x86_64 i486 i586 i686, PGI compiler with gcc  (smpar)
   3.  Linux x86_64 i486 i586 i686, PGI compiler with gcc  (dmpar)
   4.  Linux x86_64 i486 i586 i686, PGI compiler with gcc  (dm+sm)
   5.  Linux x86_64 i486 i586 i686 PGI compiler with pgcc YELLOWSTONE  (serial)
   6.  Linux x86_64 i486 i586 i686 PGI compiler with pgcc YELLOWSTONE  (smpar)
   7.  Linux x86_64 i486 i586 i686 PGI compiler with pgcc YELLOWSTONE  (dmpar)
   8.  Linux x86_64 i486 i586 i686 PGI compiler with pgcc YELLOWSTONE  (dm+sm)
   9.  Linux x86_64, PGI compiler with pgcc, SGI MPT  (serial)
  10.  Linux x86_64, PGI compiler with pgcc, SGI MPT  (smpar)
  11.  Linux x86_64, PGI compiler with pgcc, SGI MPT  (dmpar)
  12.  Linux x86_64, PGI compiler with pgcc, SGI MPT  (dm+sm)
  13.  Linux x86_64, PGI accelerator compiler with gcc  (serial)
  14.  Linux x86_64, PGI accelerator compiler with gcc  (smpar)
  15.  Linux x86_64, PGI accelerator compiler with gcc  (dmpar)
  16.  Linux x86_64, PGI accelerator compiler with gcc  (dm+sm)
  17.  Linux x86_64 i486 i586 i686, ifort compiler with icc  (serial)
  18.  Linux x86_64 i486 i586 i686, ifort compiler with icc  (smpar)
  19.  Linux x86_64 i486 i586 i686, ifort compiler with icc  (dmpar)
  20.  Linux x86_64 i486 i586 i686, ifort compiler with icc  (dm+sm)
  21.  Linux x86_64 i486 i586 i686, Xeon Phi (MIC architecture) ifort compiler with icc  (dm+sm)
  22.  Linux x86_64 i486 i586 i686, Xeon (SNB with AVX mods) ifort compiler with icc  (serial)
  23.  Linux x86_64 i486 i586 i686, Xeon (SNB with AVX mods) ifort compiler with icc  (smpar)
  24.  Linux x86_64 i486 i586 i686, Xeon (SNB with AVX mods) ifort compiler with icc  (dmpar)
  25.  Linux x86_64 i486 i586 i686, Xeon (SNB with AVX mods) ifort compiler with icc  (dm+sm)
  26.  Linux x86_64 i486 i586 i686, ifort compiler with icc YELLOWSTONE  (serial)
  27.  Linux x86_64 i486 i586 i686, ifort compiler with icc YELLOWSTONE  (smpar)
  28.  Linux x86_64 i486 i586 i686, ifort compiler with icc YELLOWSTONE  (dmpar)
  29.  Linux x86_64 i486 i586 i686, ifort compiler with icc YELLOWSTONE  (dm+sm)
  30.  Linux x86_64 i486 i586 i686, ifort compiler with icc, SGI MPT  (serial)
  31.  Linux x86_64 i486 i586 i686, ifort compiler with icc, SGI MPT  (smpar)
  32.  Linux x86_64 i486 i586 i686, ifort compiler with icc, SGI MPT  (dmpar)
  33.  Linux x86_64 i486 i586 i686, ifort compiler with icc, SGI MPT  (dm+sm)
  34.  Linux x86_64 i486 i586 i686, ifort compiler with icc, IBM POE  (serial)
  35.  Linux x86_64 i486 i586 i686, ifort compiler with icc, IBM POE  (smpar)
  36.  Linux x86_64 i486 i586 i686, ifort compiler with icc, IBM POE  (dmpar)
  37.  Linux x86_64 i486 i586 i686, ifort compiler with icc, IBM POE  (dm+sm)
  38.  Linux i486 i586 i686 x86_64, PathScale compiler with pathcc  (serial)
  39.  Linux i486 i586 i686 x86_64, PathScale compiler with pathcc  (dmpar)
  40.  x86_64 Linux, gfortran compiler with gcc   (serial)
  41.  x86_64 Linux, gfortran compiler with gcc   (smpar)
  42.  x86_64 Linux, gfortran compiler with gcc   (dmpar)
  43.  x86_64 Linux, gfortran compiler with gcc   (dm+sm)
  44.  Cray XE and XC30 CLE/Linux x86_64, Cray CCE compiler  (serial)
  45.  Cray XE and XC30 CLE/Linux x86_64, Cray CCE compiler  (smpar)
  46.  Cray XE and XC30 CLE/Linux x86_64, Cray CCE compiler  (dmpar)
  47.  Cray XE and XC30 CLE/Linux x86_64, Cray CCE compiler  (dm+sm)
  48.  Cray XC30 CLE/Linux x86_64, Xeon ifort compiler  (serial)
  49.  Cray XC30 CLE/Linux x86_64, Xeon ifort compiler  (smpar)
  50.  Cray XC30 CLE/Linux x86_64, Xeon ifort compiler  (dmpar)
  51.  Cray XC30 CLE/Linux x86_64, Xeon ifort compiler  (dm+sm)
  52.  Linux x86_64, Fujitsu FX10 mpifrtpx and mpifccpx compilers  (serial)
  53.  Linux x86_64, Fujitsu FX10 mpifrtpx and mpifccpx compilers  (smpar)
  54.  Linux x86_64, Fujitsu FX10 mpifrtpx and mpifccpx compilers  (dmpar)
  55.  Linux x86_64, Fujitsu FX10 mpifrtpx and mpifccpx compilers  (dm+sm)

Enter selection [1-55] : 


WRF peut être compilé avec de nombreux compilateurs. Nous n'utiliserons ici que gfortran (options 40 à 42). Vous reconnaissez les différentes options de parallélisation dont nous avons déjà parlé:
  • 40 serial : commencez par là si c'est votre première fois. Vous n'exploiterez pas toute votre puissance de calcul mais vous arriverez plus facilement à compiler, c'est important de ne pas être dégoûté tout de suite ! Option possible pour ARW et NMM.
  • 41 smpar : Option possible pour ARW, vous pouvez éventuellement commencer par là. Prévoyez quelques librairies additionnelles. N'utilisez pas cette option pour NMM : vous allez au devant de nombreuses erreurs de compilation.
  • 42 dmpar : Seule alternative possible pour la parallélisation du coeur NMM. Vous aurez besoin de librairies et d'outils supplémentaires.
Une fois choisi votre option :

Compile for nesting? (1=basic, 2=preset moves, 3=vortex following) [default 1]:
 
Choisissez 1.
(si vous avez choisi serial ou smpar, vous aurez également l'option "0 : no nesting.". Si vous ne prévoyez pas de faire de nesting, vous pourrez la choisir).

Une fois le choix réalisé, la sortie devrait ressembler à :

Configuration successful. To build the model type compile .
------------------------------------------------------------------------
testing for MPI_Comm_f2c and MPI_Comm_c2f
MPI_Comm_f2c and MPI_Comm_c2f are not supported
testing for fseeko and fseeko64
fseeko64 is supported
------------------------------------------------------------------------

...

######################
------------------------------------------------------------------------
Settings listed above are written to configure.wrf.
If you wish to change settings, please edit that file.
If you wish to change the default options, edit the file:
arch/configure_new.defaults
NetCDF users note:
This installation of NetCDF supports large file support. To enable large file
support in NetCDF, set the environment variable WRFIO_NCD_LARGE_FILE_SUPPORT
to 1 and run configure again. Set to any other value to avoid this message.

Testing for NetCDF, C and Fortran compiler

This installation of NetCDF is 32-bit
C compiler is 32-bit
Fortran compiler is 32-bit
It will build in 32-bit

************************** W A R N I N G ************************************

There are some Fortran 20003 features in WRF that your compiler does not recognize
The IEEE signaling call has been removed. That may not be enough.

*****************************************************************************

Avant de poursuivre, voici les pré-requis supplémentaire pour chaque cas :
  • Si vous avez choisi SMPAR, installez la librairie libgomp (OpenMP).
  • Si vous avez choisi DMPAR, installez les paquets openmpi-dev et openmpi.

 

 Compilation de WRF-ARW

 

Tapez la commande :

# ./compile em_real &> compile.log

Après un peu de temps la commande se termine. Listez le contenu du dossier main. Vous devriez trouver les fichiers suivants :
  • real.exe
  • wrf.exe
Si ce n'est pas le cas, c'est qu'il y a eu une erreur. Voir section dédiée.

Compilation du WPS

 

Allez cette fois dans le dosier WPS. Assurez-vous d'avoir compilé avec succès WRF-ARW ou WRF-NMM avant de poursuivre. On tape alors la désormais classique commande :
# ./configure
Will use NETCDF in dir: /home/nicolas/Meteo
Found Jasper environment variables for GRIB2 support...
$JASPERLIB = /home/nicolas/Meteo/lib
$JASPERINC = /home/nicolas/Meteo/include
------------------------------------------------------------------------
Please select from among the following supported platforms.
   1.  Linux x86_64, gfortran    (serial)
   2.  Linux x86_64, gfortran    (serial_NO_GRIB2)
   3.  Linux x86_64, gfortran    (dmpar)
   4.  Linux x86_64, gfortran    (dmpar_NO_GRIB2)
   5.  Linux x86_64, PGI compiler   (serial)
   6.  Linux x86_64, PGI compiler   (serial_NO_GRIB2)
   7.  Linux x86_64, PGI compiler   (dmpar)
   8.  Linux x86_64, PGI compiler   (dmpar_NO_GRIB2)
   9.  Linux x86_64, PGI compiler, SGI MPT   (serial)
  10.  Linux x86_64, PGI compiler, SGI MPT   (serial_NO_GRIB2)
  11.  Linux x86_64, PGI compiler, SGI MPT   (dmpar)
  12.  Linux x86_64, PGI compiler, SGI MPT   (dmpar_NO_GRIB2)
  13.  Linux x86_64, IA64 and Opteron    (serial)
  14.  Linux x86_64, IA64 and Opteron    (serial_NO_GRIB2)
  15.  Linux x86_64, IA64 and Opteron    (dmpar)
  16.  Linux x86_64, IA64 and Opteron    (dmpar_NO_GRIB2)
  17.  Linux x86_64, Intel compiler    (serial)
  18.  Linux x86_64, Intel compiler    (serial_NO_GRIB2)
  19.  Linux x86_64, Intel compiler    (dmpar)
  20.  Linux x86_64, Intel compiler    (dmpar_NO_GRIB2)
  21.  Linux x86_64, Intel compiler, SGI MPT    (serial)
  22.  Linux x86_64, Intel compiler, SGI MPT    (serial_NO_GRIB2)
  23.  Linux x86_64, Intel compiler, SGI MPT    (dmpar)
  24.  Linux x86_64, Intel compiler, SGI MPT    (dmpar_NO_GRIB2)
  25.  Linux x86_64 g95 compiler     (serial)
  26.  Linux x86_64 g95 compiler     (serial_NO_GRIB2)
  27.  Linux x86_64 g95 compiler     (dmpar)
  28.  Linux x86_64 g95 compiler     (dmpar_NO_GRIB2)
  29.  Cray XE/XC CLE/Linux x86_64, Cray compiler   (serial)
  30.  Cray XE/XC CLE/Linux x86_64, Cray compiler   (serial_NO_GRIB2)
  31.  Cray XE/XC CLE/Linux x86_64, Cray compiler   (dmpar)
  32.  Cray XE/XC CLE/Linux x86_64, Cray compiler   (dmpar_NO_GRIB2)
  33.  Cray XC CLE/Linux x86_64, Intel compiler   (serial)
  34.  Cray XC CLE/Linux x86_64, Intel compiler   (serial_NO_GRIB2)
  35.  Cray XC CLE/Linux x86_64, Intel compiler   (dmpar)
  36.  Cray XC CLE/Linux x86_64, Intel compiler   (dmpar_NO_GRIB2)

Enter selection [1-36] : 


Choisissez l'option 1 (serial). Pour ce tutorial, on ne va pas se compliquer la vie à chercher à paralleliser, pour gagner 30 secondes sur le temps de préparation des données... Voilà le résultat à la fin :

------------------------------------------------------------------------
Configuration successful. To build the WPS, type: compile
------------------------------------------------------------------------

Testing for NetCDF, C and Fortran compiler

This installation NetCDF is 64-bit
C compiler is 64-bit
Fortran compiler is 64-bit

On enchaine sur un :
# ./compile &> compile.log

A la fin, vous devriez obtenir 3 executables dans le dossier :
  • geogrid.exe
  • ungrib.exe
  • metgrid.exe

Résolution des erreurs de compilation

 

Si à une étape de la compilation de WRF vous rencontrez une erreur, alors vous devrez vérifier le contenu du fichier compile.log à la recherche d'erreurs. Les erreurs les plus courantes sont des librairies non installées.
En cas d'erreur, faites un ./clean avant de recompiler. Parfois, un ./clean -a suivi d'un ./configure sera nécessaire.
Quelques erreurs type :
  • Messages du type "unresolved reference to function XXXX" : vérifiez bien que vous avez installé toutes les librairies requises pour votre configuration, et que vous avez bien défini les variables d'environnement. Quelques librairies à vérifier : OpenMP, MPI, Cairo2... Si votre environnement est mal défini, vous devrez parfois éditer le fichier configure.wps pour ajouter quelques options après le ./configure (en gras les ajouts éventuels) :

    NCARG_LIBS = -L$(NCARG_ROOT)/lib -L/usr/lib/i386-linux-gnu -lncarg -lncarg_gks -lncarg_c \
    -L/usr/X11R6/lib -lX11 -lcairo -L/usr/lib -lnetcdff -lnetcdf

    Variable WRF_LIBS : ajouter -lgomp (si vous avez choisi l'option smpar).
  • Vous avez choisi l'option dmpar et vous obtenez des erreurs du style : "expected identifier or ’(’ before ’int’s" suivie de "error: ’MPI_Comm’ redeclared as different kind of symbol" et d'erreurs du type "error: expected declaration specifiers or ’...’ before ’MPI_Comm’" .Editez le fichier configure.wrf et ajoutez -DMPI2_SUPPORT à la variable DM_CC.
  • J'ai eu tellement d'erreurs que je ne me rappelle pas de tout, et il est possible que votre cas n'est pas répertorié ici, ne m'en veuillez pas. Mais encore une fois, la plupart du temps c'est une histoire de librairie, voire de plateforme (32bits vs 64bits, voir section sur les pré-requis). Rien n'est insurmontable, un petit google sur le message d'erreur permet bien souvent de trouver l'option ou la librairie manquante. La FAQ de WRF est également bien utile :
    http://www.mmm.ucar.edu/wrf/users/FAQ.html

Vous êtes maintenant fin prêts à suivre le prochain article, Partie 5 - Notre premier run WRF dans lequel vous apprendrez les différentes étapes du run WRF et produirez ainsi votre première prévision numérique.