-#-*-coding:iso-8859-1-*-
+# -*- coding: utf-8 -*-
#
-# Copyright (C) 2008-2017 EDF R&D
+# Copyright (C) 2008-2022 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"""
- Définit des outils de persistence et d'enregistrement de séries de valeurs
- pour analyse ultérieure ou utilisation de calcul.
+ Définit des outils de persistance et d'enregistrement de séries de valeurs
+ pour analyse ultérieure ou utilisation de calcul.
"""
__author__ = "Jean-Philippe ARGAUD"
__all__ = []
-import numpy, copy
+import os, numpy, copy, math
+import gzip, bz2, pickle
from daCore.PlatformInfo import PathManagement ; PathManagement()
+from daCore.PlatformInfo import has_gnuplot, PlatformInfo
+mfp = PlatformInfo().MaximumPrecision()
+if has_gnuplot:
+ import Gnuplot
# ==============================================================================
class Persistence(object):
"""
- Classe générale de persistence définissant les accesseurs nécessaires
+ Classe générale de persistance définissant les accesseurs nécessaires
(Template)
"""
def __init__(self, name="", unit="", basetype=str):
"""
name : nom courant
- unit : unité
- basetype : type de base de l'objet stocké à chaque pas
+ unit : unité
+ basetype : type de base de l'objet stocké à chaque pas
- La gestion interne des données est exclusivement basée sur les variables
- initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
+ La gestion interne des données est exclusivement basée sur les variables
+ initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
objets comme des attributs) :
__basetype : le type de base de chaque valeur, sous la forme d'un type
permettant l'instanciation ou le casting Python
- __values : les valeurs de stockage. Par défaut, c'est None
+ __values : les valeurs de stockage. Par défaut, c'est None
"""
self.__name = str(name)
self.__unit = str(unit)
self.__tags = []
#
self.__dynamic = False
- self.__gnuplot = None
self.__g = None
self.__title = None
self.__ltitle = None
def basetype(self, basetype=None):
"""
- Renvoie ou met en place le type de base des objets stockés
+ Renvoie ou met en place le type de base des objets stockés
"""
if basetype is None:
return self.__basetype
def pop(self, item=None):
"""
- Retire une valeur enregistree par son index de stockage. Sans argument,
+ Retire une valeur enregistrée par son index de stockage. Sans argument,
retire le dernier objet enregistre.
"""
if item is not None:
def shape(self):
"""
- Renvoie la taille sous forme numpy du dernier objet stocké. Si c'est un
+ Renvoie la taille sous forme numpy du dernier objet stocké. Si c'est un
objet numpy, renvoie le shape. Si c'est un entier, un flottant, un
complexe, renvoie 1. Si c'est une liste ou un dictionnaire, renvoie la
- longueur. Par défaut, renvoie 1.
+ longueur. Par défaut, renvoie 1.
"""
if len(self.__values) > 0:
- if self.__basetype in [numpy.matrix, numpy.array, numpy.ravel]:
+ if self.__basetype in [numpy.matrix, numpy.ndarray, numpy.array, numpy.ravel]:
return self.__values[-1].shape
elif self.__basetype in [int, float]:
return (1,)
"x.__len__() <==> len(x)"
return len(self.__values)
+ def name(self):
+ return self.__name
+
def __getitem__(self, index=None ):
"x.__getitem__(y) <==> x[y]"
return copy.copy(self.__values[index])
"D.tagkeys() -> list of D's tag keys"
__allKeys = []
for dicotags in self.__tags:
- __allKeys.extend( dicotags.keys() )
- __allKeys = list(set(__allKeys))
- __allKeys.sort()
+ __allKeys.extend( list(dicotags.keys()) )
+ __allKeys = sorted(set(__allKeys))
return __allKeys
# def valueserie(self, item=None, allSteps=True, **kwargs):
else:
__indexOfFilteredItems = [item,]
#
- # Dans le cas où la sortie donne les valeurs d'un "outputTag"
+ # Dans le cas où la sortie donne les valeurs d'un "outputTag"
if outputTag is not None and isinstance(outputTag,str) :
outputValues = []
for index in __indexOfFilteredItems:
if outputTag in self.__tags[index].keys():
outputValues.append( self.__tags[index][outputTag] )
- outputValues = list(set(outputValues))
- outputValues.sort()
+ outputValues = sorted(set(outputValues))
return outputValues
#
- # Dans le cas où la sortie donne les tags satisfaisants aux conditions
+ # Dans le cas où la sortie donne les tags satisfaisants aux conditions
else:
if withValues:
return [self.__tags[index] for index in __indexOfFilteredItems]
allTags = {}
for index in __indexOfFilteredItems:
allTags.update( self.__tags[index] )
- allKeys = allTags.keys()
- allKeys.sort()
+ allKeys = sorted(allTags.keys())
return allKeys
# ---------------------------------------------------------
- # Pour compatibilite
+ # Pour compatibilité
def stepnumber(self):
"Nombre de pas"
return len(self.__values)
- # Pour compatibilite
+ # Pour compatibilité
def stepserie(self, **kwargs):
- "Nombre de pas filtrés"
+ "Nombre de pas filtrés"
__indexOfFilteredItems = self.__filteredIndexes(**kwargs)
return __indexOfFilteredItems
+ # Pour compatibilité
+ def steplist(self, **kwargs):
+ "Nombre de pas filtrés"
+ __indexOfFilteredItems = self.__filteredIndexes(**kwargs)
+ return list(__indexOfFilteredItems)
+
# ---------------------------------------------------------
def means(self):
"""
- Renvoie la série, contenant à chaque pas, la valeur moyenne des données
+ Renvoie la série, contenant à chaque pas, la valeur moyenne des données
au pas. Il faut que le type de base soit compatible avec les types
- élémentaires numpy.
+ élémentaires numpy.
"""
try:
- return [numpy.matrix(item).mean() for item in self.__values]
+ return [numpy.mean(item, dtype=mfp).astype('float') for item in self.__values]
except:
raise TypeError("Base type is incompatible with numpy")
def stds(self, ddof=0):
"""
- Renvoie la série, contenant à chaque pas, l'écart-type des données
+ Renvoie la série, contenant à chaque pas, l'écart-type des données
au pas. Il faut que le type de base soit compatible avec les types
- élémentaires numpy.
+ élémentaires numpy.
- ddof : c'est le nombre de degrés de liberté pour le calcul de
- l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
+ ddof : c'est le nombre de degrés de liberté pour le calcul de
+ l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
"""
try:
if numpy.version.version >= '1.1.0':
- return [numpy.matrix(item).std(ddof=ddof) for item in self.__values]
+ return [numpy.array(item).std(ddof=ddof, dtype=mfp).astype('float') for item in self.__values]
else:
- return [numpy.matrix(item).std() for item in self.__values]
+ return [numpy.array(item).std(dtype=mfp).astype('float') for item in self.__values]
except:
raise TypeError("Base type is incompatible with numpy")
def sums(self):
"""
- Renvoie la série, contenant à chaque pas, la somme des données au pas.
- Il faut que le type de base soit compatible avec les types élémentaires
+ Renvoie la série, contenant à chaque pas, la somme des données au pas.
+ Il faut que le type de base soit compatible avec les types élémentaires
numpy.
"""
try:
- return [numpy.matrix(item).sum() for item in self.__values]
+ return [numpy.array(item).sum() for item in self.__values]
except:
raise TypeError("Base type is incompatible with numpy")
def mins(self):
"""
- Renvoie la série, contenant à chaque pas, le minimum des données au pas.
- Il faut que le type de base soit compatible avec les types élémentaires
+ Renvoie la série, contenant à chaque pas, le minimum des données au pas.
+ Il faut que le type de base soit compatible avec les types élémentaires
numpy.
"""
try:
- return [numpy.matrix(item).min() for item in self.__values]
+ return [numpy.array(item).min() for item in self.__values]
except:
raise TypeError("Base type is incompatible with numpy")
def maxs(self):
"""
- Renvoie la série, contenant à chaque pas, la maximum des données au pas.
- Il faut que le type de base soit compatible avec les types élémentaires
+ Renvoie la série, contenant à chaque pas, la maximum des données au pas.
+ Il faut que le type de base soit compatible avec les types élémentaires
numpy.
"""
try:
- return [numpy.matrix(item).max() for item in self.__values]
+ return [numpy.array(item).max() for item in self.__values]
except:
raise TypeError("Base type is incompatible with numpy")
+ def norms(self, _ord=None):
+ """
+ Norm (_ord : voir numpy.linalg.norm)
+
+ Renvoie la série, contenant à chaque pas, la norme des données au pas.
+ Il faut que le type de base soit compatible avec les types élémentaires
+ numpy.
+ """
+ try:
+ return [numpy.linalg.norm(item, _ord) for item in self.__values]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+
+ def maes(self, _predictor=None):
+ """
+ Mean Absolute Error (MAE)
+ mae(dX) = 1/n sum(dX_i)
+
+ Renvoie la série, contenant à chaque pas, la MAE des données au pas.
+ Il faut que le type de base soit compatible avec les types élémentaires
+ numpy. C'est réservé aux variables d'écarts ou d'incréments si le
+ prédicteur est None, sinon c'est appliqué à l'écart entre les données
+ au pas et le prédicteur au même pas.
+ """
+ if _predictor is None:
+ try:
+ return [numpy.mean(numpy.abs(item)) for item in self.__values]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+ else:
+ if len(_predictor) != len(self.__values):
+ raise ValueError("Predictor number of steps is incompatible with the values")
+ for i, item in enumerate(self.__values):
+ if numpy.asarray(_predictor[i]).size != numpy.asarray(item).size:
+ raise ValueError("Predictor size at step %i is incompatible with the values"%i)
+ try:
+ return [numpy.mean(numpy.abs(numpy.ravel(item) - numpy.ravel(_predictor[i]))) for i, item in enumerate(self.__values)]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+
+ def mses(self, _predictor=None):
+ """
+ Mean-Square Error (MSE) ou Mean-Square Deviation (MSD)
+ mse(dX) = 1/n sum(dX_i**2)
+
+ Renvoie la série, contenant à chaque pas, la MSE des données au pas. Il
+ faut que le type de base soit compatible avec les types élémentaires
+ numpy. C'est réservé aux variables d'écarts ou d'incréments si le
+ prédicteur est None, sinon c'est appliqué à l'écart entre les données
+ au pas et le prédicteur au même pas.
+ """
+ if _predictor is None:
+ try:
+ __n = self.shape()[0]
+ return [(numpy.linalg.norm(item)**2 / __n) for item in self.__values]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+ else:
+ if len(_predictor) != len(self.__values):
+ raise ValueError("Predictor number of steps is incompatible with the values")
+ for i, item in enumerate(self.__values):
+ if numpy.asarray(_predictor[i]).size != numpy.asarray(item).size:
+ raise ValueError("Predictor size at step %i is incompatible with the values"%i)
+ try:
+ __n = self.shape()[0]
+ return [(numpy.linalg.norm(numpy.ravel(item) - numpy.ravel(_predictor[i]))**2 / __n) for i, item in enumerate(self.__values)]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+
+ msds=mses # Mean-Square Deviation (MSD=MSE)
+
+ def rmses(self, _predictor=None):
+ """
+ Root-Mean-Square Error (RMSE) ou Root-Mean-Square Deviation (RMSD)
+ rmse(dX) = sqrt( 1/n sum(dX_i**2) ) = sqrt( mse(dX) )
+
+ Renvoie la série, contenant à chaque pas, la RMSE des données au pas.
+ Il faut que le type de base soit compatible avec les types élémentaires
+ numpy. C'est réservé aux variables d'écarts ou d'incréments si le
+ prédicteur est None, sinon c'est appliqué à l'écart entre les données
+ au pas et le prédicteur au même pas.
+ """
+ if _predictor is None:
+ try:
+ __n = self.shape()[0]
+ return [(numpy.linalg.norm(item) / math.sqrt(__n)) for item in self.__values]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+ else:
+ if len(_predictor) != len(self.__values):
+ raise ValueError("Predictor number of steps is incompatible with the values")
+ for i, item in enumerate(self.__values):
+ if numpy.asarray(_predictor[i]).size != numpy.asarray(item).size:
+ raise ValueError("Predictor size at step %i is incompatible with the values"%i)
+ try:
+ __n = self.shape()[0]
+ return [(numpy.linalg.norm(numpy.ravel(item) - numpy.ravel(_predictor[i])) / math.sqrt(__n)) for i, item in enumerate(self.__values)]
+ except:
+ raise TypeError("Base type is incompatible with numpy")
+
+ rmsds = rmses # Root-Mean-Square Deviation (RMSD=RMSE)
+
def __preplots(self,
title = "",
xlabel = "",
persist = False,
pause = True,
):
- "Préparation des plots"
+ "Préparation des plots"
#
- # Vérification de la disponibilité du module Gnuplot
- try:
- import Gnuplot
- self.__gnuplot = Gnuplot
- except:
+ # Vérification de la disponibilité du module Gnuplot
+ if not has_gnuplot:
raise ImportError("The Gnuplot module is required to plot the object.")
#
- # Vérification et compléments sur les paramètres d'entrée
+ # Vérification et compléments sur les paramètres d'entrée
if persist:
- self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
+ Gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
else:
- self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
+ Gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
if ltitle is None:
ltitle = ""
- self.__g = self.__gnuplot.Gnuplot() # persist=1
- self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
+ self.__g = Gnuplot.Gnuplot() # persist=1
+ self.__g('set terminal '+Gnuplot.GnuplotOpts.default_term)
self.__g('set style data lines')
self.__g('set grid')
self.__g('set autoscale')
- self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
- self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
+ self.__g('set xlabel "'+str(xlabel)+'"')
+ self.__g('set ylabel "'+str(ylabel)+'"')
self.__title = title
self.__ltitle = ltitle
self.__pause = pause
pause = True,
):
"""
- Renvoie un affichage de la valeur à chaque pas, si elle est compatible
+ Renvoie un affichage de la valeur à chaque pas, si elle est compatible
avec un affichage Gnuplot (donc essentiellement un vecteur). Si
- l'argument "step" existe dans la liste des pas de stockage effectués,
- renvoie l'affichage de la valeur stockée à ce pas "step". Si l'argument
- "item" est correct, renvoie l'affichage de la valeur stockée au numéro
- "item". Par défaut ou en l'absence de "step" ou "item", renvoie un
+ l'argument "step" existe dans la liste des pas de stockage effectués,
+ renvoie l'affichage de la valeur stockée à ce pas "step". Si l'argument
+ "item" est correct, renvoie l'affichage de la valeur stockée au numéro
+ "item". Par défaut ou en l'absence de "step" ou "item", renvoie un
affichage successif de tous les pas.
Arguments :
- - step : valeur du pas à afficher
- - item : index de la valeur à afficher
+ - step : valeur du pas à afficher
+ - item : index de la valeur à afficher
- steps : liste unique des pas de l'axe des X, ou None si c'est
- la numérotation par défaut
- - title : base du titre général, qui sera automatiquement
- complétée par la mention du pas
+ la numérotation par défaut
+ - title : base du titre général, qui sera automatiquement
+ complétée par la mention du pas
- xlabel : label de l'axe des X
- ylabel : label de l'axe des Y
- - ltitle : titre associé au vecteur tracé
- - geometry : taille en pixels de la fenêtre et position du coin haut
- gauche, au format X11 : LxH+X+Y (défaut : 600x400)
+ - ltitle : titre associé au vecteur tracé
+ - geometry : taille en pixels de la fenêtre et position du coin haut
+ gauche, au format X11 : LxH+X+Y (défaut : 600x400)
- filename : base de nom de fichier Postscript pour une sauvegarde,
- qui est automatiquement complétée par le numéro du
- fichier calculé par incrément simple de compteur
- - dynamic : effectue un affichage des valeurs à chaque stockage
- (au-delà du second). La méthode "plots" permet de
- déclarer l'affichage dynamique, et c'est la méthode
- "__replots" qui est utilisée pour l'effectuer
- - persist : booléen indiquant que la fenêtre affichée sera
- conservée lors du passage au dessin suivant
- Par défaut, persist = False
- - pause : booléen indiquant une pause après chaque tracé, et
+ qui est automatiquement complétée par le numéro du
+ fichier calculé par incrément simple de compteur
+ - dynamic : effectue un affichage des valeurs à chaque stockage
+ (au-delà du second). La méthode "plots" permet de
+ déclarer l'affichage dynamique, et c'est la méthode
+ "__replots" qui est utilisée pour l'effectuer
+ - persist : booléen indiquant que la fenêtre affichée sera
+ conservée lors du passage au dessin suivant
+ Par défaut, persist = False
+ - pause : booléen indiquant une pause après chaque tracé, et
attendant un Return
- Par défaut, pause = True
+ Par défaut, pause = True
"""
- import os
if not self.__dynamic:
self.__preplots(title, xlabel, ylabel, ltitle, geometry, persist, pause )
if dynamic:
self.__dynamic = True
if len(self.__values) == 0: return 0
#
- # Tracé du ou des vecteurs demandés
+ # Tracé du ou des vecteurs demandés
indexes = []
if step is not None and step < len(self.__values):
indexes.append(step)
elif item is not None and item < len(self.__values):
indexes.append(item)
else:
- indexes = indexes + range(len(self.__values))
+ indexes = indexes + list(range(len(self.__values)))
#
i = -1
for index in indexes:
- self.__g('set title "'+str(title).encode('ascii','replace')+' (pas '+str(index)+')"')
+ self.__g('set title "'+str(title)+' (pas '+str(index)+')"')
if isinstance(steps,list) or isinstance(steps,numpy.ndarray):
Steps = list(steps)
else:
- Steps = range(len(self.__values[index]))
+ Steps = list(range(len(self.__values[index])))
#
- self.__g.plot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle ) )
+ self.__g.plot( Gnuplot.Data( Steps, self.__values[index], title=ltitle ) )
#
if filename != "":
i += 1
raise ValueError("Error: a file with this name \"%s\" already exists."%stepfilename)
self.__g.hardcopy(filename=stepfilename, color=1)
if self.__pause:
- raw_input('Please press return to continue...\n')
+ eval(input('Please press return to continue...\n'))
def __replots(self):
"""
"""
if self.__dynamic and len(self.__values) < 2: return 0
#
- self.__g('set title "'+str(self.__title).encode('ascii','replace'))
- Steps = range(len(self.__values))
- self.__g.plot( self.__gnuplot.Data( Steps, self.__values, title=self.__ltitle ) )
+ self.__g('set title "'+str(self.__title))
+ Steps = list(range(len(self.__values)))
+ self.__g.plot( Gnuplot.Data( Steps, self.__values, title=self.__ltitle ) )
#
if self.__pause:
- raw_input('Please press return to continue...\n')
+ eval(input('Please press return to continue...\n'))
# ---------------------------------------------------------
+ # On pourrait aussi utiliser d'autres attributs d'un "array" comme "tofile"
def mean(self):
"""
Renvoie la moyenne sur toutes les valeurs sans tenir compte de la
longueur des pas. Il faut que le type de base soit compatible avec
- les types élémentaires numpy.
+ les types élémentaires numpy.
"""
try:
- if self.__basetype in [int, float]:
- return float( numpy.array(self.__values).mean() )
- else:
- return numpy.array(self.__values).mean(axis=0)
+ return numpy.mean(self.__values, axis=0, dtype=mfp).astype('float')
except:
raise TypeError("Base type is incompatible with numpy")
def std(self, ddof=0):
"""
- Renvoie l'écart-type de toutes les valeurs sans tenir compte de la
+ Renvoie l'écart-type de toutes les valeurs sans tenir compte de la
longueur des pas. Il faut que le type de base soit compatible avec
- les types élémentaires numpy.
+ les types élémentaires numpy.
- ddof : c'est le nombre de degrés de liberté pour le calcul de
- l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
+ ddof : c'est le nombre de degrés de liberté pour le calcul de
+ l'écart-type, qui est dans le diviseur. Inutile avant Numpy 1.1
"""
try:
if numpy.version.version >= '1.1.0':
- return numpy.array(self.__values).std(ddof=ddof,axis=0)
+ return numpy.asarray(self.__values).std(ddof=ddof,axis=0).astype('float')
else:
- return numpy.array(self.__values).std(axis=0)
+ return numpy.asarray(self.__values).std(axis=0).astype('float')
except:
raise TypeError("Base type is incompatible with numpy")
"""
Renvoie la somme de toutes les valeurs sans tenir compte de la
longueur des pas. Il faut que le type de base soit compatible avec
- les types élémentaires numpy.
+ les types élémentaires numpy.
"""
try:
- return numpy.array(self.__values).sum(axis=0)
+ return numpy.asarray(self.__values).sum(axis=0)
except:
raise TypeError("Base type is incompatible with numpy")
"""
Renvoie le minimum de toutes les valeurs sans tenir compte de la
longueur des pas. Il faut que le type de base soit compatible avec
- les types élémentaires numpy.
+ les types élémentaires numpy.
"""
try:
- return numpy.array(self.__values).min(axis=0)
+ return numpy.asarray(self.__values).min(axis=0)
except:
raise TypeError("Base type is incompatible with numpy")
"""
Renvoie le maximum de toutes les valeurs sans tenir compte de la
longueur des pas. Il faut que le type de base soit compatible avec
- les types élémentaires numpy.
+ les types élémentaires numpy.
"""
try:
- return numpy.array(self.__values).max(axis=0)
+ return numpy.asarray(self.__values).max(axis=0)
except:
raise TypeError("Base type is incompatible with numpy")
def cumsum(self):
"""
- Renvoie la somme cumulée de toutes les valeurs sans tenir compte de la
+ Renvoie la somme cumulée de toutes les valeurs sans tenir compte de la
longueur des pas. Il faut que le type de base soit compatible avec
- les types élémentaires numpy.
+ les types élémentaires numpy.
"""
try:
- return numpy.array(self.__values).cumsum(axis=0)
+ return numpy.asarray(self.__values).cumsum(axis=0)
except:
raise TypeError("Base type is incompatible with numpy")
- # On pourrait aussi utiliser les autres attributs d'une "matrix", comme
- # "tofile", "min"...
-
def plot(self,
steps = None,
title = "",
pause = True,
):
"""
- Renvoie un affichage unique pour l'ensemble des valeurs à chaque pas, si
+ Renvoie un affichage unique pour l'ensemble des valeurs à chaque pas, si
elles sont compatibles avec un affichage Gnuplot (donc essentiellement
un vecteur). Si l'argument "step" existe dans la liste des pas de
- stockage effectués, renvoie l'affichage de la valeur stockée à ce pas
+ stockage effectués, renvoie l'affichage de la valeur stockée à ce pas
"step". Si l'argument "item" est correct, renvoie l'affichage de la
- valeur stockée au numéro "item".
+ valeur stockée au numéro "item".
Arguments :
- steps : liste unique des pas de l'axe des X, ou None si c'est
- la numérotation par défaut
- - title : base du titre général, qui sera automatiquement
- complétée par la mention du pas
+ la numérotation par défaut
+ - title : base du titre général, qui sera automatiquement
+ complétée par la mention du pas
- xlabel : label de l'axe des X
- ylabel : label de l'axe des Y
- - ltitle : titre associé au vecteur tracé
- - geometry : taille en pixels de la fenêtre et position du coin haut
- gauche, au format X11 : LxH+X+Y (défaut : 600x400)
+ - ltitle : titre associé au vecteur tracé
+ - geometry : taille en pixels de la fenêtre et position du coin haut
+ gauche, au format X11 : LxH+X+Y (défaut : 600x400)
- filename : nom de fichier Postscript pour une sauvegarde
- - persist : booléen indiquant que la fenêtre affichée sera
- conservée lors du passage au dessin suivant
- Par défaut, persist = False
- - pause : booléen indiquant une pause après chaque tracé, et
+ - persist : booléen indiquant que la fenêtre affichée sera
+ conservée lors du passage au dessin suivant
+ Par défaut, persist = False
+ - pause : booléen indiquant une pause après chaque tracé, et
attendant un Return
- Par défaut, pause = True
+ Par défaut, pause = True
"""
#
- # Vérification de la disponibilité du module Gnuplot
- try:
- import Gnuplot
- self.__gnuplot = Gnuplot
- except:
+ # Vérification de la disponibilité du module Gnuplot
+ if not has_gnuplot:
raise ImportError("The Gnuplot module is required to plot the object.")
#
- # Vérification et compléments sur les paramètres d'entrée
+ # Vérification et compléments sur les paramètres d'entrée
if persist:
- self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
+ Gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist -geometry '+geometry
else:
- self.__gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
+ Gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -geometry '+geometry
if ltitle is None:
ltitle = ""
if isinstance(steps,list) or isinstance(steps, numpy.ndarray):
Steps = list(steps)
else:
- Steps = range(len(self.__values[0]))
- self.__g = self.__gnuplot.Gnuplot() # persist=1
- self.__g('set terminal '+self.__gnuplot.GnuplotOpts.default_term)
+ Steps = list(range(len(self.__values[0])))
+ self.__g = Gnuplot.Gnuplot() # persist=1
+ self.__g('set terminal '+Gnuplot.GnuplotOpts.default_term)
self.__g('set style data lines')
self.__g('set grid')
self.__g('set autoscale')
- self.__g('set title "'+str(title).encode('ascii','replace') +'"')
- self.__g('set xlabel "'+str(xlabel).encode('ascii','replace')+'"')
- self.__g('set ylabel "'+str(ylabel).encode('ascii','replace')+'"')
+ self.__g('set title "'+str(title) +'"')
+ self.__g('set xlabel "'+str(xlabel)+'"')
+ self.__g('set ylabel "'+str(ylabel)+'"')
#
- # Tracé du ou des vecteurs demandés
- indexes = range(len(self.__values))
- self.__g.plot( self.__gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle+" (pas 0)" ) )
+ # Tracé du ou des vecteurs demandés
+ indexes = list(range(len(self.__values)))
+ self.__g.plot( Gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle+" (pas 0)" ) )
for index in indexes:
- self.__g.replot( self.__gnuplot.Data( Steps, self.__values[index], title=ltitle+" (pas %i)"%index ) )
+ self.__g.replot( Gnuplot.Data( Steps, self.__values[index], title=ltitle+" (pas %i)"%index ) )
#
if filename != "":
self.__g.hardcopy(filename=filename, color=1)
if pause:
- raw_input('Please press return to continue...\n')
+ eval(input('Please press return to continue...\n'))
# ---------------------------------------------------------
def setDataObserver(self, HookFunction = None, HookParameters = None, Scheduler = None):
"""
- Association à la variable d'un triplet définissant un observer
+ Association à la variable d'un triplet définissant un observer
- Le Scheduler attendu est une fréquence, une simple liste d'index ou un
- xrange des index.
+ Le Scheduler attendu est une fréquence, une simple liste d'index ou un
+ range des index.
"""
#
- # Vérification du Scheduler
+ # Vérification du Scheduler
# -------------------------
maxiter = int( 1e9 )
- if isinstance(Scheduler,int): # Considéré comme une fréquence à partir de 0
- Schedulers = xrange( 0, maxiter, int(Scheduler) )
- elif isinstance(Scheduler,xrange): # Considéré comme un itérateur
+ if isinstance(Scheduler,int): # Considéré comme une fréquence à partir de 0
+ Schedulers = range( 0, maxiter, int(Scheduler) )
+ elif isinstance(Scheduler,range): # Considéré comme un itérateur
Schedulers = Scheduler
- elif isinstance(Scheduler,list): # Considéré comme des index explicites
- Schedulers = [long(i) for i in Scheduler] # map( long, Scheduler )
- else: # Dans tous les autres cas, activé par défaut
- Schedulers = xrange( 0, maxiter )
+ elif isinstance(Scheduler,(list,tuple)): # Considéré comme des index explicites
+ Schedulers = [int(i) for i in Scheduler] #Â map( long, Scheduler )
+ else: # Dans tous les autres cas, activé par défaut
+ Schedulers = range( 0, maxiter )
#
# Stockage interne de l'observer dans la variable
# -----------------------------------------------
self.__dataobservers.append( [HookFunction, HookParameters, Schedulers] )
- def removeDataObserver(self, HookFunction = None):
+ def removeDataObserver(self, HookFunction = None, AllObservers = False):
"""
- Suppression d'un observer nommé sur la variable.
+ Suppression d'un observer nommé sur la variable.
On peut donner dans HookFunction la meme fonction que lors de la
- définition, ou un simple string qui est le nom de la fonction.
+ définition, ou un simple string qui est le nom de la fonction. Si
+ AllObservers est vrai, supprime tous les observers enregistrés.
"""
if hasattr(HookFunction,"func_name"):
name = str( HookFunction.func_name )
+ elif hasattr(HookFunction,"__name__"):
+ name = str( HookFunction.__name__ )
elif isinstance(HookFunction,str):
name = str( HookFunction )
else:
index_to_remove = []
for [hf, hp, hs] in self.__dataobservers:
i = i + 1
- if name is hf.func_name: index_to_remove.append( i )
+ if name is hf.__name__ or AllObservers: index_to_remove.append( i )
index_to_remove.reverse()
for i in index_to_remove:
self.__dataobservers.pop( i )
+ return len(index_to_remove)
+
+ def hasDataObserver(self):
+ return bool(len(self.__dataobservers) > 0)
+
+# ==============================================================================
+class SchedulerTrigger(object):
+ """
+ Classe générale d'interface de type Scheduler/Trigger
+ """
+ def __init__(self,
+ simplifiedCombo = None,
+ startTime = 0,
+ endTime = int( 1e9 ),
+ timeDelay = 1,
+ timeUnit = 1,
+ frequency = None,
+ ):
+ pass
# ==============================================================================
class OneScalar(Persistence):
"""
- Classe définissant le stockage d'une valeur unique réelle (float) par pas.
+ Classe définissant le stockage d'une valeur unique réelle (float) par pas.
- Le type de base peut être changé par la méthode "basetype", mais il faut que
- le nouveau type de base soit compatible avec les types par éléments de
- numpy. On peut même utiliser cette classe pour stocker des vecteurs/listes
- ou des matrices comme dans les classes suivantes, mais c'est déconseillé
+ Le type de base peut être changé par la méthode "basetype", mais il faut que
+ le nouveau type de base soit compatible avec les types par éléments de
+ numpy. On peut même utiliser cette classe pour stocker des vecteurs/listes
+ ou des matrices comme dans les classes suivantes, mais c'est déconseillé
pour conserver une signification claire des noms.
"""
def __init__(self, name="", unit="", basetype = float):
class OneIndex(Persistence):
"""
- Classe définissant le stockage d'une valeur unique entière (int) par pas.
+ Classe définissant le stockage d'une valeur unique entière (int) par pas.
"""
def __init__(self, name="", unit="", basetype = int):
Persistence.__init__(self, name, unit, basetype)
class OneVector(Persistence):
"""
- Classe de stockage d'une liste de valeurs numériques homogènes par pas. Ne
- pas utiliser cette classe pour des données hétérogènes, mais "OneList".
+ Classe de stockage d'une liste de valeurs numériques homogènes par pas. Ne
+ pas utiliser cette classe pour des données hétérogènes, mais "OneList".
"""
def __init__(self, name="", unit="", basetype = numpy.ravel):
Persistence.__init__(self, name, unit, basetype)
class OneMatrix(Persistence):
"""
- Classe de stockage d'une matrice de valeurs (numpy.matrix) par pas.
+ Classe de stockage d'une matrice de valeurs homogènes par pas.
"""
def __init__(self, name="", unit="", basetype = numpy.matrix):
Persistence.__init__(self, name, unit, basetype)
class OneList(Persistence):
"""
- Classe de stockage d'une liste de valeurs hétérogènes (list) par pas. Ne pas
- utiliser cette classe pour des données numériques homogènes, mais
+ Classe de stockage d'une liste de valeurs hétérogènes (list) par pas. Ne
+ pas utiliser cette classe pour des données numériques homogènes, mais
"OneVector".
"""
def __init__(self, name="", unit="", basetype = list):
class OneNoType(Persistence):
"""
Classe de stockage d'un objet sans modification (cast) de type. Attention,
- selon le véritable type de l'objet stocké à chaque pas, les opérations
- arithmétiques à base de numpy peuvent être invalides ou donner des résultats
- inattendus. Cette classe n'est donc à utiliser qu'à bon escient
- volontairement, et pas du tout par défaut.
+ selon le véritable type de l'objet stocké à chaque pas, les opérations
+ arithmétiques à base de numpy peuvent être invalides ou donner des
+ résultats inattendus. Cette classe n'est donc à utiliser qu'à bon escient
+ volontairement, et pas du tout par défaut.
"""
def __init__(self, name="", unit="", basetype = NoType):
Persistence.__init__(self, name, unit, basetype)
Structure de stockage permettant de rassembler plusieurs objets de
persistence.
- Des objets par défaut sont prévus, et des objets supplémentaires peuvent
- être ajoutés.
+ Des objets par défaut sont prévus, et des objets supplémentaires peuvent
+ être ajoutés.
"""
def __init__(self, name="", defaults=True):
"""
name : nom courant
- La gestion interne des données est exclusivement basée sur les variables
- initialisées ici (qui ne sont pas accessibles depuis l'extérieur des
- objets comme des attributs) :
- __StoredObjects : objets de type persistence collectés dans cet objet
+ La gestion interne des données est exclusivement basée sur les
+ variables initialisées ici (qui ne sont pas accessibles depuis
+ l'extérieur des objets comme des attributs) :
+ __StoredObjects : objets de type persistence collectés dans cet objet
"""
self.__name = str(name)
#
def add_object(self, name=None, persistenceType=Persistence, basetype=None ):
"""
- Ajoute dans les objets stockables un nouvel objet défini par son nom, son
- type de Persistence et son type de base à chaque pas.
+ Ajoute dans les objets stockables un nouvel objet défini par son nom,
+ son type de Persistence et son type de base à chaque pas.
"""
if name is None: raise ValueError("Object name is required for adding an object.")
if name in self.__StoredObjects.keys():
def get_object(self, name=None ):
"""
- Renvoie l'objet de type Persistence qui porte le nom demandé.
+ Renvoie l'objet de type Persistence qui porte le nom demandé.
"""
if name is None: raise ValueError("Object name is required for retrieving an object.")
if name not in self.__StoredObjects.keys():
def set_object(self, name=None, objet=None ):
"""
- Affecte directement un 'objet' qui porte le nom 'name' demandé.
- Attention, il n'est pas effectué de vérification sur le type, qui doit
- comporter les méthodes habituelles de Persistence pour que cela
+ Affecte directement un 'objet' qui porte le nom 'name' demandé.
+ Attention, il n'est pas effectué de vérification sur le type, qui doit
+ comporter les méthodes habituelles de Persistence pour que cela
fonctionne.
"""
if name is None: raise ValueError("Object name is required for setting an object.")
del self.__StoredObjects[name]
# ---------------------------------------------------------
- # Méthodes d'accès de type dictionnaire
+ # Méthodes d'accès de type dictionnaire
def __getitem__(self, name=None ):
"x.__getitem__(y) <==> x[y]"
return self.get_object( name )
# ---------------------------------------------------------
def get_stored_objects(self, hideVoidObjects = False):
- "Renvoie la liste des objets présents"
+ "Renvoie la liste des objets présents"
objs = self.__StoredObjects.keys()
if hideVoidObjects:
usedObjs = []
finally:
pass
objs = usedObjs
- objs.sort()
+ objs = sorted(objs)
return objs
# ---------------------------------------------------------
def save_composite(self, filename=None, mode="pickle", compress="gzip"):
"""
- Enregistre l'objet dans le fichier indiqué selon le "mode" demandé,
+ Enregistre l'objet dans le fichier indiqué selon le "mode" demandé,
et renvoi le nom du fichier
"""
- import os
if filename is None:
if compress == "gzip":
filename = os.tempnam( os.getcwd(), 'dacp' ) + ".pkl.gz"
else:
filename = os.path.abspath( filename )
#
- import cPickle
if mode == "pickle":
if compress == "gzip":
- import gzip
output = gzip.open( filename, 'wb')
elif compress == "bzip2":
- import bz2
output = bz2.BZ2File( filename, 'wb')
else:
output = open( filename, 'wb')
- cPickle.dump(self, output)
+ pickle.dump(self, output)
output.close()
else:
raise ValueError("Save mode '%s' unknown. Choose another one."%mode)
def load_composite(self, filename=None, mode="pickle", compress="gzip"):
"""
- Recharge un objet composite sauvé en fichier
+ Recharge un objet composite sauvé en fichier
"""
- import os
if filename is None:
raise ValueError("A file name if requested to load a composite.")
else:
filename = os.path.abspath( filename )
#
- import cPickle
if mode == "pickle":
if compress == "gzip":
- import gzip
pkl_file = gzip.open( filename, 'rb')
elif compress == "bzip2":
- import bz2
pkl_file = bz2.BZ2File( filename, 'rb')
else:
pkl_file = open(filename, 'rb')
- output = cPickle.load(pkl_file)
+ output = pickle.load(pkl_file)
for k in output.keys():
self[k] = output[k]
else:
# ==============================================================================
if __name__ == "__main__":
- print('\n AUTODIAGNOSTIC \n')
+ print('\n AUTODIAGNOSTIC\n')
