1 #-*-coding:iso-8859-1-*-
3 # Copyright (C) 2008-2012 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
21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 Définit des outils de persistence et d'enregistrement de séries de valeurs
25 pour analyse ultérieure ou utilisation de calcul.
27 __author__ = "Jean-Philippe ARGAUD"
31 from PlatformInfo import PathManagement ; PathManagement()
33 # ==============================================================================
36 Classe générale de persistence définissant les accesseurs nécessaires
39 def __init__(self, name="", unit="", basetype=str):
43 basetype : type de base de l'objet stocké à chaque pas
45 La gestion interne des données est exclusivement basée sur les variables
46 initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
47 objets comme des attributs) :
48 __step : numérotation par défaut du pas courant
49 __basetype : le type de base de chaque valeur, sous la forme d'un type
50 permettant l'instanciation ou le casting Python
51 __steps : les pas de stockage. Par défaut, c'est __step
52 __values : les valeurs de stockage. Par défaut, c'est None
54 self.__name = str(name)
55 self.__unit = str(unit)
58 self.__basetype = basetype
65 self.__dynamic = False
67 self.__dataobservers = []
69 def basetype(self, basetype=None):
71 Renvoie ou met en place le type de base des objets stockés
74 return self.__basetype
76 self.__basetype = basetype
78 def store(self, value=None, step=None, tags={}):
80 Stocke une valeur à un pas. Une instanciation est faite avec le type de
81 base pour stocker l'objet. Si le pas n'est pas fournit, on utilise
82 l'étape de stockage comme valeur de pas.
84 if value is None: raise ValueError("Value argument required")
87 self.__steps.append(step)
89 self.__steps.append(self.__step)
91 self.__values.append(self.__basetype(value))
93 self.__tags.append( dict(tags))
94 self.__tagkeys.update(dict(tags))
96 if self.__dynamic: self.__replots()
97 for hook, parameters, scheduler in self.__dataobservers:
98 if self.__step in scheduler:
99 hook( self, parameters )
103 Renvoie la taille sous forme numpy du dernier objet stocké. Si c'est un
104 objet numpy, renvoie le shape. Si c'est un entier, un flottant, un
105 complexe, renvoie 1. Si c'est une liste ou un dictionnaire, renvoie la
106 longueur. Par défaut, renvoie 1.
108 if len(self.__values) > 0:
109 if self.__basetype in [numpy.matrix, numpy.array]:
110 return self.__values[-1].shape
111 elif self.__basetype in [int, float]:
113 elif self.__basetype in [list, dict]:
114 return (len(self.__values[-1]),)
118 raise ValueError("Object has no shape before its first storage")
122 Renvoie le nombre d'éléments dans un séquence ou la plus grande
123 dimension d'une matrice
125 return max( self.shape() )
127 # ---------------------------------------------------------
128 def itemserie(self, item=None, step=None, tags=None,
131 Les "item" sont les index de la liste des pas de "step". Ils sont
132 renvoyés par cette fonction selon les filtres définis par les mots-clés.
134 Les comportements sont les suivants :
135 - Renvoie par défaut toute la liste des index.
136 - Si l'argument "item" est valide, renvoie uniquement cet index.
137 - Si l'argument "step" existe dans la liste des pas de stockage,
138 renvoie le premier index (si allSteps=False) ou tous les index
139 (si allSteps=True) de ce "step" dans les pas de stockage.
140 - Si l'argument "tags" est un dictionnaire correct, renvoie les
141 index des pas caractérisés par toutes les paires "tag/valeur" des
142 tags indiqués, ou rien sinon.
144 Cette méthode est à vocation interne pour simplifier les accès aux pas
145 par la méthode "stepserie", aux attributs par la méthode "tagserie" et
146 aux valeurs par la méthode "valueserie".
149 # Cherche l'item demandé
150 if item is not None and item < len(self.__steps):
153 # Cherche le ou les items dont le "step" est demandé
154 elif step is not None and step in self.__steps:
159 while self.__steps.index(step,searchFrom) >= 0:
160 searchFrom = self.__steps.index(step,searchFrom)
161 allIndexes.append( searchFrom )
163 except ValueError, e:
167 return [self.__steps.index(step),]
169 # Cherche le ou les items dont les "tags" sont demandés
170 elif tags is not None and type(tags) is dict :
172 for i, attributs in enumerate(self.__tags): # Boucle sur les attributs de chaque pas
173 selection = True # Booleen permettant de traiter la combinaison "ET" des tags
174 for key in tags.keys(): # Boucle sur tous les tags de filtrage
175 if key not in self.__tagkeys.keys(): continue # Passe au suivant s'il n'existe nulle part
176 if not( key in attributs.keys() and attributs[key] == tags[key] ):
180 allIndexes = list(set(allIndexes))
184 # Renvoie par défaut tous les items valides
186 return range(len(self.__steps))
188 def stepserie(self, item=None, step=None, tags=None):
190 Les "step" sont les pas nommés de stockage. Par défaut, s'il ne sont pas
191 définis explicitement, ils sont identiques aux index de stockage. Ils
192 sont renvoyés par cette fonction selon les filtres définis par les
195 Les comportements sont les suivants :
196 - Renvoie par défaut toute la liste des pas.
197 - Si l'argument "item" est valide, renvoie le pas à cet index.
198 - Si l'argument "step" existe dans la liste des pas, le renvoie.
199 - Si l'argument "tags" est un dictionnaire correct, renvoie les pas
200 caractérisés par toutes les paires "tag/valeur" des tags indiqués,
203 if item is not None and item < len(self.__steps):
204 return self.__steps[item]
205 elif step is not None and step in self.__steps:
207 elif tags is not None:
208 allIndexes = self.itemserie(tags = tags)
209 return [self.__steps[index] for index in allIndexes]
213 def valueserie(self, item=None, step=None, tags=None,
216 Les valeurs stockées sont renvoyées par cette fonction selon les filtres
217 définis par les mots-clés.
219 Les comportements sont les suivants :
220 - Renvoie par défaut toute la liste des valeurs.
221 - Si l'argument "item" est valide, renvoie la valeur à cet index.
222 - Si l'argument "step" existe dans la liste des pas de stockage,
223 renvoie la première valeur (si allSteps=False) ou toutes les
224 valeurs (si allSteps=True).
225 - Si l'argument "tags" est un dictionnaire correct, renvoie les
226 valeurs aux pas caractérisés par toutes les paires "tag/valeur"
227 des tags indiqués, ou rien sinon.
229 if item is not None and item < len(self.__values):
230 return self.__values[item]
231 elif step is not None:
232 allIndexes = self.itemserie(step = step, allSteps = allSteps)
234 return [self.__values[index] for index in allIndexes]
236 return self.__values[allIndexes[0]]
237 elif tags is not None:
238 allIndexes = self.itemserie(tags = tags)
239 return [self.__values[index] for index in allIndexes]
243 def tagserie(self, item=None, step=None, tags=None,
244 allSteps=False, withValues=False,
247 Les "tag" sont les attributs nommés, sous forme de paires "clé/valeur",
248 qu'il est possible d'associer avec chaque pas de stockage. Par défaut,
249 s'il ne sont pas définis explicitement, il n'y en a pas. Ils sont
250 renvoyés par cette fonction selon les filtres définis par les mots-clés.
251 On obtient uniquement la liste des clés de tags avec "withValues=False"
252 ou la liste des paires "clé/valeurs" avec "withValues=True".
254 On peut aussi obtenir les valeurs d'un tag satisfaisant aux conditions
255 de filtrage en "item/step/tags" en donnant le nom du tag dans
258 Les comportements sont les suivants :
259 - Renvoie par défaut toute la liste des tags.
260 - Si l'argument "item" est valide, renvoie le tag à cet index.
261 - Si l'argument "step" existe dans la liste des pas de stockage,
262 renvoie les tags du premier pas (si allSteps=False) ou la liste
263 des tags de tous les pas (si allSteps=True).
264 - Si l'argument "tags" est un dictionnaire correct, renvoie les
265 valeurs aux pas caractérisés par toutes les paires "tag/valeur"
266 des tags indiqués, ou rien sinon.
269 # Cherche tous les index satisfaisant les conditions
270 allIndexes = self.itemserie(item = item, step = step, tags = tags, allSteps = allSteps)
272 # Dans le cas où la sortie donne les valeurs d'un "outputTag"
273 if outputTag is not None and type(outputTag) is str :
275 for index in allIndexes:
276 if outputTag in self.__tags[index].keys():
277 outputValues.append( self.__tags[index][outputTag] )
278 outputValues = list(set(outputValues))
282 # Dans le cas où la sortie donne les tags satisfaisants aux conditions
285 return [self.__tags[index] for index in allIndexes]
288 for index in allIndexes:
289 allTags.update( self.__tags[index] )
290 allKeys = allTags.keys()
294 def stepnumber(self):
296 Renvoie le nombre de pas de stockage.
298 return len(self.__steps)
300 # ---------------------------------------------------------
301 # Méthodes d'accès de type dictionnaire
303 return self.stepserie()
306 return self.valueserie()
310 for i in xrange(self.stepnumber()):
311 pairs.append( (self.stepserie(item=i), self.valueserie(item=i)) )
314 # ---------------------------------------------------------
317 Renvoie la série, contenant à chaque pas, la valeur moyenne des données
318 au pas. Il faut que le type de base soit compatible avec les types
322 return [numpy.matrix(item).mean() for item in self.__values]
324 raise TypeError("Base type is incompatible with numpy")
326 def stds(self, ddof=0):
328 Renvoie la série, contenant à chaque pas, l'écart-type des données
329 au pas. Il faut que le type de base soit compatible avec les types
332 ddof : c'est le nombre de degrés de liberté pour le calcul de
333 l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
336 if numpy.version.version >= '1.1.0':
337 return [numpy.matrix(item).std(ddof=ddof) for item in self.__values]
339 return [numpy.matrix(item).std() for item in self.__values]
341 raise TypeError("Base type is incompatible with numpy")
345 Renvoie la série, contenant à chaque pas, la somme des données au pas.
346 Il faut que le type de base soit compatible avec les types élémentaires
350 return [numpy.matrix(item).sum() for item in self.__values]
352 raise TypeError("Base type is incompatible with numpy")
356 Renvoie la série, contenant à chaque pas, le minimum des données au pas.
357 Il faut que le type de base soit compatible avec les types élémentaires
361 return [numpy.matrix(item).min() for item in self.__values]
363 raise TypeError("Base type is incompatible with numpy")
367 Renvoie la série, contenant à chaque pas, la maximum des données au pas.
368 Il faut que le type de base soit compatible avec les types élémentaires
372 return [numpy.matrix(item).max() for item in self.__values]
374 raise TypeError("Base type is incompatible with numpy")
381 geometry = "600x400",
387 # Vérification de la disponibilité du module Gnuplot
390 self.__gnuplot = Gnuplot
392 raise ImportError("The Gnuplot module is required to plot the object.")
394 # Vérification et compléments sur les paramètres d'entrée
396 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
398 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
401 self.__g = self.__gnuplot.Gnuplot() # persist=1
402 self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
403 self.__g('set style data lines')
405 self.__g('set autoscale')
406 self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
407 self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
409 self.__ltitle = ltitle
412 def plots(self, item=None, step=None,
418 geometry = "600x400",
425 Renvoie un affichage de la valeur à chaque pas, si elle est compatible
426 avec un affichage Gnuplot (donc essentiellement un vecteur). Si
427 l'argument "step" existe dans la liste des pas de stockage effectués,
428 renvoie l'affichage de la valeur stockée à ce pas "step". Si l'argument
429 "item" est correct, renvoie l'affichage de la valeur stockée au numéro
430 "item". Par défaut ou en l'absence de "step" ou "item", renvoie un
431 affichage successif de tous les pas.
434 - step : valeur du pas à afficher
435 - item : index de la valeur à afficher
436 - steps : liste unique des pas de l'axe des X, ou None si c'est
437 la numérotation par défaut
438 - title : base du titre général, qui sera automatiquement
439 complétée par la mention du pas
440 - xlabel : label de l'axe des X
441 - ylabel : label de l'axe des Y
442 - ltitle : titre associé au vecteur tracé
443 - geometry : taille en pixels de la fenêtre et position du coin haut
444 gauche, au format X11 : LxH+X+Y (défaut : 600x400)
445 - filename : base de nom de fichier Postscript pour une sauvegarde,
446 qui est automatiquement complétée par le numéro du
447 fichier calculé par incrément simple de compteur
448 - dynamic : effectue un affichage des valeurs à chaque stockage
449 (au-delà du second). La méthode "plots" permet de
450 déclarer l'affichage dynamique, et c'est la méthode
451 "__replots" qui est utilisée pour l'effectuer
452 - persist : booléen indiquant que la fenêtre affichée sera
453 conservée lors du passage au dessin suivant
454 Par défaut, persist = False
455 - pause : booléen indiquant une pause après chaque tracé, et
457 Par défaut, pause = True
460 if not self.__dynamic:
461 self.__preplots(title, xlabel, ylabel, ltitle, geometry, persist, pause )
463 self.__dynamic = True
464 if len(self.__values) == 0: return 0
466 # Tracé du ou des vecteurs demandés
468 if step is not None and step in self.__steps:
469 indexes.append(self.__steps.index(step))
470 elif item is not None and item < len(self.__values):
473 indexes = indexes + range(len(self.__values))
476 for index in indexes:
477 self.__g('set title "'+str(title).encode('ascii','replace')+' (pas '+str(index)+')"')
478 if ( type(steps) is list ) or ( type(steps) is type(numpy.array([])) ):
481 Steps = range(len(self.__values[index]))
483 self.__g.plot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle ) )
487 stepfilename = "%s_%03i.ps"%(filename,i)
488 if os.path.isfile(stepfilename):
489 raise ValueError("Error: a file with this name \"%s\" already exists."%stepfilename)
490 self.__g.hardcopy(filename=stepfilename, color=1)
492 raw_input('Please press return to continue...\n')
496 Affichage dans le cas du suivi dynamique de la variable
498 if self.__dynamic and len(self.__values) < 2: return 0
501 self.__g('set title "'+str(self.__title).encode('ascii','replace'))
502 Steps = range(len(self.__values))
503 self.__g.plot( self.__gnuplot.Data( Steps, self.__values, title=self.__ltitle ) )
506 raw_input('Please press return to continue...\n')
508 # ---------------------------------------------------------
511 Renvoie la moyenne sur toutes les valeurs sans tenir compte de la
512 longueur des pas. Il faut que le type de base soit compatible avec
513 les types élémentaires numpy.
516 if self.__basetype in [int, float]:
517 return float( numpy.array(self.__values).mean() )
519 return numpy.array(self.__values).mean(axis=0)
521 raise TypeError("Base type is incompatible with numpy")
523 def std(self, ddof=0):
525 Renvoie l'écart-type de toutes les valeurs sans tenir compte de la
526 longueur des pas. Il faut que le type de base soit compatible avec
527 les types élémentaires numpy.
529 ddof : c'est le nombre de degrés de liberté pour le calcul de
530 l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
533 if numpy.version.version >= '1.1.0':
534 return numpy.array(self.__values).std(ddof=ddof,axis=0)
536 return numpy.array(self.__values).std(axis=0)
538 raise TypeError("Base type is incompatible with numpy")
542 Renvoie la somme de toutes les valeurs sans tenir compte de la
543 longueur des pas. Il faut que le type de base soit compatible avec
544 les types élémentaires numpy.
547 return numpy.array(self.__values).sum(axis=0)
549 raise TypeError("Base type is incompatible with numpy")
553 Renvoie le minimum de toutes les valeurs sans tenir compte de la
554 longueur des pas. Il faut que le type de base soit compatible avec
555 les types élémentaires numpy.
558 return numpy.array(self.__values).min(axis=0)
560 raise TypeError("Base type is incompatible with numpy")
564 Renvoie le maximum de toutes les valeurs sans tenir compte de la
565 longueur des pas. Il faut que le type de base soit compatible avec
566 les types élémentaires numpy.
569 return numpy.array(self.__values).max(axis=0)
571 raise TypeError("Base type is incompatible with numpy")
575 Renvoie la somme cumulée de toutes les valeurs sans tenir compte de la
576 longueur des pas. Il faut que le type de base soit compatible avec
577 les types élémentaires numpy.
580 return numpy.array(self.__values).cumsum(axis=0)
582 raise TypeError("Base type is incompatible with numpy")
584 # On pourrait aussi utiliser les autres attributs d'une "matrix", comme
593 geometry = "600x400",
599 Renvoie un affichage unique pour l'ensemble des valeurs à chaque pas, si
600 elles sont compatibles avec un affichage Gnuplot (donc essentiellement
601 un vecteur). Si l'argument "step" existe dans la liste des pas de
602 stockage effectués, renvoie l'affichage de la valeur stockée à ce pas
603 "step". Si l'argument "item" est correct, renvoie l'affichage de la
604 valeur stockée au numéro "item".
607 - steps : liste unique des pas de l'axe des X, ou None si c'est
608 la numérotation par défaut
609 - title : base du titre général, qui sera automatiquement
610 complétée par la mention du pas
611 - xlabel : label de l'axe des X
612 - ylabel : label de l'axe des Y
613 - ltitle : titre associé au vecteur tracé
614 - geometry : taille en pixels de la fenêtre et position du coin haut
615 gauche, au format X11 : LxH+X+Y (défaut : 600x400)
616 - filename : nom de fichier Postscript pour une sauvegarde
617 - persist : booléen indiquant que la fenêtre affichée sera
618 conservée lors du passage au dessin suivant
619 Par défaut, persist = False
620 - pause : booléen indiquant une pause après chaque tracé, et
622 Par défaut, pause = True
626 # Vérification de la disponibilité du module Gnuplot
629 self.__gnuplot = Gnuplot
631 raise ImportError("The Gnuplot module is required to plot the object.")
633 # Vérification et compléments sur les paramètres d'entrée
635 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
637 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
640 if ( type(steps) is list ) or ( type(steps) is type(numpy.array([])) ):
643 Steps = range(len(self.__values[0]))
644 self.__g = self.__gnuplot.Gnuplot() # persist=1
645 self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
646 self.__g('set style data lines')
648 self.__g('set autoscale')
649 self.__g('set title "'+str(title).encode('ascii','replace') +'"')
650 self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
651 self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
653 # Tracé du ou des vecteurs demandés
654 indexes = range(len(self.__values))
655 self.__g.plot( self.__gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle+" (pas 0)" ) )
656 for index in indexes:
657 self.__g.replot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle+" (pas %i)"%index ) )
660 self.__g.hardcopy(filename=filename, color=1)
662 raw_input('Please press return to continue...\n')
664 # ---------------------------------------------------------
665 def setDataObserver(self,
667 HookParameters = None,
671 Association à la variable d'un triplet définissant un observer
673 Le Scheduler attendu est une fréquence, une simple liste d'index ou un
677 # Vérification du Scheduler
678 # -------------------------
680 if type(Scheduler) is int: # Considéré comme une fréquence à partir de 0
681 Schedulers = xrange( 0, maxiter, int(Scheduler) )
682 elif type(Scheduler) is xrange: # Considéré comme un itérateur
683 Schedulers = Scheduler
684 elif type(Scheduler) is list: # Considéré comme des index explicites
685 Schedulers = map( long, Scheduler )
686 else: # Dans tous les autres cas, activé par défaut
687 Schedulers = xrange( 0, maxiter )
689 # Stockage interne de l'observer dans la variable
690 # -----------------------------------------------
691 self.__dataobservers.append( [HookFunction, HookParameters, Schedulers] )
693 def removeDataObserver(self,
697 Suppression d'un observer nommé sur la variable.
699 On peut donner dans HookFunction la meme fonction que lors de la
700 définition, ou un simple string qui est le nom de la fonction.
703 if hasattr(HookFunction,"func_name"):
704 name = str( HookFunction.func_name )
705 elif type(HookFunction) is str:
706 name = str( HookFunction )
712 for [hf, hp, hs] in self.__dataobservers:
714 if name is hf.func_name: index_to_remove.append( i )
715 index_to_remove.reverse()
716 for i in index_to_remove:
717 self.__dataobservers.pop( i )
719 # ==============================================================================
720 class OneScalar(Persistence):
722 Classe définissant le stockage d'une valeur unique réelle (float) par pas
724 Le type de base peut être changé par la méthode "basetype", mais il faut que
725 le nouveau type de base soit compatible avec les types par éléments de
726 numpy. On peut même utiliser cette classe pour stocker des vecteurs/listes
727 ou des matrices comme dans les classes suivantes, mais c'est déconseillé
728 pour conserver une signification claire des noms.
730 def __init__(self, name="", unit="", basetype = float):
731 Persistence.__init__(self, name, unit, basetype)
733 class OneVector(Persistence):
735 Classe définissant le stockage d'une liste (list) de valeurs homogènes par
736 hypothèse par pas. Pour éviter les confusions, ne pas utiliser la classe
737 "OneVector" pour des données hétérogènes, mais bien "OneList".
739 def __init__(self, name="", unit="", basetype = list):
740 Persistence.__init__(self, name, unit, basetype)
742 class OneMatrix(Persistence):
744 Classe définissant le stockage d'une matrice de valeurs (numpy.matrix) par
747 def __init__(self, name="", unit="", basetype = numpy.matrix):
748 Persistence.__init__(self, name, unit, basetype)
750 class OneList(Persistence):
752 Classe définissant le stockage d'une liste de valeurs potentiellement
753 hétérogènes (list) par pas. Pour éviter les confusions, ne pas utiliser la
754 classe "OneVector" pour des données hétérogènes, mais bien "OneList".
756 def __init__(self, name="", unit="", basetype = list):
757 Persistence.__init__(self, name, unit, basetype)
759 def NoType( value ): return value
761 class OneNoType(Persistence):
763 Classe définissant le stockage d'un objet sans modification (cast) de type.
764 Attention, selon le véritable type de l'objet stocké à chaque pas, les
765 opérations arithmétiques à base de numpy peuvent être invalides ou donner
766 des résultats inatendus. Cette classe n'est donc à utiliser qu'à bon escient
767 volontairement, et pas du tout par défaut.
769 def __init__(self, name="", unit="", basetype = NoType):
770 Persistence.__init__(self, name, unit, basetype)
772 # ==============================================================================
773 class CompositePersistence:
775 Structure de stockage permettant de rassembler plusieurs objets de
778 Des objets par défaut sont prévus, et des objets supplémentaires peuvent
781 def __init__(self, name="", defaults=True):
785 La gestion interne des données est exclusivement basée sur les variables
786 initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
787 objets comme des attributs) :
788 __StoredObjects : objets de type persistence collectés dans cet objet
790 self.__name = str(name)
792 self.__StoredObjects = {}
794 # Definition des objets par defaut
795 # --------------------------------
797 self.__StoredObjects["Informations"] = OneNoType("Informations")
798 self.__StoredObjects["Background"] = OneVector("Background", basetype=numpy.array)
799 self.__StoredObjects["BackgroundError"] = OneMatrix("BackgroundError")
800 self.__StoredObjects["Observation"] = OneVector("Observation", basetype=numpy.array)
801 self.__StoredObjects["ObservationError"] = OneMatrix("ObservationError")
802 self.__StoredObjects["Analysis"] = OneVector("Analysis", basetype=numpy.array)
803 self.__StoredObjects["AnalysisError"] = OneMatrix("AnalysisError")
804 self.__StoredObjects["Innovation"] = OneVector("Innovation", basetype=numpy.array)
805 self.__StoredObjects["KalmanGainK"] = OneMatrix("KalmanGainK")
806 self.__StoredObjects["OperatorH"] = OneMatrix("OperatorH")
807 self.__StoredObjects["RmsOMA"] = OneScalar("RmsOMA")
808 self.__StoredObjects["RmsOMB"] = OneScalar("RmsOMB")
809 self.__StoredObjects["RmsBMA"] = OneScalar("RmsBMA")
812 def store(self, name=None, value=None, step=None, tags={}):
814 Stockage d'une valeur "value" pour le "step" dans la variable "name".
816 if name is None: raise ValueError("Storable object name is required for storage.")
817 if name not in self.__StoredObjects.keys():
818 raise ValueError("No such name '%s' exists in storable objects."%name)
819 self.__StoredObjects[name].store( value=value, step=step, tags=tags )
821 def add_object(self, name=None, persistenceType=Persistence, basetype=numpy.array ):
823 Ajoute dans les objets stockables un nouvel objet défini par son nom, son
824 type de Persistence et son type de base à chaque pas.
826 if name is None: raise ValueError("Object name is required for adding an object.")
827 if name in self.__StoredObjects.keys():
828 raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name)
829 self.__StoredObjects[name] = persistenceType( name=str(name), basetype=basetype )
831 def get_object(self, name=None ):
833 Renvoie l'objet de type Persistence qui porte le nom demandé.
835 if name is None: raise ValueError("Object name is required for retrieving an object.")
836 if name not in self.__StoredObjects.keys():
837 raise ValueError("No such name '%s' exists in stored objects."%name)
838 return self.__StoredObjects[name]
840 def set_object(self, name=None, objet=None ):
842 Affecte directement un 'objet' qui porte le nom 'name' demandé.
843 Attention, il n'est pas effectué de vérification sur le type, qui doit
844 comporter les méthodes habituelles de Persistence pour que cela
847 if name is None: raise ValueError("Object name is required for setting an object.")
848 if name in self.__StoredObjects.keys():
849 raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name)
850 self.__StoredObjects[name] = objet
852 def del_object(self, name=None ):
854 Supprime un objet de la liste des objets stockables.
856 if name is None: raise ValueError("Object name is required for retrieving an object.")
857 if name not in self.__StoredObjects.keys():
858 raise ValueError("No such name '%s' exists in stored objects."%name)
859 del self.__StoredObjects[name]
861 # ---------------------------------------------------------
862 # Méthodes d'accès de type dictionnaire
863 def __getitem__(self, name=None ):
864 return self.get_object( name )
866 def __setitem__(self, name=None, objet=None ):
867 self.set_object( name, objet )
870 return self.get_stored_objects(hideVoidObjects = False)
873 return self.__StoredObjects.values()
876 return self.__StoredObjects.items()
878 # ---------------------------------------------------------
879 def get_stored_objects(self, hideVoidObjects = False):
880 objs = self.__StoredObjects.keys()
885 if len(self.__StoredObjects[k]) > 0: usedObjs.append( k )
892 # ---------------------------------------------------------
893 def save_composite(self, filename=None, mode="pickle", compress="gzip"):
895 Enregistre l'objet dans le fichier indiqué selon le "mode" demandé,
896 et renvoi le nom du fichier
900 if compress == "gzip":
901 filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl.gz"
902 elif compress == "bzip2":
903 filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl.bz2"
905 filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl"
907 filename = os.path.abspath( filename )
911 if compress == "gzip":
913 output = gzip.open( filename, 'wb')
914 elif compress == "bzip2":
916 output = bz2.BZ2File( filename, 'wb')
918 output = open( filename, 'wb')
919 cPickle.dump(self, output)
922 raise ValueError("Save mode '%s' unknown. Choose another one."%mode)
926 def load_composite(self, filename=None, mode="pickle", compress="gzip"):
928 Recharge un objet composite sauvé en fichier
932 raise ValueError("A file name if requested to load a composite.")
934 filename = os.path.abspath( filename )
938 if compress == "gzip":
940 pkl_file = gzip.open( filename, 'rb')
941 elif compress == "bzip2":
943 pkl_file = bz2.BZ2File( filename, 'rb')
945 pkl_file = open(filename, 'rb')
946 output = cPickle.load(pkl_file)
947 for k in output.keys():
950 raise ValueError("Load mode '%s' unknown. Choose another one."%mode)
954 # ==============================================================================
955 if __name__ == "__main__":
956 print '\n AUTODIAGNOSTIC \n'
958 print "======> Un flottant"
959 OBJET_DE_TEST = OneScalar("My float", unit="cm")
960 OBJET_DE_TEST.store( 5.)
961 OBJET_DE_TEST.store(-5.)
962 OBJET_DE_TEST.store( 1.)
963 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
964 print "Les valeurs :", OBJET_DE_TEST.valueserie()
965 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
966 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
967 print "Valeurs par pas :"
968 print " La moyenne :", OBJET_DE_TEST.means()
969 print " L'écart-type :", OBJET_DE_TEST.stds()
970 print " La somme :", OBJET_DE_TEST.sums()
971 print " Le minimum :", OBJET_DE_TEST.mins()
972 print " Le maximum :", OBJET_DE_TEST.maxs()
973 print "Valeurs globales :"
974 print " La moyenne :", OBJET_DE_TEST.mean()
975 print " L'écart-type :", OBJET_DE_TEST.std()
976 print " La somme :", OBJET_DE_TEST.sum()
977 print " Le minimum :", OBJET_DE_TEST.min()
978 print " Le maximum :", OBJET_DE_TEST.max()
979 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
980 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
981 print "Taille \"len\" :", len(OBJET_DE_TEST)
985 print "======> Un flottant"
986 OBJET_DE_TEST = OneScalar("My float", unit="cm")
987 OBJET_DE_TEST.store( 5., step="azerty")
988 OBJET_DE_TEST.store(-5., step="poiuyt")
989 OBJET_DE_TEST.store( 1., step="azerty")
990 OBJET_DE_TEST.store( 0., step="xxxxxx")
991 OBJET_DE_TEST.store( 5., step="poiuyt")
992 OBJET_DE_TEST.store(-5., step="azerty")
993 OBJET_DE_TEST.store( 1., step="poiuyt")
994 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
995 print "Les valeurs :", OBJET_DE_TEST.valueserie()
996 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
997 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
998 print "Premier index :", OBJET_DE_TEST.valueserie( step = "azerty", allSteps = False )
999 print "Valeurs identiques :", OBJET_DE_TEST.valueserie( step = "azerty", allSteps = True )
1000 print "Premier index :", OBJET_DE_TEST.valueserie( step = "poiuyt", allSteps = False )
1001 print "Valeurs identiques :", OBJET_DE_TEST.valueserie( step = "poiuyt", allSteps = True )
1005 print "======> Un entier"
1006 OBJET_DE_TEST = OneScalar("My int", unit="cm", basetype=int)
1007 OBJET_DE_TEST.store( 5 )
1008 OBJET_DE_TEST.store(-5 )
1009 OBJET_DE_TEST.store( 1.)
1010 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1011 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1012 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1013 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1014 print "Valeurs par pas :"
1015 print " La moyenne :", OBJET_DE_TEST.means()
1016 print " L'écart-type :", OBJET_DE_TEST.stds()
1017 print " La somme :", OBJET_DE_TEST.sums()
1018 print " Le minimum :", OBJET_DE_TEST.mins()
1019 print " Le maximum :", OBJET_DE_TEST.maxs()
1020 print "Valeurs globales :"
1021 print " La moyenne :", OBJET_DE_TEST.mean()
1022 print " L'écart-type :", OBJET_DE_TEST.std()
1023 print " La somme :", OBJET_DE_TEST.sum()
1024 print " Le minimum :", OBJET_DE_TEST.min()
1025 print " Le maximum :", OBJET_DE_TEST.max()
1026 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
1027 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1028 print "Taille \"len\" :", len(OBJET_DE_TEST)
1032 print "======> Un booléen"
1033 OBJET_DE_TEST = OneScalar("My bool", unit="", basetype=bool)
1034 OBJET_DE_TEST.store( True )
1035 OBJET_DE_TEST.store( False )
1036 OBJET_DE_TEST.store( True )
1037 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1038 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1039 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1040 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1041 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1042 print "Taille \"len\" :", len(OBJET_DE_TEST)
1046 print "======> Un vecteur de flottants"
1047 OBJET_DE_TEST = OneVector("My float vector", unit="cm")
1048 OBJET_DE_TEST.store( (5 , -5) )
1049 OBJET_DE_TEST.store( (-5, 5 ) )
1050 OBJET_DE_TEST.store( (1., 1.) )
1051 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1052 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1053 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1054 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1055 print "Valeurs par pas :"
1056 print " La moyenne :", OBJET_DE_TEST.means()
1057 print " L'écart-type :", OBJET_DE_TEST.stds()
1058 print " La somme :", OBJET_DE_TEST.sums()
1059 print " Le minimum :", OBJET_DE_TEST.mins()
1060 print " Le maximum :", OBJET_DE_TEST.maxs()
1061 print "Valeurs globales :"
1062 print " La moyenne :", OBJET_DE_TEST.mean()
1063 print " L'écart-type :", OBJET_DE_TEST.std()
1064 print " La somme :", OBJET_DE_TEST.sum()
1065 print " Le minimum :", OBJET_DE_TEST.min()
1066 print " Le maximum :", OBJET_DE_TEST.max()
1067 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
1068 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1069 print "Taille \"len\" :", len(OBJET_DE_TEST)
1073 print "======> Une liste hétérogène"
1074 OBJET_DE_TEST = OneList("My list", unit="bool/cm")
1075 OBJET_DE_TEST.store( (True , -5) )
1076 OBJET_DE_TEST.store( (False, 5 ) )
1077 OBJET_DE_TEST.store( (True , 1.) )
1078 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1079 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1080 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1081 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1082 print "Valeurs par pas : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens"
1083 print " La moyenne :", OBJET_DE_TEST.means()
1084 print " L'écart-type :", OBJET_DE_TEST.stds()
1085 print " La somme :", OBJET_DE_TEST.sums()
1086 print " Le minimum :", OBJET_DE_TEST.mins()
1087 print " Le maximum :", OBJET_DE_TEST.maxs()
1088 print "Valeurs globales : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens"
1089 print " La moyenne :", OBJET_DE_TEST.mean()
1090 print " L'écart-type :", OBJET_DE_TEST.std()
1091 print " La somme :", OBJET_DE_TEST.sum()
1092 print " Le minimum :", OBJET_DE_TEST.min()
1093 print " Le maximum :", OBJET_DE_TEST.max()
1094 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
1095 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1096 print "Taille \"len\" :", len(OBJET_DE_TEST)
1100 print "======> Utilisation directe de la classe Persistence"
1101 OBJET_DE_TEST = Persistence("My object", unit="", basetype=int )
1102 OBJET_DE_TEST.store( 1 )
1103 OBJET_DE_TEST.store( 3 )
1104 OBJET_DE_TEST.store( 7 )
1105 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1106 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1107 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1108 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1109 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1110 print "Taille \"len\" :", len(OBJET_DE_TEST)
1114 print "======> Utilisation des méthodes d'accès de type dictionnaire"
1115 OBJET_DE_TEST = OneScalar("My int", unit="cm", basetype=int)
1117 OBJET_DE_TEST.store( 7+i )
1118 print "Taille \"len\" :", len(OBJET_DE_TEST)
1119 print "Les pas de stockage :", OBJET_DE_TEST.keys()
1120 print "Les valeurs :", OBJET_DE_TEST.values()
1121 print "Les paires :", OBJET_DE_TEST.items()
1125 print "======> Persistence composite"
1126 OBJET_DE_TEST = CompositePersistence("My CompositePersistence")
1127 print "Objets stockables :", OBJET_DE_TEST.get_stored_objects()
1128 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1129 print "--> Stockage d'une valeur de Background"
1130 OBJET_DE_TEST.store("Background",numpy.zeros(5))
1131 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1132 print "--> Ajout d'un objet nouveau par defaut, de type vecteur numpy par pas"
1133 OBJET_DE_TEST.add_object("ValeursVectorielles")
1134 OBJET_DE_TEST.store("ValeursVectorielles",numpy.zeros(5))
1135 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1136 print "--> Ajout d'un objet nouveau de type liste par pas"
1137 OBJET_DE_TEST.add_object("ValeursList", persistenceType=OneList )
1138 OBJET_DE_TEST.store("ValeursList",range(5))
1139 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1140 print "--> Ajout d'un objet nouveau, de type vecteur string par pas"
1141 OBJET_DE_TEST.add_object("ValeursStr", persistenceType=Persistence, basetype=str )
1142 OBJET_DE_TEST.store("ValeursStr","IGN3")
1143 OBJET_DE_TEST.store("ValeursStr","c021")
1144 print "Les valeurs :", OBJET_DE_TEST.get_object("ValeursStr").valueserie()
1145 print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"].stepserie()
1146 print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"].valueserie()
1147 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1148 print "--> Suppression d'un objet"
1149 OBJET_DE_TEST.del_object("ValeursVectorielles")
1150 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1151 print "--> Enregistrement de l'objet complet de Persistence composite"
1152 OBJET_DE_TEST.save_composite("composite.pkl", compress="None")
1155 print "======> Affichage graphique d'objets stockés"
1156 OBJET_DE_TEST = Persistence("My object", unit="", basetype=numpy.array)
1158 vect1 = [1, 2, 1, 2, 1]
1159 vect2 = [-3, -3, 0, -3, -3]
1160 vect3 = [-1, 1, -5, 1, -1]
1161 vect4 = 100*[0.29, 0.97, 0.73, 0.01, 0.20]
1162 print "Stockage de 3 vecteurs de longueur identique"
1166 print "Affichage graphique de l'ensemble du stockage sur une même image"
1168 title = "Tous les vecteurs",
1169 filename="vecteurs.ps",
1173 print "Stockage d'un quatrième vecteur de longueur différente"
1175 print "Affichage graphique séparé du dernier stockage"
1179 filename = "vecteur",
1183 print "Les images ont été stockées en fichiers Postscript"
1184 print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape()
1185 print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST)
1189 print "======> Affichage graphique dynamique d'objets"
1190 OBJET_DE_TEST = Persistence("My object", unit="", basetype=float)
1194 title = "Valeur suivie",
1199 for i in range(1,11):
1201 print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape()
1202 print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST)
1203 print "Nombre d'objets stockés",OBJET_DE_TEST.stepnumber()
1207 print "======> Affectation simple d'observateurs dynamiques"
1208 def obs(var=None,info=None):
1209 print " ---> Mise en oeuvre de l'observer"
1210 print " var =",var.valueserie(-1)
1211 print " info =",info
1212 OBJET_DE_TEST = Persistence("My object", unit="", basetype=list)
1214 D.setDataObserver( HookFunction = obs )
1217 print "Action de 1 observer sur la variable observée, étape :",i
1218 D.store( [i, i, i] )
1222 print "======> Affectation multiple d'observateurs dynamiques"
1223 def obs(var=None,info=None):
1224 print " ---> Mise en oeuvre de l'observer"
1225 print " var =",var.valueserie(-1)
1226 print " info =",info
1227 def obs_bis(var=None,info=None):
1228 print " ---> Mise en oeuvre de l'observer"
1229 print " var =",var.valueserie(-1)
1230 print " info =",info
1231 OBJET_DE_TEST = Persistence("My object", unit="", basetype=list)
1236 HookParameters = "Premier observer",
1240 Scheduler = xrange(1,3),
1241 HookParameters = "Second observer",
1244 HookFunction = obs_bis,
1245 Scheduler = range(1,3)+range(7,9),
1246 HookParameters = "Troisième observer",
1249 print "Action de 3 observers sur la variable observée, étape :",i
1250 D.store( [i, i, i] )
1251 D.removeDataObserver(
1254 for i in range(5,10):
1255 print "Action d'un seul observer sur la variable observée, étape :",i
1256 D.store( [i, i, i] )
1260 print "======> Utilisation des tags/attributs et stockage puis récupération de l'ensemble"
1261 OBJET_DE_TEST = CompositePersistence("My CompositePersistence", defaults=False)
1262 OBJET_DE_TEST.add_object("My ecarts", basetype = numpy.array)
1264 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5), tags = {"Camp":"Base","Carte":"IGN3","Niveau":1024,"Palier":"Premier"} )
1265 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+1, tags = {"Camp":"Base","Carte":"IGN4","Niveau": 210,"Palier":"Premier"} )
1266 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+2, tags = {"Camp":"Base","Carte":"IGN1","Niveau":1024} )
1267 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+3, tags = {"Camp":"Sommet","Carte":"IGN2","Niveau":4024,"Palier":"Second","FullMap":True} )
1269 print "Les pas de stockage :", OBJET_DE_TEST["My ecarts"].stepserie()
1270 print "Les valeurs :", OBJET_DE_TEST["My ecarts"].valueserie()
1271 print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"].valueserie(1)
1272 print "La dernière valeur :", OBJET_DE_TEST["My ecarts"].valueserie(-1)
1273 print "Liste des attributs :", OBJET_DE_TEST["My ecarts"].tagserie()
1274 print "Taille \"shape\" :", OBJET_DE_TEST["My ecarts"].shape()
1275 print "Taille \"len\" :", len(OBJET_DE_TEST["My ecarts"])
1278 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Palier":"Premier"} )
1279 print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].valueserie( tags={"Palier":"Premier"} )
1281 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1282 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Niveau":1024} )
1283 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base"} )
1284 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"TOTO"} )
1285 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Toto":"Premier"} )
1286 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1289 print "Combinaison 'ET' de plusieurs Tags"
1290 print "Attendu : [0, 1], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base", "Palier":"Premier"} )
1291 print "Attendu : [], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Sommet", "Palier":"Premier"} )
1292 # Attention : {"Camp":"Sommet", "Camp":"Base"} == {"Camp":"Base"}
1293 print "Attendu : [0, 1, 2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Sommet", "Camp":"Base"} )
1294 print "Attendu : [2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1", "Niveau":1024} )
1297 print "Liste des tags pour le pas (item) 1 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 1)
1298 print "Liste des tags pour le pas (item) 2 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 2)
1299 print "Comme le step et l'item sont identiques par défaut, on doit avoir la même chose :"
1300 print "Liste des tags pour le pas (step) 1 :",OBJET_DE_TEST["My ecarts"].tagserie(step = 1)
1301 print "Liste des tags pour le pas (step) 2 :",OBJET_DE_TEST["My ecarts"].tagserie(step = 2)
1303 print "Liste des tags/valeurs pour le pas 1 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 1, withValues=True)
1304 print "Liste des tags/valeurs pour le pas 2 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 2, withValues=True)
1307 print "Liste des valeurs possibles pour 1 tag donné 'Camp' :",OBJET_DE_TEST["My ecarts"].tagserie(outputTag="Camp")
1308 print "Liste des valeurs possibles pour 1 tag donné 'Toto' :",OBJET_DE_TEST["My ecarts"].tagserie(outputTag="Toto")
1309 print "Liste des valeurs possibles pour 1 tag donné 'Niveau' :",OBJET_DE_TEST["My ecarts"].tagserie(outputTag="Niveau")
1312 OBJET_DE_TEST.add_object("My other ecarts", basetype = numpy.array)
1313 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5), tags = {"Camp":"Base","Carte":"IGN3","Niveau":1024,"Palier":"Premier"} )
1314 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+1, tags = {"Camp":"Base","Carte":"IGN4","Niveau": 210,"Palier":"Premier"} )
1315 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+2, tags = {"Camp":"Base","Carte":"IGN1","Niveau":1024} )
1316 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+3, tags = {"Camp":"Sommet","Carte":"IGN2","Niveau":4024,"Palier":"Second"} )
1318 print "Objets présents dans le composite :",OBJET_DE_TEST.get_stored_objects()
1319 fichier = "composite.pkl.gz"
1320 print "Sauvegarde sur \"%s\"..."%fichier
1321 OBJET_DE_TEST.save_composite( fichier )
1322 print "Effacement de l'objet en memoire"
1326 print "Relecture de l'objet sur \"%s\"..."%fichier
1327 OBJET_DE_TEST = CompositePersistence("My CompositePersistence bis", defaults=False)
1328 OBJET_DE_TEST.load_composite( fichier )
1329 print "Objets présents dans le composite :",OBJET_DE_TEST.get_stored_objects()
1330 print "Taille des objets contenus :"
1331 for name in OBJET_DE_TEST.get_stored_objects():
1332 print " Objet \"%s\" : taille unitaire de %i"%(name,len(OBJET_DE_TEST[name]))
1335 print "Les pas de stockage :", OBJET_DE_TEST["My ecarts"].stepserie()
1336 print "Les valeurs :", OBJET_DE_TEST["My ecarts"].valueserie()
1337 print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"].valueserie(1)
1338 print "La dernière valeur :", OBJET_DE_TEST["My ecarts"].valueserie(-1)
1339 print "Liste des attributs :", OBJET_DE_TEST["My ecarts"].tagserie()
1340 print "Taille \"shape\" :", OBJET_DE_TEST["My ecarts"].shape()
1341 print "Taille \"len\" :", len(OBJET_DE_TEST["My ecarts"])
1344 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Palier":"Premier"} )
1345 print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].valueserie( tags={"Palier":"Premier"} )
1347 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1348 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Niveau":1024} )
1349 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base"} )
1350 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"TOTO"} )
1351 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Toto":"Premier"} )
1352 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1354 print "Attributs :", OBJET_DE_TEST["My ecarts"].tagserie()
1355 print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( tags={"Camp":"Base"} )
1356 print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( tags={"Niveau":4024} )
1358 print "Attributs et valeurs :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True )
1359 print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, tags={"Camp":"Base"} )
1360 print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, tags={"Niveau":4024} )
1362 print "Valeur d'attribut pour un tag donné 'BU' :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau" )
1363 print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", tags={"Camp":"Base"} )
1364 print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", tags={"Palier":"Second"} )
1365 print "Valeur d'attribut pour un tag donné 'Camp' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Camp", tags={"Palier":"Premier"} )
1366 print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier"} )
1367 print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier","Niveau":4024} )
1368 print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier","Niveau":210} )