Voir la source de GOTM - General Ocean Turbulence Model

= Introduction =
GOTM (General Ocean Turbulence Model) est un modèle libre qui simule les processus physique d'une colonne d'eau lacustre ou océanique en solutionnant les équations du transport moyen et turbulent sur la verticale. Il a été développé à l'origine par Hans Burchard, Karsten Bolding, Manuel Ruiz-Villareal et Pierre-Philippe Mathieu et hébergé à l'Institute of Oceanography in Hambourg d'où l'on peut obtenir le code source ([http://www.gotm.net/ www.gotm.net]). Depuis 2008, Dany Dumont et plusieurs étudiants et collaborateurs ont utilisé ce code riche et versatile dans plusieurs projets. Pour faciliter la collaboration interne et pour tirer parti des modifications apportées, une branche du code gotm-4.0.0 a été déposée dans un dépôt [[svn]] sur les serveurs du POLR (ISMER) sous le nom de gotm_ismer. Ce dépôt a été créé afin de partager et de documenter à l'interne les avancées faites par chacun. Lorsque le code évolue significativement, les modifications sont proposées à l'équipe de développeurs qui les incorporent dans la version officielle, profitant ainsi à toute la communauté GOTM.

= Guide d'utilisation =
== Obtenir le code gotm_ismer ==
Le code <tt>gotm_ismer</tt> est en fait une copie du code <tt>gotm-4.0.0</tt> qui a subit quelques modifications somme toute assez superficielles associées aux modèles biogéochimiques. Dans un futur pas très lointain, l'objectif est de migrer vers [[FABM]] (Framework for Aquatic Biogeochemical Models), un code traitant les modèles biogéochimiques de manière modulaire et donc beaucoup plus flexible, couplés à gotm-4.1.

Pour obtenir le code gotm_ismer, vous devez d'abord avoir obtenu un accès à [[gitlasso]], le gestionnaire de version décentralisé du POLR.

Dans votre répertoire /home, exécutez la commande suivante: 
 git clone <nowiki>https://gitlasso.uqar.ca/dumoda01/gotm_ismer.git</nowiki>

Si le téléchargement a été effectué avec succès, vous devriez retrouver les répertoires suivants:
 compilers/  ! Contient les informations permettant de compiler le modèle sur votre ordinateur
 doc/        ! Documentation originale LaTeX
 include/    ! Définitions de pré-compilation
 nml/        ! Modèles de namelists (fichiers de contrôle ou de paramétrage des simulations)
 scripts/    ! Fonctions et scripts pertinents
 src/        ! Code source
 templates/  ! Modèles de routines
 test_cases/ ! Cas test

== Compiler le code ==
La compilation du code consiste à lire, interpréter, lier et condenser les routines fortran dans un fichier exécutable ou programme dont on se servira pour exécuter le modèle. Le code source se trouve dans le répertoire <tt>src/</tt> qui contient les routines fortran (<tt>.F90</tt>) qui sont classées dans des sous-répertoires représentant certaines sections du code.
 gotm/         ! Contient le programme principal.
 observations/ ! ...
 meanflow/     ! ...
 airsea/       ! ...
 turbulence/   ! ...
 util/         ! ...
 extras/       ! ...

=== Rules.make ===
Le répertoire <tt>src/</tt> contient également le fichier <tt>Makefile</tt>, qui fixe les règles de compilation qui ne doivent pas être modifiées (à moins que vous ne décidiez de faire certaines modifications avancées au code), et le fichier <tt>Rules.make.template</tt> qui contient les règles de compilation et les variables d'environnement propres à l'utilisateur et qui elles doivent être modifiées par l'utilisateur. Pour effectuer cette étape, faite une copie du fichier modèle <tt>Rules.make.template</tt> en le nommant <tt>Rules.make</tt>.
 cp Rules.make.template Rules.make
Modifiez ensuite les variables d'environnement en fonction de votre profil et de votre plate-forme.

==== brandypot.uqar.ca ====
Pour compiler avec ifort sur [[brandypot]]:
* Spécifier le compilateur à utiliser. Cette variable servira à pointer vers un fichier <tt>compiler.$FORTRAN_COMPILER</tt> qui doit exister et se trouver dans le répertoire <tt>compilers/</tt>: 
 FORTRAN_COMPILER=IFORT
* Indiquer l'emplacement des librairies NetCDF:
 NETCDFINC    = /opt/local/netcdf-3.6.1/include
 NETCDFLIBDIR = /opt/local/lib
* Déterminer quelles portions du code vous voulez compiler. Dans l'exemple suivant, le code correspondant aux modules <tt>sediment</tt> et <tt>seagrass</tt> (qu'on retrouve dans le répertoire <tt>src/extras/</tt>) ne sera pas compilé alors que le module <tt>bio</tt> et le module <tt>netcdf</tt>, qui permet de sauvegarder les sorties du modèle en format NetCDF, le sera:
 # What do we include in this compilation
 NetCDF=true
 SEDIMENT=false
 SEAGRASS=false
 BIO=true

==== mingan.uqar.ca ====
Pour compiler avec gfortran sur [[mingan]] (la compilation avec ifort sera décrite bientôt), modifier les lignes suivantes de <tt>Rules.make</tt>:
 FORTRAN_COMPILER=GFORTRAN
 
 NETCDFINC    = /usr/include
 NETCDFLIBDIR = /usr/lib64
 
 NETCDFLIB = -lnetcdff

Sur [[mingan]], assurez-vous d'avoir chargé les modules nécessaires. Il n'y a pas de module associé à ifort. Pour l'utiliser, faites la commandes suivante, que vous pouvez ajouter dans le <tt>.bashrc</tt>

 source /share/apps/intel/bin/ifortvars.sh intel64

Une fois le fichier <tt>Rules.make</tt> correctement modifié, vous pouvez compiler le code en faisant:
 make realclean
 make

À la fin de la compilation, l'exécutable <tt>gotm_prod_GFORTRAN</tt> est créé. Le terme <tt>prod</tt> indique que la compilation a été faite en mode production, option que l'on détermine dans le fichier <tt>Rules.make</tt> (l'autre option disponible est <tt>debug</tt>), et le terme <tt>GFORTRAN</tt> indique qu'elle a été réalisée avec le compilateur <tt>GFORTRAN</tt> utilisant le fichier de configuration <tt>compilers/compiler.GFORTRAN</tt>. En cas de problème, consultez la page [[dépannage]].

== Configurer une expérience ==
Si vous arrivez à compiler le code avec succès, c'est que vous êtes maintenant prêts à construire votre propre expérience. Vous pouvez pour cela vous inspirer des cas test (voir prochaine section), ou bien suivre les indications de cette section. Mettre en place une expérience nécessite d'abord de créer un répertoire de travail à partir duquel vous exécuterai le modèle. La pratique commune est de mettre toutes vos expérience (vous risquez d'en faire plus d'une) dans un répertoire <tt>exp/</tt> que vous pouvez créer dans un endroit où vous avez suffisamment d'espace disque. Sur [[brandypot]], il est commun d'utiliser la partition <tt>/sas/usagers</tt>  pour y mettre ce répertoire, comme par exemple <tt>/sas/usagers/dumoda01/gotm/exp</tt>. Afin de simplifier l'exécution du code, il est conseillé de faire un lien symbolique de <tt>exp/</tt> dans <tt>/home/dumoda01/gotm_ismer</tt> en faisant la commande:
 cd gotm_ismer
 ln -s /sas/usagers/dumoda01/gotm/exp .

De cette manière, le répertoire sera accessible aisément à partir du répertoire racine, mais les données parfois volumineuses seront stockées dans un endroit où il y a suffisamment d'espace. Dans <tt>exp/</tt>, créez un répertoire portant le nom de votre expérience (ex. <tt>potter_cove_1/</tt>). À ce stade-ci, vous avez besoin de trois ingrédients principaux pour réaliser votre expérience: 1) l'exécutable (<tt>gotm_prod_IFORT</tt>, que vous avez déjà), 2) des fichiers de paramètres <tt>namelist</tt> (<tt>*.nml</tt>) et 3) des fichiers intrants (<tt>*.dat</tt>).

La façon la plus sûre d'obtenir le premier est de créer une lien symbolique de l'exécutable se trouvant dans <tt>src/</tt> dans le répertoire de l'expérience:
 cd potter_cove_1
 ln -s /home/dumoda01/gotm_ismer/src/gotm_prod_IFORT .

De cette façon, toute modification au code sera prise en compte automatiquement.
Les fichiers namelist correspondant à la dernière version du code sont situés dans le répertoire <tt>gotm_ismer/nml/</tt>. Chaque fichier contient plusieurs namelists associées aux routines du code dont certains paramètres peuvent être affectés. Les namelists permettent de modifier des variables ou des paramètres sans avoir à recompiler le code. Chacun des paramètres sont documentés dans les fichiers. Certains fichiers sont obligatoires alors que d'autres dépendent des modules que l'on désire utiliser. En voici la liste complète:
 # Mandatory namelist files
 gotmrun.nml
 gotmmean.nml
 gotmturb.nml
 airsea.nml
 obs.nml
 kpp.nml
 
 # Module-dependent namelist files
 bio.nml
 bio_fasham.nml
 bio_npzd.nml
 bio_iow.nml

C'est à travers les namelist que l'on gère les intrants au modèle. Par exemple, on peut demander au modèle de lire les variables météorologiques ou des profils de température et de salinité à partir de fichiers. Dans un tel cas, il faut donc fournir ces fichiers et ce dans un format texte spécifique. C'est le troisième et dernier ingrédient à mettre dans la soupe. Pour de l'aide sur la façon de formater ces fichiers, consultez le fichier <tt>GOTM_HOWTO_observations.txt</tt> situé dans le répertoire racine. Les sections suivantes décrivent différentes façon de générer ces fichiers selon l'origine des données.

=== meteo.dat ===
Tel qu'indiqué dans <tt>GOTM_HOWTO_observations.txt</tt>, le fichier <tt>meteo.dat</tt> doit être formaté de la manière suivante:
 1957-09-01 00:00:00   2.46    6.80 1011.1   12.13   10.20 0.61
 1957-09-01 06:00:00   0.46    6.32 1011.2   13.85   11.04 0.63
 1957-09-01 12:00:00  -0.16    6.20 1010.8   15.38   10.72 0.88
 1957-09-01 18:00:00  -0.56    4.41 1010.2   13.56   10.50 0.83
 1957-09-02 00:00:00   1.83    3.43 1009.8   13.31   10.65 0.40
 1957-09-02 06:00:00   3.70    6.76 1009.1   13.08   10.86 1.00
 1957-09-02 12:00:00   5.24    7.13 1009.5   14.33   12.49 0.98
 1957-09-02 18:00:00   5.67    8.07 1009.7   15.06   12.09 0.71
 1957-09-03 00:00:00   5.15    6.46 1010.4   14.68   12.88 0.83
 1957-09-03 06:00:00   1.17    3.47 1010.4   14.78   13.42 0.69

=== Ajout d'un modèle biologique ===
Avant de se lancer dans l'ajout d'un modèle biologique, il peut être intéressant de comprendre la structure générale de GOTM et comment les modules (''.mod'') et sous-routine (''.F90'') sont liés entre eux, afin de comprendre comment modifier le code pour que nos ajouts/corrections soient pris en considération. Une présentation schématique est disponible ici : [https://drive.google.com/file/d/0B4GzaM0BUgWsWllZLXhYT3BQWm8/view?usp=sharing].

Il existe actuellement plusieurs modèles biologiques disponibles, répertoriés dans la namelist ''bio.nml'':

 1: NPZD                     (4 variables)
 2: IOW-ERGOM                (9 variables)
 3: Suspended matter only    (1 variable)
 4: Fasham et al. 1990       (7 variables)
 5: IOW-ERGOM MaBenE version (9 variables)
 6: ISMER model              (9 variables)
 7: GSJ model                (11 variables)
 8: Ariadna Nocera's model   (tbd)
 9: North water polynya's model   (tbd)

Selon vos besoins vous pourriez avoir envie de construire votre propre modèle de réaction afin de répondre à votre question de recherche.
Voici les étapes à suivre pour ajouter un nouveau modèle à partir d'un modèle existant:

*'''model_name.F90'''

L'ensemble des fichiers avec l'extension ''.F90'' se trouvent dans le répertoire ''/gotm_ismer/src/extras/bio''. Choisissez parmi les modèles biologiques déjà disponibles, celui se rapprochant le plus de celui que vous souhaitez développer. Faite une copie de ce fichier en le renommant avec le nom de votre modèle:
 
 mv /gotm_ismer/src/extras/bio/initial_model_name.F90 /gotm_ismer/src/extras/bio/final_model_name.F90

Il s'agira par la suite dans ce fichier ''final_model_name.F90'' de renommer partout l’ancien nom du modèle par le nouveau. Exemple:

 Fichier initial : bio_fasham.F90 
 Fichier final   : bio_polynow.F90
 Dans bio_fasham.F90 remplacer tous les lieux ou sera écrit "fasham" par "polynow".

Par la suite dans ce fichier ''final_model_name.F90'' vous pourrez librement construire ou améliorer votre modèle biologique.

'''Note''': dans ce fichier .F90, la routine ''var_info_modelname'' spécifie le numéro de chaque variable. Il peut être par la suite utilisé par d'autres routines. Par exemple il est important de noter la valeur de l'indice attribué au nitrate et à l'ammonium pour les référencer correctement dans les fichiers ''ammonium.F90'' et ''nitrates.F90''.

 '''''Dans le fichier bio_polynow.F90, sous-routine var_info_polynow:'''''
   var_names('''5''') = 'nit'  ! indice du nitrate = 5
   var_units(5) = 'mmol/m**3'
   var_long(5)  = 'nitrate'
   var_names('''6''') = 'amm'  ! indice de l'ammonium = 6
   var_units(6) = 'mmol/m**3'
   var_long(6)  = 'ammonium'

 '''''Dans le fichier nitrates.F90:'''''
   else if (bio_model.eq.9) then  !! Le 9 ici fait référence au modèle sélectionné (voir section bio.F90)
      do i=1,nlev
         nit(i) = cc('''5''',i)
     end do
 '''''Dans le fichier ammonium.F90:'''''
 else if (bio_model.eq.9) then  
      do i=1,nlev
         amm(i) = cc('''6''',i)
      end do

*'''bio.F90'''
Ce fichier permet de répertorier l'ensemble des modèles biologiques disponibles et de sélectionner parmi eux (d'après le choix par l'utilisateur via la namelist ''bio.nml'') celui à prendre en compte lorsque l'on fera tourner le modèle. Il s'agira donc de répertorier ici votre nouveau modèle biologique à 3 endroits différents:
 
 '''''* Dans la partie déclaration du module:'''''
   use bio_polynow,  only : init_bio_polynow,init_var_polynow,var_info_polynow  
   use bio_polynow,  only : light_polynow,do_bio_polynow 

 '''''*Dans la partie déclaration de la sous-routine init_bio'''''
 case (9)  
 call init_bio_polynow(namlst,'bio_polynow.nml',unit)
 call allocate_memory(nlev)
 call init_var_polynow(nlev)
 call var_info_polynow()''
 ''Ici le numéro fait référence aux modèles biologiques comme numérotés dans la namelist bio.nml.''
 ''Notre modèle bio_polynow est donc le 9eme modèle associé à GOTM dans les répertoires de l'ismer, et celui de Fasham par exemple est référencé comme le numéro 4.''

 '''''*Dans la partie déclaration de la sous-routine do_bio'''''
 case (9)                                                         
 call light_polynow(nlev,bioshade_feedback)                     
 call ode_solver(ode_method,numc,nlev,dt_eff,cc,do_bio_polynow)

*'''Makefile'''
Ajoutez dans ce fichier votre modèle (lignes à insérer de manière similaire à celles référençant les autres modèles ) :
 bio_polynow.F90		\
 ${LIB}(bio_polynow.o)	\

*'''bio.nml'''
Dans la namelist ''bio.nml'' (disponible dans le répertoire /gotm_ismer/nml) ajoutez votre modèle dans la partie description.
  9: North water polynya's model   (tbd)

*'''bio_polynow.nml'''
Il faut ajouter une namelist au nom de votre modèle dans le répertoire ''/gotm_ismer/exp/nom_exp/'' , pour que le modèle se réfère aux valeurs des paramètres mentionnées par l'utilisateur. 
Une simple copie de la nml du modèle d'après lequel vous construisez votre modèle suffit. 
 mv /../exp/bio_nocera.nml /../exp/bio_polynow.nml
 
Une fois le fichier copier ne pas oublier de modifier dans le fichier le nom de la namelist.
 gedit bio_polynow.nml 
 &bio_polynow_nml

Une fois toutes ces étapes réalisées, vous pourrez aller dans le dossier ''/src'' et recompiler le modèle comme mentionné précédemment à l'aide des commandes :
 make realclean
 make

Si vous avez réalisé un lien symbolique vers ''gotm_prod_IFORT'' alors la sortie de modèle aura pris en compte les modifications que vous aurez réalisé dans le code.

==== Ajout d'une constante dans le modèle biologique ====

Lors de l'élaboration de votre modèle biologique vous pouvez être amené à utiliser des constantes dans vos équations. Pour ce faire il y a quelques étapes à respecter. Nous prendrons ici l'exemple de l'équation de la '''nitrification''' et donc l'ajout de la constante de nitrification, ''mu5''.
 
*'''bio_polynow.F90'''

Dans votre fichier ''.F90'' contenant le code de votre modèle, situé (''/gotm_ismer/src/extras/bio'') vous devrez ajouter votre constante ''mu5'' :

 '''''Dans la définition des paramètres du module'''''
 REALTYPE                  ::  mu5      = 0.1     
 
 '''''Dans la sous-routine init_bio_polynow'''''
   namelist /bio_polynow_nml/ numc, &
                        p_initial,z_initial,b_initial,d_initial,           &
                        l_initial,p0,z0,b0,vp,alpha,k1,k2,mu1,k5,          &
                        gamma,w_p,gmax,k3,beta,mu2,k6,delta,epsi,r1,r2,r3, &
                        vb,k4,mu3,eta,mu4,w_d,'''mu5''',kc,                      &    
                        I_opt,inib,                                        &    
                        theta,w_pmax,w_pmin                                     

 '''''Dans la sous-routine do_bio_polynow'''''
      dd(a,n,ci)=mu5*cc(a,ci)     
*'''bio_polynow.nml''' 
Il faudra ensuite modifier la namelist ''bio_polynow.nml'' et y référencer le taux de nitrification:
 '''''Dans la description de la namelist'''''   
 !  mu5     = nitrification rate                                  [1/day]    
 '''''Dans la liste des paramètres que l'utilisateur spécifie'''''
    mu5     = 0.1              

Une fois ces changements effectués, ne pas oublier de re-compiler le modèle.

== Exécuter en mode batch ==
Les scripts <tt>batch_airsea.sh</tt> et <tt>batch_bio.sh</tt> permettent de lancer en série plusieurs simulations avec des valeurs de paramètres différents. Le script <tt>batch_airsea.sh</tt> permet de faire varier les forçages en surface alors que <tt>batch_bio.sh</tt> permet de varier les paramètres des modèles biologiques. Ils sont situés dans le répertoire <tt>gotm_ismer/scripts/shell/</tt>.

=== batch_bio.sh ===
Ce script prend en argument le nom du modèle biologique sui sera utilisé, tel que spécifié dans <tt>bio.nml</tt>. Par exemple, si on utilise le modèle de Fasham (<tt>bio_model=4</tt>), on écrit:
 ./batch_bio.sh fasham

Si le répertoire <tt>gotm_ismer/script/shell</tt> est dans votre <tt>PATH</tt>, vous pouvez appeler le script sans le <tt>./</tt>:
 batch_bio.sh fasham

Deux fichiers sont nécessaires, <tt>bio_$model.mal</tt> et <tt>gotmrun.mal</tt>, qui sont en fait les fichiers namelists qui seront lus par le script pour générer les <tt>.nml</tt> correspond qui eux seront utilisés par le modèle. Dans <tt>gotmrun.mal</tt>, le paramètre qui spécifie le nom du fichier de sortie <tt>out</tt> doit être <tt>experiment_name</tt>. Dans <tt>bio_$model.mal</tt> (<tt>$model</tt> est l'argument du script, e.g. <tt>fasham</tt>, <tt>npzd</tt> ou <tt>ismer</tt>), les paramètres dont on veut varier les valeurs pour chacune des simulation de la batch doivent prendre les valeurs <tt>param1</tt>, <tt>param2</tt>, <tt>param3</tt>, etc. Vous pouvez attribuer ces valeurs à autant de paramètres que vous le voulez. Une fois que ce choix est fait, vous devrez modifier le script <tt>batch_bio.sh</tt> pour tenir compte de ces choix.

Pour illustrer cette étape, procédons par un exemple. Supposons qu'on veuille faire ving-cinq simulations en variant deux paramètres, <tt>vp</tt> et <tt>alpha</tt> qui prendront chacun cinq valeurs différentes. Ceci doit être spécifié de la manière suivante:
 # Parameters for the biological model
 vp="0.02 0.08 0.24 0.48 0.72"
 alpha="0.01 0.04 0.16 0.32 0.48"

Ensuite, il faut ajuster la portion suivante du script afin de respecter le nombre de paramètres:
 ...
 count=0
 for a in $vp
 do
 for b in $alpha
 do
 count=`expr $count + 1`
 count=`expr 000$count | tail -8c`
 echo $count
 if [ -f bio_fasham.nml ] then
   rm -f bio_fasham.nml
 fi
 cat bio_fasham.mal | sed \
   -e "s/param1/$a/g" \
   -e "s/param2/$b/g" \
   > bio_fasham.nml
 if [ -f bio_fasham.nml ] then
   echo "   bio_fasham.nml created"
 fi
 
 if [ -f gotmrun.nml ] then
   rm -f gotmrun.nml
 fi
 cat gotmrun.mal | sed \
   -e "s/experiment_name/$count/g" \
   > gotmrun.nml
 if [ -f gotmrun.nml ] then
   echo "   gotmrun.nml    created"
 fi
 strt=`date +%H:%M:%S`
 echo "   started at "$strt
 ./gotm_prod_IFORT >& $count.out
 end=`date +%H:%M:%S`
 echo "   ended   at "$end
 done
 done
 ...

Dans cet exemple, le fichier <tt>bio_fasham.mal</tt> devra contenir les lignes suivantes:
 ...
 vp    = param1
 alpha = param2
 ...

Le script remplacera successivement <tt>param1</tt> et <tt>param2</tt> par les valeurs spécifiées, écrira la namelist et exécutera le modèle.

=== batch_airsea.sh ===
Le script <tt>batch_airsea.sh</tt> est utile pour lancer un ensemble de simulations avec des fichiers de forçage distincts pour chacune des simulations. Il fonctionne de manière très similaire à <tt>batch_bio.sh</tt> en remplaçant créant un fichier <tt>airsea.nml</tt> à partir d'un fichier <tt>airsea.mal</tt> où les paramètres à remplacer sont les noms des fichiers contenant les différents forçages atmosphériques. Pour cela, il faut d'abord créer ces fichiers. Comme chacune des simulations porte un numéro, il est commode d'inclure un numéro dans le nom du fichier, comme dans l'exemple suivant:
 momentum_flux_001.dat
 momentum_flux_002.dat
 momentum_flux_003.dat
 momentum_flux_004.dat
 momentum_flux_005.dat
 momentum_flux_006.dat
 ...

De cette manière, la liste des fichiers formées dans la boucle du script sera ordonnée et la simulation <tt>001.nc</tt> correspondra au forçage <tt>momemtum_flux_001.dat</tt>. Le fichier <tt>gotmrun.mal</tt> doit exister et être configuré tel que décrit dans la section <tt>batch_bio.sh</tt>.
 ...
 count=0
 for file in narr_momentum_*.dat
 do
 count=`expr $count + 1`
 count=`expr 000$count | tail -3c`
 echo $count
 if [ -f airsea.nml ] then
   rm -f airsea.nml
 fi
 cat airsea.mal | sed \
   -e "s/heatfile/narr_heatflux_2008_$count/g" \
   > airsea.nml
 if [ -f airsea.nml ] then
   echo "   airsea.nml created"
 fi
 if [ -f gotmrun.nml ] then
   rm -f gotmrun.nml
 fi
 cat gotmrun.mal | sed \
   -e "s/experiment_name/$count/g" \
   > gotmrun.nml
 if [ -f gotmrun.nml ] then
   echo "   gotmrun.nml    created"
 fi
 strt=`date +%H:%M:%S`
 echo "   started at "$strt
 ./gotm_prod_IFORT >& $count.out
 end=`date +%H:%M:%S`
 echo "   ended   at "$end
 done
 ...

== Cas test ==
À venir ...

== Visualisation des résultats ==
Pour visualiser les sorties du modèle, le logiciel [http://ferret.pmel.noaa.gov/ Ferret] constitue une option extrêmement intéressante. Ce programme permet de produire des figures très simplement en tenant compte des méta-données contenues dans les fichiers NetCDF. Pour se familiariser avec le logiciel et obtenir de l'aide, consultez le site [http://ferret.pmel.noaa.gov/]. Dans cette section sont présentés des exemples de scripts permettant de visualiser des quantités importantes pour l'interprétation d'une simulation couplée. Les scripts ferret (<tt>*.jnl</tt>) sont en fait une liste de commandes Ferret qu'on peut exécuter avec la commande suivante:
 ferret -gif -script scriptname.jnl

L'option <tt>-gif</tt> dit à ferret de ne pas afficher les figures à l'écran pendant l'exécution du script. Les figures seront plutôt produites et sauvegardées par la commande
 frame/file=figure.gif

qui apparaît dans le script. Voici donc quelques exemples appliqués à une simulation couplée représentant le golfe d'Amundsen avec le modèle biologique de type Fasham et al. (1990).

[[Category:Modèles  numériques]]