doc/fr/ref_observers_requirements.rst

   1 ..
   2    Copyright (C) 2008-2024 EDF R&D
   3
   4    This file is part of SALOME ADAO module.
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19
  20    See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21
  22    Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  23
  24 .. _section_ref_observers_requirements:
  25
  26 Conditions requises pour les fonctions décrivant un "*observer*"
  27 ----------------------------------------------------------------
  28
  29 .. index:: single: Observer
  30 .. index:: single: setObserver
  31 .. index:: single: Observer Template
  32
  33 Certaines variables spéciales, internes à l'optimisation et utilisées au cours
  34 des calculs, peuvent être surveillées durant un calcul ADAO. Ces variables
  35 peuvent être affichées, tracées, enregistrées, etc. par l'utilisateur. C'est
  36 réalisable en utilisant des "*observer*", parfois aussi appelés des "callback",
  37 sur une variable. Ce sont des fonctions Python spéciales, qui sont chacune
  38 associées à une variable donnée, comme décrit conceptuellement dans la figure
  39 suivante :
  40
  41   .. ref_observer_simple:
  42   .. image:: images/ref_observer_simple.png
  43     :align: center
  44     :width: 75%
  45   .. centered::
  46     **Définition conceptuelle d'une fonction "observer"**
  47
  48 Ces fonctions "*observer*" sont décrites dans les sous-sections suivantes.
  49
  50 Enregistrer et activer une fonction "*observer*"
  51 ++++++++++++++++++++++++++++++++++++++++++++++++
  52
  53 Dans l'interface graphique EFICAS d'ADAO, il y a 3 méthodes pratiques pour
  54 intégrer une fonction "*observer*" dans un cas ADAO. La méthode est choisie à
  55 l'aide du mot-clé "*NodeType*" de chaque entrée de type "*observer*", comme
  56 montré dans la figure qui suit :
  57
  58   .. eficas_observer_nodetype:
  59   .. image:: images/eficas_observer_nodetype.png
  60     :align: center
  61     :width: 100%
  62   .. centered::
  63     **Choisir son type d'entrée pour une fonction "observer"**
  64
  65 Une fonction "*observer*" peut être fourni sous la forme d'un script explicite
  66 (entrée de type "*String*"), d'un script contenu dans un fichier externe
  67 (entrée de type "*Script*"), ou en utilisant un modèle (entrée de type
  68 "*Template*"). Les modèles sont fournis par défaut dans ADAO, lors de l'usage
  69 de l'éditeur graphique EFICAS d'ADAO ou de l'interface TUI, et sont détaillés
  70 dans la partie :ref:`section_ref_observers_templates` qui suit. Ces derniers
  71 sont des scripts simples qui peuvent être adaptés par l'utilisateur, soit dans
  72 l'étape d'édition intégrée du cas avec EFICAS d'ADAO, soit dans l'étape
  73 d'édition du schéma avant l'exécution, pour améliorer la performance du calcul
  74 ADAO dans le superviseur d'exécution de SALOME.
  75
  76 Dans l'interface textuelle (TUI) d'ADAO (voir la partie :ref:`section_tui`),
  77 les mêmes informations peuvent être données à l'aide de la commande
  78 "*setObserver*" appliquée pour une variable donnée indiquée en utilisant
  79 l'argument "*Variable*". Les autres arguments de cette commande permettent de
  80 définir un "*observer*" soit comme un modèle (argument "*Template*") désignant
  81 l'un des scripts détaillés dans la partie
  82 :ref:`section_ref_observers_templates`, soit comme un script explicite
  83 (argument "*String*"), soit comme un script contenu dans un fichier externe
  84 (argument "*Script*").
  85
  86 Forme générale d'un script permettant de définir une fonction "*observer*"
  87 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  88
  89 Une fonction "*observer*" est un script Python spécial, associé à une variable
  90 donnée, et qui est automatiquement activée à chaque modification de la variable
  91 lors du calcul. Chaque fonction (soigneusement établie) qui s'applique à la
  92 variable sélectionnée peut être utilisée. De nombreuses fonctions "*observer*"
  93 sont disponibles par défaut.
  94
  95 Pour pouvoir utiliser directement cette capacité "*observer*", l'utilisateur
  96 doit utiliser ou construire un script utilisant en entrée standard (i.e.
  97 disponible dans l'espace de nommage) les variables ``var`` et ``info``. La
  98 variable ``var`` est à utiliser comme un objet de type liste/tuple, contenant
  99 l'historique de la variable d'intérêt, indicé par les pas d'itérations et/ou de
 100 temps. Seul le corps de la fonction "*observer*" doit être spécifié par
 101 l'utilisateur, pas l'appel Python ``def`` de fonction lui-même.
 102
 103 A titre d'exemple, voici un script très simple (similaire au modèle
 104 "*ValuePrinter*"), utilisable pour afficher la valeur d'une variable
 105 surveillée :
 106 ::
 107
 108     print("    --->",info," Value =",var[-1])
 109
 110 Stockées comme un fichier Python ou une chaîne de caractères explicite, cette
 111 ou ces lignes de script peuvent être associées à chaque variable présente dans
 112 le mot-clé "*SELECTION*" de la commande "*Observers*" du cas ADAO :
 113 "*Analysis*", "*CurrentState*", "*CostFunction*"... La valeur courante de la
 114 variable sera par exemple affichée à chaque étape de l'algorithme
 115 d'optimisation ou d'assimilation. Les "*observer*" peuvent inclure des
 116 capacités d'affichage graphique, de stockage, de traitement complexe, d'analyse
 117 statistique, etc. Si une variable, à laquelle est lié un "*observer*", n'est
 118 pas requise dans le calcul et par l'utilisateur, l'exécution de cet
 119 "*observer*" n'est tout simplement jamais activée.
 120
 121 .. warning::
 122
 123     Si les modèles disponibles par défaut ne sont pas utilisés, il revient à
 124     l'utilisateur de faire des scripts de fonctions soigneusement établis ou
 125     des programmes externes qui ne se plantent pas avant d'être enregistrés
 126     comme une fonction "*observer*". Le débogage peut sinon être vraiment
 127     difficile !
 128
 129 Certains "*observer*" permettent de créer des fichiers ou des figures
 130 successives, qui sont numérotées de manière unique et, le cas échéant,
 131 enregistrées par défaut dans le répertoire standard ``/tmp``. Dans le cas où
 132 ces informations sont à modifier (comme par exemple lorsque le répertoire
 133 ``/tmp`` est un dossier virtuel ou local non pérenne, ou lorsque l'on désire
 134 une numérotation en fonction de l'itération), l'utilisateur est invité à
 135 s'inspirer d'un modèle lui convenant pour le modifier en spécifiant
 136 différemment ces informations communes. Ensuite, la fonction modifiée peut être
 137 utilisée dans une entrée de type "*String*" ou de type "*Script*".
 138
 139 .. note::
 140
 141     Une partie des "*observer*" permet de créer des figures en utilisant le
 142     module Python intégré Gnuplot.py [Gnuplot.py]_, ici mis à jour pour
 143     supporter Python 3. Ce module est une interface de contrôle et de
 144     transmission d'arguments au remarquable utilitaire classique de tracé
 145     graphique Gnuplot [Gnuplot]_. Disponible pour la grande majorité des
 146     environnements, ce dernier est indépendant et doit être correctement
 147     préinstallé.
 148
 149 On donne ci-après l'identifiant et le contenu de tous les modèles "*observer*"
 150 disponibles.
 151
 152 .. _section_ref_observers_templates:
 153
 154 Inventaire des modèles de fonctions "*observer*" disponibles ("*Template*")
 155 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 156
 157 .. index:: single: ValuePrinter (Observer)
 158
 159 Modèle **ValuePrinter**
 160 .......................
 161
 162 Imprime sur la sortie standard la valeur courante de la variable.
 163
 164 ::
 165
 166     print(str(info)+" "+str(var[-1]))
 167
 168 .. index:: single: ValueAndIndexPrinter (Observer)
 169
 170 Modèle **ValueAndIndexPrinter**
 171 ...............................
 172
 173 Imprime sur la sortie standard la valeur courante de la variable, en ajoutant son index.
 174
 175 ::
 176
 177     print(str(info)+(" index %i:"%(len(var)-1))+" "+str(var[-1]))
 178
 179 .. index:: single: ValueSeriePrinter (Observer)
 180
 181 Modèle **ValueSeriePrinter**
 182 ............................
 183
 184 Imprime sur la sortie standard la série des valeurs de la variable.
 185
 186 ::
 187
 188     print(str(info)+" "+str(var[:]))
 189
 190 .. index:: single: ValueSaver (Observer)
 191
 192 Modèle **ValueSaver**
 193 .....................
 194
 195 Enregistre la valeur courante de la variable dans un fichier du répertoire '/tmp' nommé 'value...txt' selon le nom de la variable et l'étape d'enregistrement.
 196
 197 ::
 198
 199     import numpy, re
 200     v=numpy.array(var[-1], ndmin=1)
 201     global istep
 202     try:
 203         istep+=1
 204     except:
 205         istep=0
 206     f='/tmp/value_%s_%05i.txt'%(info,istep)
 207     f=re.sub(r'\s','_',f)
 208     print('Value saved in "%s"'%f)
 209     numpy.savetxt(f,v)
 210
 211 .. index:: single: ValueSerieSaver (Observer)
 212
 213 Modèle **ValueSerieSaver**
 214 ..........................
 215
 216 Enregistre la série des valeurs de la variable dans un fichier du répertoire '/tmp' nommé 'value...txt' selon le nom de la variable et l'étape.
 217
 218 ::
 219
 220     import numpy, re
 221     v=numpy.array(var[:], ndmin=1)
 222     global istep
 223     try:
 224         istep+=1
 225     except:
 226         istep=0
 227     f='/tmp/value_%s_%05i.txt'%(info,istep)
 228     f=re.sub(r'\s','_',f)
 229     print('Value saved in "%s"'%f)
 230     numpy.savetxt(f,v)
 231
 232 .. index:: single: ValuePrinterAndSaver (Observer)
 233
 234 Modèle **ValuePrinterAndSaver**
 235 ...............................
 236
 237 Imprime sur la sortie standard et, en même temps enregistre dans un fichier du répertoire '/tmp', la valeur courante de la variable.
 238
 239 ::
 240
 241     import numpy, re
 242     v=numpy.array(var[-1], ndmin=1)
 243     print(str(info)+" "+str(v))
 244     global istep
 245     try:
 246         istep+=1
 247     except:
 248         istep=0
 249     f='/tmp/value_%s_%05i.txt'%(info,istep)
 250     f=re.sub(r'\s','_',f)
 251     print('Value saved in "%s"'%f)
 252     numpy.savetxt(f,v)
 253
 254 .. index:: single: ValueIndexPrinterAndSaver (Observer)
 255
 256 Modèle **ValueIndexPrinterAndSaver**
 257 ....................................
 258
 259 Imprime sur la sortie standard et, en même temps enregistre dans un fichier du répertoire '/tmp', la valeur courante de la variable, en ajoutant son index.
 260
 261 ::
 262
 263     import numpy, re
 264     v=numpy.array(var[-1], ndmin=1)
 265     print(str(info)+(" index %i:"%(len(var)-1))+" "+str(v))
 266     global istep
 267     try:
 268         istep+=1
 269     except:
 270         istep=0
 271     f='/tmp/value_%s_%05i.txt'%(info,istep)
 272     f=re.sub(r'\s','_',f)
 273     print('Value saved in "%s"'%f)
 274     numpy.savetxt(f,v)
 275
 276 .. index:: single: ValueSeriePrinterAndSaver (Observer)
 277
 278 Modèle **ValueSeriePrinterAndSaver**
 279 ....................................
 280
 281 Imprime sur la sortie standard et, en même temps, enregistre dans un fichier du répertoire '/tmp', la série des valeurs de la variable.
 282
 283 ::
 284
 285     import numpy, re
 286     v=numpy.array(var[:], ndmin=1)
 287     print(str(info)+" "+str(v))
 288     global istep
 289     try:
 290         istep+=1
 291     except:
 292         istep=0
 293     f='/tmp/value_%s_%05i.txt'%(info,istep)
 294     f=re.sub(r'\s','_',f)
 295     print('Value saved in "%s"'%f)
 296     numpy.savetxt(f,v)
 297
 298 .. index:: single: ValueGnuPlotter (Observer)
 299
 300 Modèle **ValueGnuPlotter**
 301 ..........................
 302
 303 Affiche graphiquement avec Gnuplot la valeur courante de la variable (affichage persistant).
 304
 305 ::
 306
 307     import numpy, Gnuplot
 308     v=numpy.array(var[-1], ndmin=1)
 309     global igfig, gp
 310     try:
 311         igfig+=1
 312         gp('set title "%s (Figure %i)"'%(info,igfig))
 313     except:
 314         igfig=0
 315         gp=Gnuplot.Gnuplot(persist=1)
 316         gp('set title "%s (Figure %i)"'%(info,igfig))
 317         gp('set style data lines')
 318     gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
 319
 320 .. index:: single: ValueSerieGnuPlotter (Observer)
 321
 322 Modèle **ValueSerieGnuPlotter**
 323 ...............................
 324
 325 Affiche graphiquement avec Gnuplot la série des valeurs de la variable (affichage persistant).
 326
 327 ::
 328
 329     import numpy, Gnuplot
 330     v=numpy.array(var[:], ndmin=1)
 331     global igfig, gp
 332     try:
 333         igfig+=1
 334         gp('set title "%s (Figure %i)"'%(info,igfig))
 335     except:
 336         igfig=0
 337         gp=Gnuplot.Gnuplot(persist=1)
 338         gp('set title "%s (Figure %i)"'%(info,igfig))
 339         gp('set style data lines')
 340         gp('set xlabel "Step"')
 341         gp('set ylabel "Variable"')
 342     gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
 343
 344 .. index:: single: ValuePrinterAndGnuPlotter (Observer)
 345
 346 Modèle **ValuePrinterAndGnuPlotter**
 347 ....................................
 348
 349 Imprime sur la sortie standard et, en même temps, affiche graphiquement avec Gnuplot la valeur courante de la variable (affichage persistant).
 350
 351 ::
 352
 353     print(str(info)+' '+str(var[-1]))
 354     import numpy, Gnuplot
 355     v=numpy.array(var[-1], ndmin=1)
 356     global igfig, gp
 357     try:
 358         igfig+=1
 359         gp('set title "%s (Figure %i)"'%(info,igfig))
 360     except:
 361         igfig=0
 362         gp=Gnuplot.Gnuplot(persist=1)
 363         gp('set title "%s (Figure %i)"'%(info,igfig))
 364         gp('set style data lines')
 365     gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
 366
 367 .. index:: single: ValueSeriePrinterAndGnuPlotter (Observer)
 368
 369 Modèle **ValueSeriePrinterAndGnuPlotter**
 370 .........................................
 371
 372 Imprime sur la sortie standard et, en même temps, affiche graphiquement avec Gnuplot la série des valeurs de la variable (affichage persistant).
 373
 374 ::
 375
 376     print(str(info)+' '+str(var[:]))
 377     import numpy, Gnuplot
 378     v=numpy.array(var[:], ndmin=1)
 379     global igfig, gp
 380     try:
 381         igfig+=1
 382         gp('set title "%s (Figure %i)"'%(info,igfig))
 383     except:
 384         igfig=0
 385         gp=Gnuplot.Gnuplot(persist=1)
 386         gp('set title "%s (Figure %i)"'%(info,igfig))
 387         gp('set style data lines')
 388         gp('set xlabel "Step"')
 389         gp('set ylabel "Variable"')
 390     gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
 391
 392 .. index:: single: ValuePrinterSaverAndGnuPlotter (Observer)
 393
 394 Modèle **ValuePrinterSaverAndGnuPlotter**
 395 .........................................
 396
 397 Imprime sur la sortie standard et, en même temps, enregistre dans un fichier du répertoire '/tmp' et affiche graphiquement la valeur courante de la variable (affichage persistant).
 398
 399 ::
 400
 401     print(str(info)+' '+str(var[-1]))
 402     import numpy, re
 403     v=numpy.array(var[-1], ndmin=1)
 404     global istep
 405     try:
 406         istep+=1
 407     except:
 408         istep=0
 409     f='/tmp/value_%s_%05i.txt'%(info,istep)
 410     f=re.sub(r'\s','_',f)
 411     print('Value saved in "%s"'%f)
 412     numpy.savetxt(f,v)
 413     import Gnuplot
 414     global igfig, gp
 415     try:
 416         igfig+=1
 417         gp('set title "%s (Figure %i)"'%(info,igfig))
 418     except:
 419         igfig=0
 420         gp=Gnuplot.Gnuplot(persist=1)
 421         gp('set title "%s (Figure %i)"'%(info,igfig))
 422         gp('set style data lines')
 423     gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
 424
 425 .. index:: single: ValueSeriePrinterSaverAndGnuPlotter (Observer)
 426
 427 Modèle **ValueSeriePrinterSaverAndGnuPlotter**
 428 ..............................................
 429
 430 Imprime sur la sortie standard et, en même temps, enregistre dans un fichier du répertoire '/tmp' et affiche graphiquement la série des valeurs de la variable (affichage persistant).
 431
 432 ::
 433
 434     print(str(info)+' '+str(var[:]))
 435     import numpy, re
 436     v=numpy.array(var[:], ndmin=1)
 437     global istep
 438     try:
 439         istep+=1
 440     except:
 441         istep=0
 442     f='/tmp/value_%s_%05i.txt'%(info,istep)
 443     f=re.sub(r'\s','_',f)
 444     print('Value saved in "%s"'%f)
 445     numpy.savetxt(f,v)
 446     import Gnuplot
 447     global igfig, gp
 448     try:
 449         igfig+=1
 450         gp('set title "%s (Figure %i)"'%(info,igfig))
 451     except:
 452         igfig=0
 453         gp=Gnuplot.Gnuplot(persist=1)
 454         gp('set title "%s (Figure %i)"'%(info,igfig))
 455         gp('set style data lines')
 456         gp('set xlabel "Step"')
 457         gp('set ylabel "Variable"')
 458     gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
 459
 460 .. index:: single: ValueMatPlotter (Observer)
 461
 462 Modèle **ValueMatPlotter**
 463 ..........................
 464
 465 Affiche graphiquement avec Matplolib la valeur courante de la variable (affichage non persistant).
 466
 467 ::
 468
 469     import numpy
 470     import matplotlib.pyplot as plt
 471     v=numpy.array(var[-1], ndmin=1)
 472     global imfig, mp, ax
 473     plt.ion()
 474     try:
 475         imfig+=1
 476         mp.suptitle('%s (Figure %i)'%(info,imfig))
 477     except:
 478         imfig=0
 479         mp = plt.figure()
 480         ax = mp.add_subplot(1, 1, 1)
 481         mp.suptitle('%s (Figure %i)'%(info,imfig))
 482     ax.plot(v)
 483     plt.show()
 484
 485 .. index:: single: ValueMatPlotterSaver (Observer)
 486
 487 Modèle **ValueMatPlotterSaver**
 488 ...............................
 489
 490 Affiche graphiquement avec Matplolib la valeur courante de la variable, et enregistre la figure dans un fichier du répertoire '/tmp' (figure persistante).
 491
 492 ::
 493
 494     import numpy, re
 495     import matplotlib.pyplot as plt
 496     v=numpy.array(var[-1], ndmin=1)
 497     global imfig, mp, ax
 498     plt.ion()
 499     try:
 500         imfig+=1
 501         mp.suptitle('%s (Figure %i)'%(info,imfig))
 502     except:
 503         imfig=0
 504         mp = plt.figure()
 505         ax = mp.add_subplot(1, 1, 1)
 506         mp.suptitle('%s (Figure %i)'%(info,imfig))
 507     ax.plot(v)
 508     f='/tmp/figure_%s_%05i.pdf'%(info,imfig)
 509     f=re.sub(r'\s','_',f)
 510     plt.savefig(f)
 511     plt.show()
 512
 513 .. index:: single: ValueSerieMatPlotter (Observer)
 514
 515 Modèle **ValueSerieMatPlotter**
 516 ...............................
 517
 518 Affiche graphiquement avec Matplolib la série des valeurs de la variable (affichage non persistant).
 519
 520 ::
 521
 522     import numpy
 523     import matplotlib.pyplot as plt
 524     v=numpy.array(var[:], ndmin=1)
 525     global imfig, mp, ax
 526     plt.ion()
 527     try:
 528         imfig+=1
 529         mp.suptitle('%s (Figure %i)'%(info,imfig))
 530     except:
 531         imfig=0
 532         mp = plt.figure()
 533         ax = mp.add_subplot(1, 1, 1)
 534         mp.suptitle('%s (Figure %i)'%(info,imfig))
 535         ax.set_xlabel('Step')
 536         ax.set_ylabel('Variable')
 537     ax.plot(v)
 538     plt.show()
 539
 540 .. index:: single: ValueSerieMatPlotterSaver (Observer)
 541
 542 Modèle **ValueSerieMatPlotterSaver**
 543 ....................................
 544
 545 Affiche graphiquement avec Matplolib la série des valeurs de la variable, et enregistre la figure dans un fichier du répertoire '/tmp' (figure persistante).
 546
 547 ::
 548
 549     import numpy, re
 550     import matplotlib.pyplot as plt
 551     v=numpy.array(var[:], ndmin=1)
 552     global imfig, mp, ax
 553     plt.ion()
 554     try:
 555         imfig+=1
 556         mp.suptitle('%s (Figure %i)'%(info,imfig))
 557     except:
 558         imfig=0
 559         mp = plt.figure()
 560         ax = mp.add_subplot(1, 1, 1)
 561         mp.suptitle('%s (Figure %i)'%(info,imfig))
 562         ax.set_xlabel('Step')
 563         ax.set_ylabel('Variable')
 564     ax.plot(v)
 565     f='/tmp/figure_%s_%05i.pdf'%(info,imfig)
 566     f=re.sub(r'\s','_',f)
 567     plt.savefig(f)
 568     plt.show()
 569
 570 .. index:: single: ValuePrinterAndMatPlotter (Observer)
 571
 572 Modèle **ValuePrinterAndMatPlotter**
 573 ....................................
 574
 575 Affiche graphiquement avec Matplolib la valeur courante de la variable (affichage non persistant).
 576
 577 ::
 578
 579     print(str(info)+' '+str(var[-1]))
 580     import numpy
 581     import matplotlib.pyplot as plt
 582     v=numpy.array(var[-1], ndmin=1)
 583     global imfig, mp, ax
 584     plt.ion()
 585     try:
 586         imfig+=1
 587         mp.suptitle('%s (Figure %i)'%(info,imfig))
 588     except:
 589         imfig=0
 590         mp = plt.figure()
 591         ax = mp.add_subplot(1, 1, 1)
 592         mp.suptitle('%s (Figure %i)'%(info,imfig))
 593     ax.plot(v)
 594     plt.show()
 595
 596 .. index:: single: ValuePrinterAndMatPlotterSaver (Observer)
 597
 598 Modèle **ValuePrinterAndMatPlotterSaver**
 599 .........................................
 600
 601 Affiche graphiquement avec Matplolib la valeur courante de la variable, et enregistre la figure dans un fichier du répertoire '/tmp' (figure persistante).
 602
 603 ::
 604
 605     print(str(info)+' '+str(var[-1]))
 606     import numpy, re
 607     import matplotlib.pyplot as plt
 608     v=numpy.array(var[-1], ndmin=1)
 609     global imfig, mp, ax
 610     plt.ion()
 611     try:
 612         imfig+=1
 613         mp.suptitle('%s (Figure %i)'%(info,imfig))
 614     except:
 615         imfig=0
 616         mp = plt.figure()
 617         ax = mp.add_subplot(1, 1, 1)
 618         mp.suptitle('%s (Figure %i)'%(info,imfig))
 619     ax.plot(v)
 620     f='/tmp/figure_%s_%05i.pdf'%(info,imfig)
 621     f=re.sub(r'\s','_',f)
 622     plt.savefig(f)
 623     plt.show()
 624
 625 .. index:: single: ValueSeriePrinterAndMatPlotter (Observer)
 626
 627 Modèle **ValueSeriePrinterAndMatPlotter**
 628 .........................................
 629
 630 Affiche graphiquement avec Matplolib la série des valeurs de la variable (affichage non persistant).
 631
 632 ::
 633
 634     print(str(info)+' '+str(var[:]))
 635     import numpy
 636     import matplotlib.pyplot as plt
 637     v=numpy.array(var[:], ndmin=1)
 638     global imfig, mp, ax
 639     plt.ion()
 640     try:
 641         imfig+=1
 642         mp.suptitle('%s (Figure %i)'%(info,imfig))
 643     except:
 644         imfig=0
 645         mp = plt.figure()
 646         ax = mp.add_subplot(1, 1, 1)
 647         mp.suptitle('%s (Figure %i)'%(info,imfig))
 648         ax.set_xlabel('Step')
 649         ax.set_ylabel('Variable')
 650     ax.plot(v)
 651     plt.show()
 652
 653 .. index:: single: ValueSeriePrinterAndMatPlotterSaver (Observer)
 654
 655 Modèle **ValueSeriePrinterAndMatPlotterSaver**
 656 ..............................................
 657
 658 Affiche graphiquement avec Matplolib la série des valeurs de la variable, et enregistre la figure dans un fichier du répertoire '/tmp' (figure persistante).
 659
 660 ::
 661
 662     print(str(info)+' '+str(var[:]))
 663     import numpy, re
 664     import matplotlib.pyplot as plt
 665     v=numpy.array(var[:], ndmin=1)
 666     global imfig, mp, ax
 667     plt.ion()
 668     try:
 669         imfig+=1
 670         mp.suptitle('%s (Figure %i)'%(info,imfig))
 671     except:
 672         imfig=0
 673         mp = plt.figure()
 674         ax = mp.add_subplot(1, 1, 1)
 675         mp.suptitle('%s (Figure %i)'%(info,imfig))
 676         ax.set_xlabel('Step')
 677         ax.set_ylabel('Variable')
 678     ax.plot(v)
 679     f='/tmp/figure_%s_%05i.pdf'%(info,imfig)
 680     f=re.sub(r'\s','_',f)
 681     plt.savefig(f)
 682     plt.show()
 683
 684 .. index:: single: ValueMean (Observer)
 685
 686 Modèle **ValueMean**
 687 ....................
 688
 689 Imprime sur la sortie standard la moyenne de la valeur courante de la variable.
 690
 691 ::
 692
 693     import numpy
 694     print(str(info)+' '+str(numpy.nanmean(var[-1])))
 695
 696 .. index:: single: ValueStandardError (Observer)
 697
 698 Modèle **ValueStandardError**
 699 .............................
 700
 701 Imprime sur la sortie standard l'écart-type de la valeur courante de la variable.
 702
 703 ::
 704
 705     import numpy
 706     print(str(info)+' '+str(numpy.nanstd(var[-1])))
 707
 708 .. index:: single: ValueVariance (Observer)
 709
 710 Modèle **ValueVariance**
 711 ........................
 712
 713 Imprime sur la sortie standard la variance de la valeur courante de la variable.
 714
 715 ::
 716
 717     import numpy
 718     print(str(info)+' '+str(numpy.nanvar(var[-1])))
 719
 720 .. index:: single: ValueL2Norm (Observer)
 721
 722 Modèle **ValueL2Norm**
 723 ......................
 724
 725 Imprime sur la sortie standard la norme L2 de la valeur courante de la variable.
 726
 727 ::
 728
 729     import numpy
 730     v = numpy.ravel( var[-1] )
 731     print(str(info)+' '+str(float( numpy.linalg.norm(v) )))
 732
 733 .. index:: single: ValueRMS (Observer)
 734
 735 Modèle **ValueRMS**
 736 ...................
 737
 738 Imprime sur la sortie standard la racine de la moyenne des carrés (RMS), ou moyenne quadratique, de la valeur courante de la variable.
 739
 740 ::
 741
 742     import numpy
 743     v = numpy.ravel( var[-1] )
 744     print(str(info)+' '+str(float( numpy.sqrt((1./v.size)*numpy.dot(v,v)) )))