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:
+from daCore.PlatformInfo import PathManagement ; PathManagement() # noqa: E702,E203
+from daCore.PlatformInfo import PlatformInfo
+lpi = PlatformInfo()
+mfp = lpi.MaximumPrecision()
+
+if lpi.has_gnuplot:
import Gnuplot
# ==============================================================================
__slots__ = (
"__name", "__unit", "__basetype", "__values", "__tags", "__dynamic",
"__g", "__title", "__ltitle", "__pause", "__dataobservers",
- )
- #
+ )
+
def __init__(self, name="", unit="", basetype=str):
"""
name : nom courant
"""
Stocke une valeur avec ses informations de filtrage.
"""
- if value is None: raise ValueError("Value argument required")
+ if value is None:
+ raise ValueError("Value argument required")
#
self.__values.append(copy.copy(self.__basetype(value)))
self.__tags.append(kwargs)
#
- if self.__dynamic: self.__replots()
+ if self.__dynamic:
+ self.__replots()
__step = len(self.__values) - 1
- for hook, parameters, scheduler in self.__dataobservers:
+ for hook, parameters, scheduler, order, osync, dovar in self.__dataobservers:
if __step in scheduler:
- hook( self, parameters )
+ if order is None or dovar is None:
+ hook( self, parameters )
+ else:
+ if not isinstance(order, (list, tuple)):
+ continue
+ if not isinstance(dovar, dict):
+ continue
+ if not bool(osync): # Async observation
+ hook( self, parameters, order, dovar )
+ else: # Sync observations
+ for v in order:
+ if len(dovar[v]) != len(self):
+ break
+ else:
+ hook( self, parameters, order, dovar )
def pop(self, item=None):
"""
def __str__(self):
"x.__str__() <==> str(x)"
msg = " Index Value Tags\n"
- for i,v in enumerate(self.__values):
- msg += " i=%05i %10s %s\n"%(i,v,self.__tags[i])
+ for iv, vv in enumerate(self.__values):
+ msg += " i=%05i %10s %s\n"%(iv, vv, self.__tags[iv])
return msg
def __len__(self):
def index(self, value, start=0, stop=None):
"L.index(value, [start, [stop]]) -> integer -- return first index of value."
- if stop is None : stop = len(self.__values)
+ if stop is None:
+ stop = len(self.__values)
return self.__values.index(value, start, stop)
# ---------------------------------------------------------
if tagKey in self.__tags[i]:
if self.__tags[i][tagKey] == kwargs[tagKey]:
__tmp.append( i )
- elif isinstance(kwargs[tagKey],(list,tuple)) and self.__tags[i][tagKey] in kwargs[tagKey]:
+ elif isinstance(kwargs[tagKey], (list, tuple)) and self.__tags[i][tagKey] in kwargs[tagKey]:
__tmp.append( i )
__indexOfFilteredItems = __tmp
- if len(__indexOfFilteredItems) == 0: break
+ if len(__indexOfFilteredItems) == 0:
+ break
return __indexOfFilteredItems
# ---------------------------------------------------------
__indexOfFilteredItems = self.__filteredIndexes(**kwargs)
return [self.__values[i] for i in __indexOfFilteredItems]
- def keys(self, keyword=None , **kwargs):
+ def keys(self, keyword=None, **kwargs):
"D.keys() -> list of D's keys"
__indexOfFilteredItems = self.__filteredIndexes(**kwargs)
__keys = []
__keys.append( None )
return __keys
- def items(self, keyword=None , **kwargs):
+ def items(self, keyword=None, **kwargs):
"D.items() -> list of D's (key, value) pairs, as 2-tuples"
__indexOfFilteredItems = self.__filteredIndexes(**kwargs)
__pairs = []
__indexOfFilteredItems = [item,]
#
# Dans le cas où la sortie donne les valeurs d'un "outputTag"
- if outputTag is not None and isinstance(outputTag,str) :
+ if outputTag is not None and isinstance(outputTag, str):
outputValues = []
for index in __indexOfFilteredItems:
if outputTag in self.__tags[index].keys():
élémentaires numpy.
"""
try:
- return [numpy.mean(item, dtype=mfp).astype('float') for item in self.__values]
+ __sr = [numpy.mean(item, dtype=mfp).astype('float') for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def stds(self, ddof=0):
"""
"""
try:
if numpy.version.version >= '1.1.0':
- return [numpy.array(item).std(ddof=ddof, dtype=mfp).astype('float') for item in self.__values]
+ __sr = [numpy.array(item).std(ddof=ddof, dtype=mfp).astype('float') for item in self.__values]
else:
return [numpy.array(item).std(dtype=mfp).astype('float') for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def sums(self):
"""
numpy.
"""
try:
- return [numpy.array(item).sum() for item in self.__values]
+ __sr = [numpy.array(item).sum() for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def mins(self):
"""
numpy.
"""
try:
- return [numpy.array(item).min() for item in self.__values]
+ __sr = [numpy.array(item).min() for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def maxs(self):
"""
numpy.
"""
try:
- return [numpy.array(item).max() for item in self.__values]
+ __sr = [numpy.array(item).max() for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def powers(self, x2):
"""
numpy.
"""
try:
- return [numpy.power(item, x2) for item in self.__values]
+ __sr = [numpy.power(item, x2) for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def norms(self, _ord=None):
"""
numpy.
"""
try:
- return [numpy.linalg.norm(item, _ord) for item in self.__values]
+ __sr = [numpy.linalg.norm(item, _ord) for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def traces(self, offset=0):
"""
types élémentaires numpy.
"""
try:
- return [numpy.trace(item, offset, dtype=mfp) for item in self.__values]
+ __sr = [numpy.trace(item, offset, dtype=mfp).astype('float') for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def maes(self, _predictor=None):
"""
"""
if _predictor is None:
try:
- return [numpy.mean(numpy.abs(item)) for item in self.__values]
+ __sr = [numpy.mean(numpy.abs(item)) for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
else:
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)]
+ __sr = [numpy.mean(numpy.abs(numpy.ravel(item) - numpy.ravel(_predictor[i]))) for i, item in enumerate(self.__values)]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
def mses(self, _predictor=None):
"""
if _predictor is None:
try:
__n = self.shape()[0]
- return [(numpy.linalg.norm(item)**2 / __n) for item in self.__values]
+ __sr = [(numpy.linalg.norm(item)**2 / __n) for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
else:
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)]
+ __sr = [(numpy.linalg.norm(numpy.ravel(item) - numpy.ravel(_predictor[i]))**2 / __n) for i, item in enumerate(self.__values)]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
- msds=mses # Mean-Square Deviation (MSD=MSE)
+ msds = mses # Mean-Square Deviation (MSD=MSE)
def rmses(self, _predictor=None):
"""
if _predictor is None:
try:
__n = self.shape()[0]
- return [(numpy.linalg.norm(item) / math.sqrt(__n)) for item in self.__values]
+ __sr = [(numpy.linalg.norm(item) / math.sqrt(__n)) for item in self.__values]
except Exception:
raise TypeError("Base type is incompatible with numpy")
else:
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)]
+ __sr = [(numpy.linalg.norm(numpy.ravel(item) - numpy.ravel(_predictor[i])) / math.sqrt(__n)) for i, item in enumerate(self.__values)]
except Exception:
raise TypeError("Base type is incompatible with numpy")
+ return numpy.array(__sr).tolist()
- rmsds = rmses # Root-Mean-Square Deviation (RMSD=RMSE)
+ rmsds = rmses # Root-Mean-Square Deviation (RMSD=RMSE)
def __preplots(self,
title = "",
ltitle = None,
geometry = "600x400",
persist = False,
- pause = True,
- ):
+ pause = True ):
"Préparation des plots"
#
# Vérification de la disponibilité du module Gnuplot
- if not has_gnuplot:
+ if not lpi.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
- if ltitle is None: ltitle = ""
+ if ltitle is None:
+ ltitle = ""
__geometry = str(geometry)
- __sizespec = (__geometry.split('+')[0]).replace('x',',')
+ __sizespec = (__geometry.split('+')[0]).replace('x', ',')
#
if persist:
Gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist '
#
- self.__g = Gnuplot.Gnuplot() # persist=1
- self.__g('set terminal '+Gnuplot.GnuplotOpts.default_term+' size '+__sizespec)
+ self.__g = Gnuplot.Gnuplot() # persist=1
+ self.__g('set terminal ' + Gnuplot.GnuplotOpts.default_term + ' size ' + __sizespec)
self.__g('set style data lines')
self.__g('set grid')
self.__g('set autoscale')
- self.__g('set xlabel "'+str(xlabel)+'"')
- self.__g('set ylabel "'+str(ylabel)+'"')
+ self.__g('set xlabel "' + str(xlabel) + '"')
+ self.__g('set ylabel "' + str(ylabel) + '"')
self.__title = title
self.__ltitle = ltitle
self.__pause = pause
filename = "",
dynamic = False,
persist = False,
- pause = True,
- ):
+ pause = True ):
"""
Renvoie un affichage de la valeur à chaque pas, si elle est compatible
avec un affichage Gnuplot (donc essentiellement un vecteur). Si
self.__preplots(title, xlabel, ylabel, ltitle, geometry, persist, pause )
if dynamic:
self.__dynamic = True
- if len(self.__values) == 0: return 0
+ if len(self.__values) == 0:
+ return 0
#
# Tracé du ou des vecteurs demandés
indexes = []
#
i = -1
for index in indexes:
- self.__g('set title "'+str(title)+' (pas '+str(index)+')"')
+ self.__g('set title "' + str(title) + ' (pas ' + str(index) + ')"')
if isinstance(steps, (list, numpy.ndarray)):
Steps = list(steps)
else:
#
if filename != "":
i += 1
- stepfilename = "%s_%03i.ps"%(filename,i)
+ stepfilename = "%s_%03i.ps"%(filename, i)
if os.path.isfile(stepfilename):
raise ValueError("Error: a file with this name \"%s\" already exists."%stepfilename)
self.__g.hardcopy(filename=stepfilename, color=1)
"""
Affichage dans le cas du suivi dynamique de la variable
"""
- if self.__dynamic and len(self.__values) < 2: return 0
+ if self.__dynamic and len(self.__values) < 2:
+ return 0
#
- self.__g('set title "'+str(self.__title))
+ self.__g('set title "' + str(self.__title))
Steps = list(range(len(self.__values)))
self.__g.plot( Gnuplot.Data( Steps, self.__values, title=self.__ltitle ) )
#
"""
try:
if numpy.version.version >= '1.1.0':
- return numpy.asarray(self.__values).std(ddof=ddof,axis=0).astype('float')
+ return numpy.asarray(self.__values).std(ddof=ddof, axis=0).astype('float')
else:
return numpy.asarray(self.__values).std(axis=0).astype('float')
except Exception:
geometry = "600x400",
filename = "",
persist = False,
- pause = True,
- ):
+ pause = True ):
"""
Renvoie un affichage unique pour l'ensemble des valeurs à chaque pas, si
elles sont compatibles avec un affichage Gnuplot (donc essentiellement
"""
#
# Vérification de la disponibilité du module Gnuplot
- if not has_gnuplot:
+ if not lpi.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
- if ltitle is None: ltitle = ""
+ if ltitle is None:
+ ltitle = ""
if isinstance(steps, (list, numpy.ndarray)):
Steps = list(steps)
else:
Steps = list(range(len(self.__values[0])))
__geometry = str(geometry)
- __sizespec = (__geometry.split('+')[0]).replace('x',',')
+ __sizespec = (__geometry.split('+')[0]).replace('x', ',')
#
if persist:
Gnuplot.GnuplotOpts.gnuplot_command = 'gnuplot -persist '
#
- self.__g = Gnuplot.Gnuplot() # persist=1
- self.__g('set terminal '+Gnuplot.GnuplotOpts.default_term+' size '+__sizespec)
+ self.__g = Gnuplot.Gnuplot() # persist=1
+ self.__g('set terminal ' + Gnuplot.GnuplotOpts.default_term + ' size ' + __sizespec)
self.__g('set style data lines')
self.__g('set grid')
self.__g('set autoscale')
- self.__g('set title "'+str(title) +'"')
- self.__g('set xlabel "'+str(xlabel)+'"')
- self.__g('set ylabel "'+str(ylabel)+'"')
+ 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 = list(range(len(self.__values)))
- self.__g.plot( Gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle+" (pas 0)" ) )
+ self.__g.plot( Gnuplot.Data( Steps, self.__values[indexes.pop(0)], title=ltitle + " (pas 0)" ) )
for index in indexes:
- self.__g.replot( 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)
raise TypeError("Base type is incompatible with numpy")
# ---------------------------------------------------------
- def setDataObserver(self, HookFunction = None, HookParameters = None, Scheduler = None):
+ def setDataObserver(self, HookFunction = None, HookParameters = None, Scheduler = None, Order = None, OSync = True, DOVar = 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
- range des index.
+ Les variables Order et DOVar sont utilisées pour un observer
+ multi-variable. Le Scheduler attendu est une fréquence, une simple
+ liste d'index ou un range des index.
"""
#
# Vérification du Scheduler
# -------------------------
maxiter = int( 1e9 )
- if isinstance(Scheduler,int): # Considéré comme une fréquence à partir de 0
+ 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
+ elif isinstance(Scheduler, range): # Considéré comme un itérateur
Schedulers = Scheduler
- 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
+ elif isinstance(Scheduler, (list, tuple)): # Considéré comme des index explicites
+ Schedulers = [int(i) for i in Scheduler] # Similaire à map( int, Scheduler ) # noqa: E262
+ 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] )
+ self.__dataobservers.append( [HookFunction, HookParameters, Schedulers, Order, OSync, DOVar] )
def removeDataObserver(self, HookFunction = None, AllObservers = False):
"""
Suppression d'un observer nommé sur la variable.
- On peut donner dans HookFunction la meme fonction que lors de la
+ On peut donner dans HookFunction la même fonction que lors de la
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"):
+ if hasattr(HookFunction, "func_name"):
name = str( HookFunction.func_name )
- elif hasattr(HookFunction,"__name__"):
+ elif hasattr(HookFunction, "__name__"):
name = str( HookFunction.__name__ )
- elif isinstance(HookFunction,str):
+ elif isinstance(HookFunction, str):
name = str( HookFunction )
else:
name = None
#
- i = -1
+ ih = -1
index_to_remove = []
- for [hf, hp, hs] in self.__dataobservers:
- i = i + 1
- if name is hf.__name__ or AllObservers: index_to_remove.append( i )
+ for [hf, _, _, _, _, _] in self.__dataobservers:
+ ih = ih + 1
+ if name is hf.__name__ or AllObservers:
+ index_to_remove.append( ih )
index_to_remove.reverse()
- for i in index_to_remove:
- self.__dataobservers.pop( i )
+ for ih in index_to_remove:
+ self.__dataobservers.pop( ih )
return len(index_to_remove)
def hasDataObserver(self):
Classe générale d'interface de type Scheduler/Trigger
"""
__slots__ = ()
- #
+
def __init__(self,
simplifiedCombo = None,
startTime = 0,
endTime = int( 1e9 ),
timeDelay = 1,
timeUnit = 1,
- frequency = None,
- ):
+ frequency = None ):
pass
# ==============================================================================
pour conserver une signification claire des noms.
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = float):
Persistence.__init__(self, name, unit, basetype)
Classe définissant le stockage d'une valeur unique entière (int) par pas.
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = int):
Persistence.__init__(self, name, unit, basetype)
pas utiliser cette classe pour des données hétérogènes, mais "OneList".
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = numpy.ravel):
Persistence.__init__(self, name, unit, basetype)
Classe de stockage d'une matrice de valeurs homogènes par pas.
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = numpy.array):
Persistence.__init__(self, name, unit, basetype)
Classe de stockage d'une matrice de valeurs homogènes par pas.
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = numpy.matrix):
Persistence.__init__(self, name, unit, basetype)
"OneVector".
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = list):
Persistence.__init__(self, name, unit, basetype)
volontairement, et pas du tout par défaut.
"""
__slots__ = ()
- #
+
def __init__(self, name="", unit="", basetype = NoType):
Persistence.__init__(self, name, unit, basetype)
être ajoutés.
"""
__slots__ = ("__name", "__StoredObjects")
- #
+
def __init__(self, name="", defaults=True):
"""
name : nom courant
"""
Stockage d'une valeur "value" pour le "step" dans la variable "name".
"""
- if name is None: raise ValueError("Storable object name is required for storage.")
+ if name is None:
+ raise ValueError("Storable object name is required for storage.")
if name not in self.__StoredObjects.keys():
raise ValueError("No such name '%s' exists in storable objects."%name)
self.__StoredObjects[name].store( value=value, **kwargs )
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 is None:
+ raise ValueError("Object name is required for adding an object.")
if name in self.__StoredObjects.keys():
raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name)
if basetype is None:
"""
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 is None:
+ raise ValueError("Object name is required for retrieving an object.")
if name not in self.__StoredObjects.keys():
raise ValueError("No such name '%s' exists in stored objects."%name)
return self.__StoredObjects[name]
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.")
+ if name is None:
+ raise ValueError("Object name is required for setting an object.")
if name in self.__StoredObjects.keys():
raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name)
self.__StoredObjects[name] = objet
"""
Supprime un objet de la liste des objets stockables.
"""
- if name is None: raise ValueError("Object name is required for retrieving an object.")
+ if name is None:
+ raise ValueError("Object name is required for retrieving an object.")
if name not in self.__StoredObjects.keys():
raise ValueError("No such name '%s' exists in stored objects."%name)
del self.__StoredObjects[name]
usedObjs = []
for k in objs:
try:
- if len(self.__StoredObjects[k]) > 0: usedObjs.append( k )
+ if len(self.__StoredObjects[k]) > 0:
+ usedObjs.append( k )
finally:
pass
objs = usedObjs
