1 #-*-coding:iso-8859-1-*-
3 # Copyright (C) 2008-2010 EDF R&D
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU Lesser General Public
7 # License as published by the Free Software Foundation; either
8 # version 2.1 of the License.
10 # This library is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 # Lesser General Public License for more details.
15 # You should have received a copy of the GNU Lesser General Public
16 # License along with this library; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 Définit des outils de persistence et d'enregistrement de séries de valeurs
23 pour analyse ultérieure ou utilisation de calcul.
25 __author__ = "Jean-Philippe ARGAUD - Mars 2008"
29 from PlatformInfo import PathManagement ; PathManagement()
31 # ==============================================================================
34 Classe générale de persistence définissant les accesseurs nécessaires
37 def __init__(self, name="", unit="", basetype=str):
41 basetype : type de base de l'objet stocké à chaque pas
43 La gestion interne des données est exclusivement basée sur les variables
44 initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
45 objets comme des attributs) :
46 __step : numérotation par défaut du pas courant
47 __basetype : le type de base de chaque valeur, sous la forme d'un type
48 permettant l'instanciation ou le casting Python
49 __steps : les pas de stockage. Par défaut, c'est __step
50 __values : les valeurs de stockage. Par défaut, c'est None
52 self.__name = str(name)
53 self.__unit = str(unit)
56 self.__basetype = basetype
61 self.__dynamic = False
63 self.__dataobservers = []
65 def basetype(self, basetype=None):
67 Renvoie ou met en place le type de base des objets stockés
70 return self.__basetype
72 self.__basetype = basetype
74 def store(self, value=None, step=None):
76 Stocke une valeur à un pas. Une instanciation est faite avec le type de
77 base pour stocker l'objet. Si le pas n'est pas fournit, on utilise
78 l'étape de stockage comme valeur de pas.
80 if value is None: raise ValueError("Value argument required")
83 self.__steps.append(step)
85 self.__steps.append(self.__step)
87 self.__values.append(self.__basetype(value))
89 if self.__dynamic: self.__replot()
90 for hook, parameters, scheduler in self.__dataobservers:
91 if self.__step in scheduler:
92 hook( self, parameters )
96 Renvoie la taille sous forme numpy du dernier objet stocké. Si c'est un
97 objet numpy, renvoie le shape. Si c'est un entier, un flottant, un
98 complexe, renvoie 1. Si c'est une liste ou un dictionnaire, renvoie la
99 longueur. Par défaut, renvoie 1.
101 if len(self.__values) > 0:
102 if self.__basetype in [numpy.matrix, numpy.array]:
103 return self.__values[-1].shape
104 elif self.__basetype in [int, float]:
106 elif self.__basetype in [list, dict]:
107 return (len(self.__values[-1]),)
111 raise ValueError("Object has no shape before its first storage")
115 Renvoie le nombre d'éléments dans un séquence ou la plus grande
116 dimension d'une matrice
118 return max( self.shape() )
120 # ---------------------------------------------------------
121 def stepserie(self, item=None, step=None):
123 Renvoie par défaut toute la liste des pas de temps. Si l'argument "step"
124 existe dans la liste des pas de stockage effectués, renvoie ce pas
125 "step". Si l'argument "item" est correct, renvoie le pas stockée au
128 if step is not None and step in self.__steps:
130 elif item is not None and item < len(self.__steps):
131 return self.__steps[item]
135 def valueserie(self, item=None, step=None):
137 Renvoie par défaut toute la liste des valeurs/objets. Si l'argument
138 "step" existe dans la liste des pas de stockage effectués, renvoie la
139 valeur stockée à ce pas "step". Si l'argument "item" est correct,
140 renvoie la valeur stockée au numéro "item".
142 if step is not None and step in self.__steps:
143 index = self.__steps.index(step)
144 return self.__values[index]
145 elif item is not None and item < len(self.__values):
146 return self.__values[item]
150 def stepnumber(self):
152 Renvoie le nombre de pas de stockage.
154 return len(self.__steps)
156 # ---------------------------------------------------------
159 Renvoie la valeur moyenne des données à chaque pas. Il faut que le type
160 de base soit compatible avec les types élémentaires numpy.
163 return [numpy.matrix(item).mean() for item in self.__values]
165 raise TypeError("Base type is incompatible with numpy")
167 def std(self, ddof=0):
169 Renvoie l'écart-type des données à chaque pas. Il faut que le type de
170 base soit compatible avec les types élémentaires numpy.
172 ddof : c'est le nombre de degrés de liberté pour le calcul de
173 l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
176 if numpy.version.version >= '1.1.0':
177 return [numpy.matrix(item).std(ddof=ddof) for item in self.__values]
179 return [numpy.matrix(item).std() for item in self.__values]
181 raise TypeError("Base type is incompatible with numpy")
185 Renvoie la somme des données à chaque pas. Il faut que le type de
186 base soit compatible avec les types élémentaires numpy.
189 return [numpy.matrix(item).sum() for item in self.__values]
191 raise TypeError("Base type is incompatible with numpy")
195 Renvoie le minimum des données à chaque pas. Il faut que le type de
196 base soit compatible avec les types élémentaires numpy.
199 return [numpy.matrix(item).min() for item in self.__values]
201 raise TypeError("Base type is incompatible with numpy")
205 Renvoie le maximum des données à chaque pas. Il faut que le type de
206 base soit compatible avec les types élémentaires numpy.
209 return [numpy.matrix(item).max() for item in self.__values]
211 raise TypeError("Base type is incompatible with numpy")
218 geometry = "600x400",
224 # Vérification de la disponibilité du module Gnuplot
227 self.__gnuplot = Gnuplot
229 raise ImportError("The Gnuplot module is required to plot the object.")
231 # Vérification et compléments sur les paramètres d'entrée
233 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
235 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
238 self.__g = self.__gnuplot.Gnuplot() # persist=1
239 self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
240 self.__g('set style data lines')
242 self.__g('set autoscale')
243 self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
244 self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
246 self.__ltitle = ltitle
249 def plot(self, item=None, step=None,
255 geometry = "600x400",
262 Renvoie un affichage de la valeur à chaque pas, si elle est compatible
263 avec un affichage Gnuplot (donc essentiellement un vecteur). Si
264 l'argument "step" existe dans la liste des pas de stockage effectués,
265 renvoie l'affichage de la valeur stockée à ce pas "step". Si l'argument
266 "item" est correct, renvoie l'affichage de la valeur stockée au numéro
267 "item". Par défaut ou en l'absence de "step" ou "item", renvoie un
268 affichage successif de tous les pas.
271 - step : valeur du pas à afficher
272 - item : index de la valeur à afficher
273 - steps : liste unique des pas de l'axe des X, ou None si c'est
274 la numérotation par défaut
275 - title : base du titre général, qui sera automatiquement
276 complétée par la mention du pas
277 - xlabel : label de l'axe des X
278 - ylabel : label de l'axe des Y
279 - ltitle : titre associé au vecteur tracé
280 - geometry : taille en pixels de la fenêtre et position du coin haut
281 gauche, au format X11 : LxH+X+Y (défaut : 600x400)
282 - filename : base de nom de fichier Postscript pour une sauvegarde,
283 qui est automatiquement complétée par le numéro du
284 fichier calculé par incrément simple de compteur
285 - dynamic : effectue un affichage des valeurs à chaque stockage
286 (au-delà du second) La méthode "plot" permet de déclarer
287 l'affichage dynamique, et c'est la méthode "__replot"
288 qui est utilisée pour l'effectuer
289 - persist : booléen indiquant que la fenêtre affichée sera
290 conservée lors du passage au dessin suivant
291 Par défaut, persist = False
292 - pause : booléen indiquant une pause après chaque tracé, et
294 Par défaut, pause = True
297 if not self.__dynamic:
298 self.__preplot(title, xlabel, ylabel, ltitle, geometry, persist, pause )
300 self.__dynamic = True
301 if len(self.__values) == 0: return 0
303 # Tracé du ou des vecteurs demandés
305 if step is not None and step in self.__steps:
306 indexes.append(self.__steps.index(step))
307 elif item is not None and item < len(self.__values):
310 indexes = indexes + range(len(self.__values))
313 for index in indexes:
314 self.__g('set title "'+str(title).encode('ascii','replace')+' (pas '+str(index)+')"')
315 if ( type(steps) is type([]) ) or ( type(steps) is type(numpy.array([])) ):
318 Steps = range(len(self.__values[index]))
320 self.__g.plot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle ) )
324 stepfilename = "%s_%03i.ps"%(filename,i)
325 if os.path.isfile(stepfilename):
326 raise ValueError("Error: a file with this name \"%s\" already exists."%stepfilename)
327 self.__g.hardcopy(filename=stepfilename, color=1)
329 raw_input('Please press return to continue...\n')
333 Affichage dans le cas du suivi dynamique de la variable
335 if self.__dynamic and len(self.__values) < 2: return 0
338 self.__g('set title "'+str(self.__title).encode('ascii','replace'))
339 Steps = range(len(self.__values))
340 self.__g.plot( self.__gnuplot.Data( Steps, self.__values, title=self.__ltitle ) )
343 raw_input('Please press return to continue...\n')
345 # ---------------------------------------------------------
348 Renvoie la moyenne sur toutes les valeurs sans tenir compte de la
349 longueur des pas. Il faut que le type de base soit compatible avec
350 les types élémentaires numpy.
353 return numpy.matrix(self.__values).mean()
355 raise TypeError("Base type is incompatible with numpy")
357 def stepstd(self, ddof=0):
359 Renvoie l'écart-type de toutes les valeurs sans tenir compte de la
360 longueur des pas. Il faut que le type de base soit compatible avec
361 les types élémentaires numpy.
363 ddof : c'est le nombre de degrés de liberté pour le calcul de
364 l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
367 if numpy.version.version >= '1.1.0':
368 return numpy.matrix(self.__values).std(ddof=ddof)
370 return numpy.matrix(self.__values).std()
372 raise TypeError("Base type is incompatible with numpy")
376 Renvoie la somme de toutes les valeurs sans tenir compte de la
377 longueur des pas. Il faut que le type de base soit compatible avec
378 les types élémentaires numpy.
381 return numpy.matrix(self.__values).sum()
383 raise TypeError("Base type is incompatible with numpy")
387 Renvoie le minimum de toutes les valeurs sans tenir compte de la
388 longueur des pas. Il faut que le type de base soit compatible avec
389 les types élémentaires numpy.
392 return numpy.matrix(self.__values).min()
394 raise TypeError("Base type is incompatible with numpy")
398 Renvoie le maximum de toutes les valeurs sans tenir compte de la
399 longueur des pas. Il faut que le type de base soit compatible avec
400 les types élémentaires numpy.
403 return numpy.matrix(self.__values).max()
405 raise TypeError("Base type is incompatible with numpy")
409 Renvoie la somme cumulée de toutes les valeurs sans tenir compte de la
410 longueur des pas. Il faut que le type de base soit compatible avec
411 les types élémentaires numpy.
414 return numpy.matrix(self.__values).cumsum(axis=0)
416 raise TypeError("Base type is incompatible with numpy")
418 # On pourrait aussi utiliser les autres attributs d'une "matrix", comme
427 geometry = "600x400",
433 Renvoie un affichage unique pour l'ensemble des valeurs à chaque pas, si
434 elles sont compatibles avec un affichage Gnuplot (donc essentiellement
435 un vecteur). Si l'argument "step" existe dans la liste des pas de
436 stockage effectués, renvoie l'affichage de la valeur stockée à ce pas
437 "step". Si l'argument "item" est correct, renvoie l'affichage de la
438 valeur stockée au numéro "item".
441 - steps : liste unique des pas de l'axe des X, ou None si c'est
442 la numérotation par défaut
443 - title : base du titre général, qui sera automatiquement
444 complétée par la mention du pas
445 - xlabel : label de l'axe des X
446 - ylabel : label de l'axe des Y
447 - ltitle : titre associé au vecteur tracé
448 - geometry : taille en pixels de la fenêtre et position du coin haut
449 gauche, au format X11 : LxH+X+Y (défaut : 600x400)
450 - filename : nom de fichier Postscript pour une sauvegarde
451 - persist : booléen indiquant que la fenêtre affichée sera
452 conservée lors du passage au dessin suivant
453 Par défaut, persist = False
454 - pause : booléen indiquant une pause après chaque tracé, et
456 Par défaut, pause = True
460 # Vérification de la disponibilité du module Gnuplot
463 self.__gnuplot = Gnuplot
465 raise ImportError("The Gnuplot module is required to plot the object.")
467 # Vérification et compléments sur les paramètres d'entrée
469 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
471 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
474 if ( type(steps) is type([]) ) or ( type(steps) is type(numpy.array([])) ):
477 Steps = range(len(self.__values[0]))
478 self.__g = self.__gnuplot.Gnuplot() # persist=1
479 self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
480 self.__g('set style data lines')
482 self.__g('set autoscale')
483 self.__g('set title "'+str(title).encode('ascii','replace') +'"')
484 self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
485 self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
487 # Tracé du ou des vecteurs demandés
488 indexes = range(len(self.__values))
489 self.__g.plot( self.__gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle+" (pas 0)" ) )
490 for index in indexes:
491 self.__g.replot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle+" (pas %i)"%index ) )
494 self.__g.hardcopy(filename=filename, color=1)
496 raw_input('Please press return to continue...\n')
498 # ---------------------------------------------------------
499 def setDataObserver(self,
501 HookParameters = None,
505 Méthode d'association à la variable d'un triplet définissant un observer
507 Le Scheduler attendu est une fréquence, une simple liste d'index ou un
511 # Vérification du Scheduler
512 # -------------------------
514 if type(Scheduler) is int: # Considéré comme une fréquence à partir de 0
515 Schedulers = xrange( 0, maxiter, int(Scheduler) )
516 elif type(Scheduler) is xrange: # Considéré comme un itérateur
517 Schedulers = Scheduler
518 elif type(Scheduler) is list: # Considéré comme des index explicites
519 Schedulers = map( long, Scheduler )
520 else: # Dans tous les autres cas, activé par défaut
521 Schedulers = xrange( 0, maxiter )
523 # Stockage interne de l'observer dans la variable
524 # -----------------------------------------------
525 self.__dataobservers.append( [HookFunction, HookParameters, Schedulers] )
527 # ==============================================================================
528 class OneScalar(Persistence):
530 Classe définissant le stockage d'une valeur unique réelle (float) par pas
532 Le type de base peut être changé par la méthode "basetype", mais il faut que
533 le nouveau type de base soit compatible avec les types par éléments de
534 numpy. On peut même utiliser cette classe pour stocker des vecteurs/listes
535 ou des matrices comme dans les classes suivantes, mais c'est déconseillé
536 pour conserver une signification claire des noms.
538 def __init__(self, name="", unit="", basetype = float):
539 Persistence.__init__(self, name, unit, basetype)
541 class OneVector(Persistence):
543 Classe définissant le stockage d'une liste (list) de valeurs homogènes par
544 hypothèse par pas. Pour éviter les confusions, ne pas utiliser la classe
545 "OneVector" pour des données hétérogènes, mais bien "OneList".
547 def __init__(self, name="", unit="", basetype = list):
548 Persistence.__init__(self, name, unit, basetype)
550 class OneMatrix(Persistence):
552 Classe définissant le stockage d'une matrice de valeurs (numpy.matrix) par
555 def __init__(self, name="", unit="", basetype = numpy.matrix):
556 Persistence.__init__(self, name, unit, basetype)
558 class OneList(Persistence):
560 Classe définissant le stockage d'une liste de valeurs potentiellement
561 hétérogènes (list) par pas. Pour éviter les confusions, ne pas utiliser la
562 classe "OneVector" pour des données hétérogènes, mais bien "OneList".
564 def __init__(self, name="", unit="", basetype = list):
565 Persistence.__init__(self, name, unit, basetype)
567 # ==============================================================================
568 if __name__ == "__main__":
569 print '\n AUTODIAGNOSTIC \n'
571 print "======> Un flottant"
572 OBJET_DE_TEST = OneScalar("My float", unit="cm")
573 OBJET_DE_TEST.store( 5.)
574 OBJET_DE_TEST.store(-5.)
575 OBJET_DE_TEST.store( 1.)
576 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
577 print "Les valeurs :", OBJET_DE_TEST.valueserie()
578 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
579 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
580 print "Valeurs par pas :"
581 print " La moyenne :", OBJET_DE_TEST.mean()
582 print " L'écart-type :", OBJET_DE_TEST.std()
583 print " La somme :", OBJET_DE_TEST.sum()
584 print " Le minimum :", OBJET_DE_TEST.min()
585 print " Le maximum :", OBJET_DE_TEST.max()
586 print "Valeurs globales :"
587 print " La moyenne :", OBJET_DE_TEST.stepmean()
588 print " L'écart-type :", OBJET_DE_TEST.stepstd()
589 print " La somme :", OBJET_DE_TEST.stepsum()
590 print " Le minimum :", OBJET_DE_TEST.stepmin()
591 print " Le maximum :", OBJET_DE_TEST.stepmax()
592 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
593 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
594 print "Taille \"len\" :", len(OBJET_DE_TEST)
598 print "======> Un entier"
599 OBJET_DE_TEST = OneScalar("My int", unit="cm", basetype=int)
600 OBJET_DE_TEST.store( 5 )
601 OBJET_DE_TEST.store(-5 )
602 OBJET_DE_TEST.store( 1.)
603 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
604 print "Les valeurs :", OBJET_DE_TEST.valueserie()
605 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
606 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
607 print "Valeurs par pas :"
608 print " La moyenne :", OBJET_DE_TEST.mean()
609 print " L'écart-type :", OBJET_DE_TEST.std()
610 print " La somme :", OBJET_DE_TEST.sum()
611 print " Le minimum :", OBJET_DE_TEST.min()
612 print " Le maximum :", OBJET_DE_TEST.max()
613 print "Valeurs globales :"
614 print " La moyenne :", OBJET_DE_TEST.stepmean()
615 print " L'écart-type :", OBJET_DE_TEST.stepstd()
616 print " La somme :", OBJET_DE_TEST.stepsum()
617 print " Le minimum :", OBJET_DE_TEST.stepmin()
618 print " Le maximum :", OBJET_DE_TEST.stepmax()
619 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
620 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
621 print "Taille \"len\" :", len(OBJET_DE_TEST)
625 print "======> Un booléen"
626 OBJET_DE_TEST = OneScalar("My bool", unit="", basetype=bool)
627 OBJET_DE_TEST.store( True )
628 OBJET_DE_TEST.store( False )
629 OBJET_DE_TEST.store( True )
630 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
631 print "Les valeurs :", OBJET_DE_TEST.valueserie()
632 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
633 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
634 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
635 print "Taille \"len\" :", len(OBJET_DE_TEST)
639 print "======> Un vecteur de flottants"
640 OBJET_DE_TEST = OneVector("My float vector", unit="cm")
641 OBJET_DE_TEST.store( (5 , -5) )
642 OBJET_DE_TEST.store( (-5, 5 ) )
643 OBJET_DE_TEST.store( (1., 1.) )
644 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
645 print "Les valeurs :", OBJET_DE_TEST.valueserie()
646 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
647 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
648 print "Valeurs par pas :"
649 print " La moyenne :", OBJET_DE_TEST.mean()
650 print " L'écart-type :", OBJET_DE_TEST.std()
651 print " La somme :", OBJET_DE_TEST.sum()
652 print " Le minimum :", OBJET_DE_TEST.min()
653 print " Le maximum :", OBJET_DE_TEST.max()
654 print "Valeurs globales :"
655 print " La moyenne :", OBJET_DE_TEST.stepmean()
656 print " L'écart-type :", OBJET_DE_TEST.stepstd()
657 print " La somme :", OBJET_DE_TEST.stepsum()
658 print " Le minimum :", OBJET_DE_TEST.stepmin()
659 print " Le maximum :", OBJET_DE_TEST.stepmax()
660 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
661 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
662 print "Taille \"len\" :", len(OBJET_DE_TEST)
666 print "======> Une liste hétérogène"
667 OBJET_DE_TEST = OneList("My list", unit="bool/cm")
668 OBJET_DE_TEST.store( (True , -5) )
669 OBJET_DE_TEST.store( (False, 5 ) )
670 OBJET_DE_TEST.store( (True , 1.) )
671 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
672 print "Les valeurs :", OBJET_DE_TEST.valueserie()
673 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
674 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
675 print "Valeurs par pas : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens"
676 print " La moyenne :", OBJET_DE_TEST.mean()
677 print " L'écart-type :", OBJET_DE_TEST.std()
678 print " La somme :", OBJET_DE_TEST.sum()
679 print " Le minimum :", OBJET_DE_TEST.min()
680 print " Le maximum :", OBJET_DE_TEST.max()
681 print "Valeurs globales : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens"
682 print " La moyenne :", OBJET_DE_TEST.stepmean()
683 print " L'écart-type :", OBJET_DE_TEST.stepstd()
684 print " La somme :", OBJET_DE_TEST.stepsum()
685 print " Le minimum :", OBJET_DE_TEST.stepmin()
686 print " Le maximum :", OBJET_DE_TEST.stepmax()
687 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
688 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
689 print "Taille \"len\" :", len(OBJET_DE_TEST)
693 print "======> Utilisation directe de la classe Persistence"
694 OBJET_DE_TEST = Persistence("My object", unit="", basetype=int )
695 OBJET_DE_TEST.store( 1 )
696 OBJET_DE_TEST.store( 3 )
697 OBJET_DE_TEST.store( 7 )
698 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
699 print "Les valeurs :", OBJET_DE_TEST.valueserie()
700 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
701 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
702 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
703 print "Taille \"len\" :", len(OBJET_DE_TEST)
707 print "======> Affichage d'objets stockés"
708 OBJET_DE_TEST = Persistence("My object", unit="", basetype=numpy.array)
710 vect1 = [1, 2, 1, 2, 1]
711 vect2 = [-3, -3, 0, -3, -3]
712 vect3 = [-1, 1, -5, 1, -1]
713 vect4 = 100*[0.29, 0.97, 0.73, 0.01, 0.20]
714 print "Stockage de 3 vecteurs de longueur identique"
718 print "Affichage de l'ensemble du stockage sur une même image"
720 title = "Tous les vecteurs",
721 filename="vecteurs.ps",
725 print "Stockage d'un quatrième vecteur de longueur différente"
727 print "Affichage séparé du dernier stockage"
731 filename = "vecteur",
735 print "Les images ont été stockées en fichiers Postscript"
736 print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape()
737 print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST)
741 print "======> Affichage dynamique d'objets"
742 OBJET_DE_TEST = Persistence("My object", unit="", basetype=float)
746 title = "Valeur suivie",
751 for i in range(1,11):
753 print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape()
754 print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST)
755 print "Nombre d'objets stockés",OBJET_DE_TEST.stepnumber()
759 print "======> Affectation simple d'observateurs dynamiques"
760 def obs(var=None,info=None):
761 print " ---> Mise en oeuvre de l'observer"
762 print " var =",var.valueserie(-1)
764 OBJET_DE_TEST = Persistence("My object", unit="", basetype=list)
766 D.setDataObserver( HookFunction = obs )
769 print "Action de 1 observer sur la variable observée, étape :",i
774 print "======> Affectation multiple d'observateurs dynamiques"
775 def obs(var=None,info=None):
776 print " ---> Mise en oeuvre de l'observer"
777 print " var =",var.valueserie(-1)
779 OBJET_DE_TEST = Persistence("My object", unit="", basetype=list)
784 HookParameters = "Second observer",
788 Scheduler = xrange(1,3),
789 HookParameters = "Troisième observer",
793 print "Action de 2 observers sur la variable observée, étape :",i