1 #-*-coding:iso-8859-1-*-
3 # Copyright (C) 2008-2011 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.__replot()
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 valeur moyenne des données à chaque pas. Il faut que le type
318 de base soit compatible avec les types élémentaires numpy.
321 return [numpy.matrix(item).mean() for item in self.__values]
323 raise TypeError("Base type is incompatible with numpy")
325 def std(self, ddof=0):
327 Renvoie l'écart-type des données à chaque pas. Il faut que le type de
328 base soit compatible avec les types élémentaires numpy.
330 ddof : c'est le nombre de degrés de liberté pour le calcul de
331 l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
334 if numpy.version.version >= '1.1.0':
335 return [numpy.matrix(item).std(ddof=ddof) for item in self.__values]
337 return [numpy.matrix(item).std() for item in self.__values]
339 raise TypeError("Base type is incompatible with numpy")
343 Renvoie la somme des données à chaque pas. Il faut que le type de
344 base soit compatible avec les types élémentaires numpy.
347 return [numpy.matrix(item).sum() for item in self.__values]
349 raise TypeError("Base type is incompatible with numpy")
353 Renvoie le minimum des données à chaque pas. Il faut que le type de
354 base soit compatible avec les types élémentaires numpy.
357 return [numpy.matrix(item).min() for item in self.__values]
359 raise TypeError("Base type is incompatible with numpy")
363 Renvoie le maximum des données à chaque pas. Il faut que le type de
364 base soit compatible avec les types élémentaires numpy.
367 return [numpy.matrix(item).max() for item in self.__values]
369 raise TypeError("Base type is incompatible with numpy")
376 geometry = "600x400",
382 # Vérification de la disponibilité du module Gnuplot
385 self.__gnuplot = Gnuplot
387 raise ImportError("The Gnuplot module is required to plot the object.")
389 # Vérification et compléments sur les paramètres d'entrée
391 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
393 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
396 self.__g = self.__gnuplot.Gnuplot() # persist=1
397 self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
398 self.__g('set style data lines')
400 self.__g('set autoscale')
401 self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
402 self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
404 self.__ltitle = ltitle
407 def plot(self, item=None, step=None,
413 geometry = "600x400",
420 Renvoie un affichage de la valeur à chaque pas, si elle est compatible
421 avec un affichage Gnuplot (donc essentiellement un vecteur). Si
422 l'argument "step" existe dans la liste des pas de stockage effectués,
423 renvoie l'affichage de la valeur stockée à ce pas "step". Si l'argument
424 "item" est correct, renvoie l'affichage de la valeur stockée au numéro
425 "item". Par défaut ou en l'absence de "step" ou "item", renvoie un
426 affichage successif de tous les pas.
429 - step : valeur du pas à afficher
430 - item : index de la valeur à afficher
431 - steps : liste unique des pas de l'axe des X, ou None si c'est
432 la numérotation par défaut
433 - title : base du titre général, qui sera automatiquement
434 complétée par la mention du pas
435 - xlabel : label de l'axe des X
436 - ylabel : label de l'axe des Y
437 - ltitle : titre associé au vecteur tracé
438 - geometry : taille en pixels de la fenêtre et position du coin haut
439 gauche, au format X11 : LxH+X+Y (défaut : 600x400)
440 - filename : base de nom de fichier Postscript pour une sauvegarde,
441 qui est automatiquement complétée par le numéro du
442 fichier calculé par incrément simple de compteur
443 - dynamic : effectue un affichage des valeurs à chaque stockage
444 (au-delà du second) La méthode "plot" permet de déclarer
445 l'affichage dynamique, et c'est la méthode "__replot"
446 qui est utilisée pour l'effectuer
447 - persist : booléen indiquant que la fenêtre affichée sera
448 conservée lors du passage au dessin suivant
449 Par défaut, persist = False
450 - pause : booléen indiquant une pause après chaque tracé, et
452 Par défaut, pause = True
455 if not self.__dynamic:
456 self.__preplot(title, xlabel, ylabel, ltitle, geometry, persist, pause )
458 self.__dynamic = True
459 if len(self.__values) == 0: return 0
461 # Tracé du ou des vecteurs demandés
463 if step is not None and step in self.__steps:
464 indexes.append(self.__steps.index(step))
465 elif item is not None and item < len(self.__values):
468 indexes = indexes + range(len(self.__values))
471 for index in indexes:
472 self.__g('set title "'+str(title).encode('ascii','replace')+' (pas '+str(index)+')"')
473 if ( type(steps) is list ) or ( type(steps) is type(numpy.array([])) ):
476 Steps = range(len(self.__values[index]))
478 self.__g.plot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle ) )
482 stepfilename = "%s_%03i.ps"%(filename,i)
483 if os.path.isfile(stepfilename):
484 raise ValueError("Error: a file with this name \"%s\" already exists."%stepfilename)
485 self.__g.hardcopy(filename=stepfilename, color=1)
487 raw_input('Please press return to continue...\n')
491 Affichage dans le cas du suivi dynamique de la variable
493 if self.__dynamic and len(self.__values) < 2: return 0
496 self.__g('set title "'+str(self.__title).encode('ascii','replace'))
497 Steps = range(len(self.__values))
498 self.__g.plot( self.__gnuplot.Data( Steps, self.__values, title=self.__ltitle ) )
501 raw_input('Please press return to continue...\n')
503 # ---------------------------------------------------------
506 Renvoie la moyenne sur toutes les valeurs sans tenir compte de la
507 longueur des pas. Il faut que le type de base soit compatible avec
508 les types élémentaires numpy.
511 return numpy.matrix(self.__values).mean()
513 raise TypeError("Base type is incompatible with numpy")
515 def stepstd(self, ddof=0):
517 Renvoie l'écart-type de toutes les valeurs sans tenir compte de la
518 longueur des pas. Il faut que le type de base soit compatible avec
519 les types élémentaires numpy.
521 ddof : c'est le nombre de degrés de liberté pour le calcul de
522 l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
525 if numpy.version.version >= '1.1.0':
526 return numpy.matrix(self.__values).std(ddof=ddof)
528 return numpy.matrix(self.__values).std()
530 raise TypeError("Base type is incompatible with numpy")
534 Renvoie la somme de toutes les valeurs sans tenir compte de la
535 longueur des pas. Il faut que le type de base soit compatible avec
536 les types élémentaires numpy.
539 return numpy.matrix(self.__values).sum()
541 raise TypeError("Base type is incompatible with numpy")
545 Renvoie le minimum de toutes les valeurs sans tenir compte de la
546 longueur des pas. Il faut que le type de base soit compatible avec
547 les types élémentaires numpy.
550 return numpy.matrix(self.__values).min()
552 raise TypeError("Base type is incompatible with numpy")
556 Renvoie le maximum de toutes les valeurs sans tenir compte de la
557 longueur des pas. Il faut que le type de base soit compatible avec
558 les types élémentaires numpy.
561 return numpy.matrix(self.__values).max()
563 raise TypeError("Base type is incompatible with numpy")
567 Renvoie la somme cumulée de toutes les valeurs sans tenir compte de la
568 longueur des pas. Il faut que le type de base soit compatible avec
569 les types élémentaires numpy.
572 return numpy.matrix(self.__values).cumsum(axis=0)
574 raise TypeError("Base type is incompatible with numpy")
576 # On pourrait aussi utiliser les autres attributs d'une "matrix", comme
585 geometry = "600x400",
591 Renvoie un affichage unique pour l'ensemble des valeurs à chaque pas, si
592 elles sont compatibles avec un affichage Gnuplot (donc essentiellement
593 un vecteur). Si l'argument "step" existe dans la liste des pas de
594 stockage effectués, renvoie l'affichage de la valeur stockée à ce pas
595 "step". Si l'argument "item" est correct, renvoie l'affichage de la
596 valeur stockée au numéro "item".
599 - steps : liste unique des pas de l'axe des X, ou None si c'est
600 la numérotation par défaut
601 - title : base du titre général, qui sera automatiquement
602 complétée par la mention du pas
603 - xlabel : label de l'axe des X
604 - ylabel : label de l'axe des Y
605 - ltitle : titre associé au vecteur tracé
606 - geometry : taille en pixels de la fenêtre et position du coin haut
607 gauche, au format X11 : LxH+X+Y (défaut : 600x400)
608 - filename : nom de fichier Postscript pour une sauvegarde
609 - persist : booléen indiquant que la fenêtre affichée sera
610 conservée lors du passage au dessin suivant
611 Par défaut, persist = False
612 - pause : booléen indiquant une pause après chaque tracé, et
614 Par défaut, pause = True
618 # Vérification de la disponibilité du module Gnuplot
621 self.__gnuplot = Gnuplot
623 raise ImportError("The Gnuplot module is required to plot the object.")
625 # Vérification et compléments sur les paramètres d'entrée
627 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
629 self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
632 if ( type(steps) is list ) or ( type(steps) is type(numpy.array([])) ):
635 Steps = range(len(self.__values[0]))
636 self.__g = self.__gnuplot.Gnuplot() # persist=1
637 self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
638 self.__g('set style data lines')
640 self.__g('set autoscale')
641 self.__g('set title "'+str(title).encode('ascii','replace') +'"')
642 self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
643 self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
645 # Tracé du ou des vecteurs demandés
646 indexes = range(len(self.__values))
647 self.__g.plot( self.__gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle+" (pas 0)" ) )
648 for index in indexes:
649 self.__g.replot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle+" (pas %i)"%index ) )
652 self.__g.hardcopy(filename=filename, color=1)
654 raw_input('Please press return to continue...\n')
656 # ---------------------------------------------------------
657 def setDataObserver(self,
659 HookParameters = None,
663 Association à la variable d'un triplet définissant un observer
665 Le Scheduler attendu est une fréquence, une simple liste d'index ou un
669 # Vérification du Scheduler
670 # -------------------------
672 if type(Scheduler) is int: # Considéré comme une fréquence à partir de 0
673 Schedulers = xrange( 0, maxiter, int(Scheduler) )
674 elif type(Scheduler) is xrange: # Considéré comme un itérateur
675 Schedulers = Scheduler
676 elif type(Scheduler) is list: # Considéré comme des index explicites
677 Schedulers = map( long, Scheduler )
678 else: # Dans tous les autres cas, activé par défaut
679 Schedulers = xrange( 0, maxiter )
681 # Stockage interne de l'observer dans la variable
682 # -----------------------------------------------
683 self.__dataobservers.append( [HookFunction, HookParameters, Schedulers] )
685 def removeDataObserver(self,
689 Suppression d'un observer nommé sur la variable.
691 On peut donner dans HookFunction la meme fonction que lors de la
692 définition, ou un simple string qui est le nom de la fonction.
695 if hasattr(HookFunction,"func_name"):
696 name = str( HookFunction.func_name )
697 elif type(HookFunction) is str:
698 name = str( HookFunction )
704 for [hf, hp, hs] in self.__dataobservers:
706 if name is hf.func_name: index_to_remove.append( i )
707 index_to_remove.reverse()
708 for i in index_to_remove:
709 self.__dataobservers.pop( i )
711 # ==============================================================================
712 class OneScalar(Persistence):
714 Classe définissant le stockage d'une valeur unique réelle (float) par pas
716 Le type de base peut être changé par la méthode "basetype", mais il faut que
717 le nouveau type de base soit compatible avec les types par éléments de
718 numpy. On peut même utiliser cette classe pour stocker des vecteurs/listes
719 ou des matrices comme dans les classes suivantes, mais c'est déconseillé
720 pour conserver une signification claire des noms.
722 def __init__(self, name="", unit="", basetype = float):
723 Persistence.__init__(self, name, unit, basetype)
725 class OneVector(Persistence):
727 Classe définissant le stockage d'une liste (list) de valeurs homogènes par
728 hypothèse par pas. Pour éviter les confusions, ne pas utiliser la classe
729 "OneVector" pour des données hétérogènes, mais bien "OneList".
731 def __init__(self, name="", unit="", basetype = list):
732 Persistence.__init__(self, name, unit, basetype)
734 class OneMatrix(Persistence):
736 Classe définissant le stockage d'une matrice de valeurs (numpy.matrix) par
739 def __init__(self, name="", unit="", basetype = numpy.matrix):
740 Persistence.__init__(self, name, unit, basetype)
742 class OneList(Persistence):
744 Classe définissant le stockage d'une liste de valeurs potentiellement
745 hétérogènes (list) par pas. Pour éviter les confusions, ne pas utiliser la
746 classe "OneVector" pour des données hétérogènes, mais bien "OneList".
748 def __init__(self, name="", unit="", basetype = list):
749 Persistence.__init__(self, name, unit, basetype)
751 def NoType( value ): return value
753 class OneNoType(Persistence):
755 Classe définissant le stockage d'un objet sans modification (cast) de type.
756 Attention, selon le véritable type de l'objet stocké à chaque pas, les
757 opérations arithmétiques à base de numpy peuvent être invalides ou donner
758 des résultats inatendus. Cette classe n'est donc à utiliser qu'à bon escient
759 volontairement, et pas du tout par défaut.
761 def __init__(self, name="", unit="", basetype = NoType):
762 Persistence.__init__(self, name, unit, basetype)
764 # ==============================================================================
765 class CompositePersistence:
767 Structure de stockage permettant de rassembler plusieurs objets de
770 Des objets par défaut sont prévus, et des objets supplémentaires peuvent
773 def __init__(self, name="", defaults=True):
777 La gestion interne des données est exclusivement basée sur les variables
778 initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
779 objets comme des attributs) :
780 __StoredObjects : objets de type persistence collectés dans cet objet
782 self.__name = str(name)
784 self.__StoredObjects = {}
786 # Definition des objets par defaut
787 # --------------------------------
789 self.__StoredObjects["Informations"] = OneNoType("Informations")
790 self.__StoredObjects["Background"] = OneVector("Background", basetype=numpy.array)
791 self.__StoredObjects["BackgroundError"] = OneMatrix("BackgroundError")
792 self.__StoredObjects["Observation"] = OneVector("Observation", basetype=numpy.array)
793 self.__StoredObjects["ObservationError"] = OneMatrix("ObservationError")
794 self.__StoredObjects["Analysis"] = OneVector("Analysis", basetype=numpy.array)
795 self.__StoredObjects["AnalysisError"] = OneMatrix("AnalysisError")
796 self.__StoredObjects["Innovation"] = OneVector("Innovation", basetype=numpy.array)
797 self.__StoredObjects["KalmanGainK"] = OneMatrix("KalmanGainK")
798 self.__StoredObjects["OperatorH"] = OneMatrix("OperatorH")
799 self.__StoredObjects["RmsOMA"] = OneScalar("RmsOMA")
800 self.__StoredObjects["RmsOMB"] = OneScalar("RmsOMB")
801 self.__StoredObjects["RmsBMA"] = OneScalar("RmsBMA")
804 def store(self, name=None, value=None, step=None, tags={}):
806 Stockage d'une valeur "value" pour le "step" dans la variable "name".
808 if name is None: raise ValueError("Storable object name is required for storage.")
809 if name not in self.__StoredObjects.keys():
810 raise ValueError("No such name '%s' exists in storable objects."%name)
811 self.__StoredObjects[name].store( value=value, step=step, tags=tags )
813 def add_object(self, name=None, persistenceType=Persistence, basetype=numpy.array ):
815 Ajoute dans les objets stockables un nouvel objet défini par son nom, son
816 type de Persistence et son type de base à chaque pas.
818 if name is None: raise ValueError("Object name is required for adding an object.")
819 if name in self.__StoredObjects.keys():
820 raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name)
821 self.__StoredObjects[name] = persistenceType( name=str(name), basetype=basetype )
823 def get_object(self, name=None ):
825 Renvoie l'objet de type Persistence qui porte le nom demandé.
827 if name is None: raise ValueError("Object name is required for retrieving an object.")
828 if name not in self.__StoredObjects.keys():
829 raise ValueError("No such name '%s' exists in stored objects."%name)
830 return self.__StoredObjects[name]
832 def set_object(self, name=None, objet=None ):
834 Affecte directement un 'objet' qui porte le nom 'name' demandé.
835 Attention, il n'est pas effectué de vérification sur le type, qui doit
836 comporter les méthodes habituelles de Persistence pour que cela
839 if name is None: raise ValueError("Object name is required for setting an object.")
840 if name in self.__StoredObjects.keys():
841 raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name)
842 self.__StoredObjects[name] = objet
844 def del_object(self, name=None ):
846 Supprime un objet de la liste des objets stockables.
848 if name is None: raise ValueError("Object name is required for retrieving an object.")
849 if name not in self.__StoredObjects.keys():
850 raise ValueError("No such name '%s' exists in stored objects."%name)
851 del self.__StoredObjects[name]
853 # ---------------------------------------------------------
854 # Méthodes d'accès de type dictionnaire
855 def __getitem__(self, name=None ):
856 return self.get_object( name )
858 def __setitem__(self, name=None, objet=None ):
859 self.set_object( name, objet )
862 return self.get_stored_objects(hideVoidObjects = False)
865 return self.__StoredObjects.values()
868 return self.__StoredObjects.items()
870 # ---------------------------------------------------------
871 def get_stored_objects(self, hideVoidObjects = False):
872 objs = self.__StoredObjects.keys()
877 if len(self.__StoredObjects[k]) > 0: usedObjs.append( k )
884 # ---------------------------------------------------------
885 def save_composite(self, filename=None, mode="pickle", compress="gzip"):
887 Enregistre l'objet dans le fichier indiqué selon le "mode" demandé,
888 et renvoi le nom du fichier
892 if compress == "gzip":
893 filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl.gz"
894 elif compress == "bzip2":
895 filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl.bz2"
897 filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl"
899 filename = os.path.abspath( filename )
903 if compress == "gzip":
905 output = gzip.open( filename, 'wb')
906 elif compress == "bzip2":
908 output = bz2.BZ2File( filename, 'wb')
910 output = open( filename, 'wb')
911 cPickle.dump(self, output)
914 raise ValueError("Save mode '%s' unknown. Choose another one."%mode)
918 def load_composite(self, filename=None, mode="pickle", compress="gzip"):
920 Recharge un objet composite sauvé en fichier
924 raise ValueError("A file name if requested to load a composite.")
926 filename = os.path.abspath( filename )
930 if compress == "gzip":
932 pkl_file = gzip.open( filename, 'rb')
933 elif compress == "bzip2":
935 pkl_file = bz2.BZ2File( filename, 'rb')
937 pkl_file = open(filename, 'rb')
938 output = cPickle.load(pkl_file)
939 for k in output.keys():
942 raise ValueError("Load mode '%s' unknown. Choose another one."%mode)
946 # ==============================================================================
947 if __name__ == "__main__":
948 print '\n AUTODIAGNOSTIC \n'
950 print "======> Un flottant"
951 OBJET_DE_TEST = OneScalar("My float", unit="cm")
952 OBJET_DE_TEST.store( 5.)
953 OBJET_DE_TEST.store(-5.)
954 OBJET_DE_TEST.store( 1.)
955 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
956 print "Les valeurs :", OBJET_DE_TEST.valueserie()
957 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
958 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
959 print "Valeurs par pas :"
960 print " La moyenne :", OBJET_DE_TEST.mean()
961 print " L'écart-type :", OBJET_DE_TEST.std()
962 print " La somme :", OBJET_DE_TEST.sum()
963 print " Le minimum :", OBJET_DE_TEST.min()
964 print " Le maximum :", OBJET_DE_TEST.max()
965 print "Valeurs globales :"
966 print " La moyenne :", OBJET_DE_TEST.stepmean()
967 print " L'écart-type :", OBJET_DE_TEST.stepstd()
968 print " La somme :", OBJET_DE_TEST.stepsum()
969 print " Le minimum :", OBJET_DE_TEST.stepmin()
970 print " Le maximum :", OBJET_DE_TEST.stepmax()
971 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
972 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
973 print "Taille \"len\" :", len(OBJET_DE_TEST)
977 print "======> Un flottant"
978 OBJET_DE_TEST = OneScalar("My float", unit="cm")
979 OBJET_DE_TEST.store( 5., step="azerty")
980 OBJET_DE_TEST.store(-5., step="poiuyt")
981 OBJET_DE_TEST.store( 1., step="azerty")
982 OBJET_DE_TEST.store( 0., step="xxxxxx")
983 OBJET_DE_TEST.store( 5., step="poiuyt")
984 OBJET_DE_TEST.store(-5., step="azerty")
985 OBJET_DE_TEST.store( 1., step="poiuyt")
986 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
987 print "Les valeurs :", OBJET_DE_TEST.valueserie()
988 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
989 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
990 print "Premier index :", OBJET_DE_TEST.valueserie( step = "azerty", allSteps = False )
991 print "Valeurs identiques :", OBJET_DE_TEST.valueserie( step = "azerty", allSteps = True )
992 print "Premier index :", OBJET_DE_TEST.valueserie( step = "poiuyt", allSteps = False )
993 print "Valeurs identiques :", OBJET_DE_TEST.valueserie( step = "poiuyt", allSteps = True )
997 print "======> Un entier"
998 OBJET_DE_TEST = OneScalar("My int", unit="cm", basetype=int)
999 OBJET_DE_TEST.store( 5 )
1000 OBJET_DE_TEST.store(-5 )
1001 OBJET_DE_TEST.store( 1.)
1002 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1003 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1004 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1005 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1006 print "Valeurs par pas :"
1007 print " La moyenne :", OBJET_DE_TEST.mean()
1008 print " L'écart-type :", OBJET_DE_TEST.std()
1009 print " La somme :", OBJET_DE_TEST.sum()
1010 print " Le minimum :", OBJET_DE_TEST.min()
1011 print " Le maximum :", OBJET_DE_TEST.max()
1012 print "Valeurs globales :"
1013 print " La moyenne :", OBJET_DE_TEST.stepmean()
1014 print " L'écart-type :", OBJET_DE_TEST.stepstd()
1015 print " La somme :", OBJET_DE_TEST.stepsum()
1016 print " Le minimum :", OBJET_DE_TEST.stepmin()
1017 print " Le maximum :", OBJET_DE_TEST.stepmax()
1018 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
1019 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1020 print "Taille \"len\" :", len(OBJET_DE_TEST)
1024 print "======> Un booléen"
1025 OBJET_DE_TEST = OneScalar("My bool", unit="", basetype=bool)
1026 OBJET_DE_TEST.store( True )
1027 OBJET_DE_TEST.store( False )
1028 OBJET_DE_TEST.store( True )
1029 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1030 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1031 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1032 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1033 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1034 print "Taille \"len\" :", len(OBJET_DE_TEST)
1038 print "======> Un vecteur de flottants"
1039 OBJET_DE_TEST = OneVector("My float vector", unit="cm")
1040 OBJET_DE_TEST.store( (5 , -5) )
1041 OBJET_DE_TEST.store( (-5, 5 ) )
1042 OBJET_DE_TEST.store( (1., 1.) )
1043 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1044 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1045 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1046 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1047 print "Valeurs par pas :"
1048 print " La moyenne :", OBJET_DE_TEST.mean()
1049 print " L'écart-type :", OBJET_DE_TEST.std()
1050 print " La somme :", OBJET_DE_TEST.sum()
1051 print " Le minimum :", OBJET_DE_TEST.min()
1052 print " Le maximum :", OBJET_DE_TEST.max()
1053 print "Valeurs globales :"
1054 print " La moyenne :", OBJET_DE_TEST.stepmean()
1055 print " L'écart-type :", OBJET_DE_TEST.stepstd()
1056 print " La somme :", OBJET_DE_TEST.stepsum()
1057 print " Le minimum :", OBJET_DE_TEST.stepmin()
1058 print " Le maximum :", OBJET_DE_TEST.stepmax()
1059 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
1060 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1061 print "Taille \"len\" :", len(OBJET_DE_TEST)
1065 print "======> Une liste hétérogène"
1066 OBJET_DE_TEST = OneList("My list", unit="bool/cm")
1067 OBJET_DE_TEST.store( (True , -5) )
1068 OBJET_DE_TEST.store( (False, 5 ) )
1069 OBJET_DE_TEST.store( (True , 1.) )
1070 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1071 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1072 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1073 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1074 print "Valeurs par pas : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens"
1075 print " La moyenne :", OBJET_DE_TEST.mean()
1076 print " L'écart-type :", OBJET_DE_TEST.std()
1077 print " La somme :", OBJET_DE_TEST.sum()
1078 print " Le minimum :", OBJET_DE_TEST.min()
1079 print " Le maximum :", OBJET_DE_TEST.max()
1080 print "Valeurs globales : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens"
1081 print " La moyenne :", OBJET_DE_TEST.stepmean()
1082 print " L'écart-type :", OBJET_DE_TEST.stepstd()
1083 print " La somme :", OBJET_DE_TEST.stepsum()
1084 print " Le minimum :", OBJET_DE_TEST.stepmin()
1085 print " Le maximum :", OBJET_DE_TEST.stepmax()
1086 print " La somme cumulée :", OBJET_DE_TEST.cumsum()
1087 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1088 print "Taille \"len\" :", len(OBJET_DE_TEST)
1092 print "======> Utilisation directe de la classe Persistence"
1093 OBJET_DE_TEST = Persistence("My object", unit="", basetype=int )
1094 OBJET_DE_TEST.store( 1 )
1095 OBJET_DE_TEST.store( 3 )
1096 OBJET_DE_TEST.store( 7 )
1097 print "Les pas de stockage :", OBJET_DE_TEST.stepserie()
1098 print "Les valeurs :", OBJET_DE_TEST.valueserie()
1099 print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1)
1100 print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1)
1101 print "Taille \"shape\" :", OBJET_DE_TEST.shape()
1102 print "Taille \"len\" :", len(OBJET_DE_TEST)
1106 print "======> Utilisation des méthodes d'accès de type dictionnaire"
1107 OBJET_DE_TEST = OneScalar("My int", unit="cm", basetype=int)
1109 OBJET_DE_TEST.store( 7+i )
1110 print "Taille \"len\" :", len(OBJET_DE_TEST)
1111 print "Les pas de stockage :", OBJET_DE_TEST.keys()
1112 print "Les valeurs :", OBJET_DE_TEST.values()
1113 print "Les paires :", OBJET_DE_TEST.items()
1117 print "======> Persistence composite"
1118 OBJET_DE_TEST = CompositePersistence("My CompositePersistence")
1119 print "Objets stockables :", OBJET_DE_TEST.get_stored_objects()
1120 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1121 print "--> Stockage d'une valeur de Background"
1122 OBJET_DE_TEST.store("Background",numpy.zeros(5))
1123 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1124 print "--> Ajout d'un objet nouveau par defaut, de type vecteur numpy par pas"
1125 OBJET_DE_TEST.add_object("ValeursVectorielles")
1126 OBJET_DE_TEST.store("ValeursVectorielles",numpy.zeros(5))
1127 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1128 print "--> Ajout d'un objet nouveau de type liste par pas"
1129 OBJET_DE_TEST.add_object("ValeursList", persistenceType=OneList )
1130 OBJET_DE_TEST.store("ValeursList",range(5))
1131 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1132 print "--> Ajout d'un objet nouveau, de type vecteur string par pas"
1133 OBJET_DE_TEST.add_object("ValeursStr", persistenceType=Persistence, basetype=str )
1134 OBJET_DE_TEST.store("ValeursStr","IGN3")
1135 OBJET_DE_TEST.store("ValeursStr","c021")
1136 print "Les valeurs :", OBJET_DE_TEST.get_object("ValeursStr").valueserie()
1137 print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"].stepserie()
1138 print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"].valueserie()
1139 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1140 print "--> Suppression d'un objet"
1141 OBJET_DE_TEST.del_object("ValeursVectorielles")
1142 print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True )
1143 print "--> Enregistrement de l'objet complet de Persistence composite"
1144 OBJET_DE_TEST.save_composite("composite.pkl", compress="None")
1147 print "======> Affichage graphique d'objets stockés"
1148 OBJET_DE_TEST = Persistence("My object", unit="", basetype=numpy.array)
1150 vect1 = [1, 2, 1, 2, 1]
1151 vect2 = [-3, -3, 0, -3, -3]
1152 vect3 = [-1, 1, -5, 1, -1]
1153 vect4 = 100*[0.29, 0.97, 0.73, 0.01, 0.20]
1154 print "Stockage de 3 vecteurs de longueur identique"
1158 print "Affichage graphique de l'ensemble du stockage sur une même image"
1160 title = "Tous les vecteurs",
1161 filename="vecteurs.ps",
1165 print "Stockage d'un quatrième vecteur de longueur différente"
1167 print "Affichage graphique séparé du dernier stockage"
1171 filename = "vecteur",
1175 print "Les images ont été stockées en fichiers Postscript"
1176 print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape()
1177 print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST)
1181 print "======> Affichage graphique dynamique d'objets"
1182 OBJET_DE_TEST = Persistence("My object", unit="", basetype=float)
1186 title = "Valeur suivie",
1191 for i in range(1,11):
1193 print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape()
1194 print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST)
1195 print "Nombre d'objets stockés",OBJET_DE_TEST.stepnumber()
1199 print "======> Affectation simple d'observateurs dynamiques"
1200 def obs(var=None,info=None):
1201 print " ---> Mise en oeuvre de l'observer"
1202 print " var =",var.valueserie(-1)
1203 print " info =",info
1204 OBJET_DE_TEST = Persistence("My object", unit="", basetype=list)
1206 D.setDataObserver( HookFunction = obs )
1209 print "Action de 1 observer sur la variable observée, étape :",i
1210 D.store( [i, i, i] )
1214 print "======> Affectation multiple d'observateurs dynamiques"
1215 def obs(var=None,info=None):
1216 print " ---> Mise en oeuvre de l'observer"
1217 print " var =",var.valueserie(-1)
1218 print " info =",info
1219 def obs_bis(var=None,info=None):
1220 print " ---> Mise en oeuvre de l'observer"
1221 print " var =",var.valueserie(-1)
1222 print " info =",info
1223 OBJET_DE_TEST = Persistence("My object", unit="", basetype=list)
1228 HookParameters = "Premier observer",
1232 Scheduler = xrange(1,3),
1233 HookParameters = "Second observer",
1236 HookFunction = obs_bis,
1237 Scheduler = range(1,3)+range(7,9),
1238 HookParameters = "Troisième observer",
1241 print "Action de 3 observers sur la variable observée, étape :",i
1242 D.store( [i, i, i] )
1243 D.removeDataObserver(
1246 for i in range(5,10):
1247 print "Action d'un seul observer sur la variable observée, étape :",i
1248 D.store( [i, i, i] )
1252 print "======> Utilisation des tags/attributs et stockage puis récupération de l'ensemble"
1253 OBJET_DE_TEST = CompositePersistence("My CompositePersistence", defaults=False)
1254 OBJET_DE_TEST.add_object("My ecarts", basetype = numpy.array)
1256 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5), tags = {"Camp":"Base","Carte":"IGN3","Niveau":1024,"Palier":"Premier"} )
1257 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+1, tags = {"Camp":"Base","Carte":"IGN4","Niveau": 210,"Palier":"Premier"} )
1258 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+2, tags = {"Camp":"Base","Carte":"IGN1","Niveau":1024} )
1259 OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+3, tags = {"Camp":"Sommet","Carte":"IGN2","Niveau":4024,"Palier":"Second","FullMap":True} )
1261 print "Les pas de stockage :", OBJET_DE_TEST["My ecarts"].stepserie()
1262 print "Les valeurs :", OBJET_DE_TEST["My ecarts"].valueserie()
1263 print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"].valueserie(1)
1264 print "La dernière valeur :", OBJET_DE_TEST["My ecarts"].valueserie(-1)
1265 print "Liste des attributs :", OBJET_DE_TEST["My ecarts"].tagserie()
1266 print "Taille \"shape\" :", OBJET_DE_TEST["My ecarts"].shape()
1267 print "Taille \"len\" :", len(OBJET_DE_TEST["My ecarts"])
1270 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Palier":"Premier"} )
1271 print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].valueserie( tags={"Palier":"Premier"} )
1273 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1274 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Niveau":1024} )
1275 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base"} )
1276 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"TOTO"} )
1277 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Toto":"Premier"} )
1278 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1281 print "Combinaison 'ET' de plusieurs Tags"
1282 print "Attendu : [0, 1], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base", "Palier":"Premier"} )
1283 print "Attendu : [], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Sommet", "Palier":"Premier"} )
1284 # Attention : {"Camp":"Sommet", "Camp":"Base"} == {"Camp":"Base"}
1285 print "Attendu : [0, 1, 2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Sommet", "Camp":"Base"} )
1286 print "Attendu : [2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1", "Niveau":1024} )
1289 print "Liste des tags pour le pas (item) 1 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 1)
1290 print "Liste des tags pour le pas (item) 2 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 2)
1291 print "Comme le step et l'item sont identiques par défaut, on doit avoir la même chose :"
1292 print "Liste des tags pour le pas (step) 1 :",OBJET_DE_TEST["My ecarts"].tagserie(step = 1)
1293 print "Liste des tags pour le pas (step) 2 :",OBJET_DE_TEST["My ecarts"].tagserie(step = 2)
1295 print "Liste des tags/valeurs pour le pas 1 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 1, withValues=True)
1296 print "Liste des tags/valeurs pour le pas 2 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 2, withValues=True)
1299 print "Liste des valeurs possibles pour 1 tag donné 'Camp' :",OBJET_DE_TEST["My ecarts"].tagserie(outputTag="Camp")
1300 print "Liste des valeurs possibles pour 1 tag donné 'Toto' :",OBJET_DE_TEST["My ecarts"].tagserie(outputTag="Toto")
1301 print "Liste des valeurs possibles pour 1 tag donné 'Niveau' :",OBJET_DE_TEST["My ecarts"].tagserie(outputTag="Niveau")
1304 OBJET_DE_TEST.add_object("My other ecarts", basetype = numpy.array)
1305 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5), tags = {"Camp":"Base","Carte":"IGN3","Niveau":1024,"Palier":"Premier"} )
1306 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+1, tags = {"Camp":"Base","Carte":"IGN4","Niveau": 210,"Palier":"Premier"} )
1307 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+2, tags = {"Camp":"Base","Carte":"IGN1","Niveau":1024} )
1308 OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+3, tags = {"Camp":"Sommet","Carte":"IGN2","Niveau":4024,"Palier":"Second"} )
1310 print "Objets présents dans le composite :",OBJET_DE_TEST.get_stored_objects()
1311 fichier = "composite.pkl.gz"
1312 print "Sauvegarde sur \"%s\"..."%fichier
1313 OBJET_DE_TEST.save_composite( fichier )
1314 print "Effacement de l'objet en memoire"
1318 print "Relecture de l'objet sur \"%s\"..."%fichier
1319 OBJET_DE_TEST = CompositePersistence("My CompositePersistence bis", defaults=False)
1320 OBJET_DE_TEST.load_composite( fichier )
1321 print "Objets présents dans le composite :",OBJET_DE_TEST.get_stored_objects()
1322 print "Taille des objets contenus :"
1323 for name in OBJET_DE_TEST.get_stored_objects():
1324 print " Objet \"%s\" : taille unitaire de %i"%(name,len(OBJET_DE_TEST[name]))
1327 print "Les pas de stockage :", OBJET_DE_TEST["My ecarts"].stepserie()
1328 print "Les valeurs :", OBJET_DE_TEST["My ecarts"].valueserie()
1329 print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"].valueserie(1)
1330 print "La dernière valeur :", OBJET_DE_TEST["My ecarts"].valueserie(-1)
1331 print "Liste des attributs :", OBJET_DE_TEST["My ecarts"].tagserie()
1332 print "Taille \"shape\" :", OBJET_DE_TEST["My ecarts"].shape()
1333 print "Taille \"len\" :", len(OBJET_DE_TEST["My ecarts"])
1336 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Palier":"Premier"} )
1337 print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].valueserie( tags={"Palier":"Premier"} )
1339 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1340 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Niveau":1024} )
1341 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base"} )
1342 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"TOTO"} )
1343 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Toto":"Premier"} )
1344 print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} )
1346 print "Attributs :", OBJET_DE_TEST["My ecarts"].tagserie()
1347 print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( tags={"Camp":"Base"} )
1348 print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( tags={"Niveau":4024} )
1350 print "Attributs et valeurs :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True )
1351 print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, tags={"Camp":"Base"} )
1352 print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, tags={"Niveau":4024} )
1354 print "Valeur d'attribut pour un tag donné 'BU' :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau" )
1355 print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", tags={"Camp":"Base"} )
1356 print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", tags={"Palier":"Second"} )
1357 print "Valeur d'attribut pour un tag donné 'Camp' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Camp", tags={"Palier":"Premier"} )
1358 print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier"} )
1359 print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier","Niveau":4024} )
1360 print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier","Niveau":210} )