YACS donné, qui a préalablement été généré par l'utilisateur en interface
graphique. Dans ce cas, en ayant pris soin de remplacer les textes contenus
entre les symboles ``<...>``, il suffit d'enregistrer le script de commandes
-Shell suivant::
+Shell suivant :
+::
#!/bin/bash
USERDIR="<Répertoire du fichier JDC ADAO>"
Un exemple un peu plus complet consiste à lancer l'exécution d'un schéma YACS
indiqué par l'utilisateur, en ayant préalablement vérifié sa disponibilité. Pour
cela, en remplaçant le texte ``<Répertoire principal d'installation de
-SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant::
+SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant :
+::
#!/bin/bash
if (test $# != 1)
(fichier ".xml"). A la fin du script, on choisit aussi de supprimer le fichier
de ``<Schéma xml YACS ADAO>`` car c'est un fichier généré. Pour cela, en ayant
bien pris soin de remplacer le texte ``<Répertoire principal d'installation de
-SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant::
+SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant :
+::
#!/bin/bash
if (test $# != 1)
un schéma XML peut être chargé en python. On donne ici une séquence complète de
commandes pour tester la validité du schéma avant de l'exécuter, ajoutant des
lignes supplémentaires initiales pour charger de manière explicite le catalogue
-de types pour éviter d'obscures difficultés::
+de types pour éviter d'obscures difficultés :
+::
#-*- coding: utf-8 -*-
import pilot
détails). Ce dernier est disponible dans SALOME en lançant l'interpréteur R dans
le shell "``salome shell``". Il faut de plus disposer, en R, du package
"*rPython*", qui peut si nécessaire être installé par l'utilisateur à l'aide de
-la commande R suivante::
+la commande R suivante :
+::
#-*- coding: utf-8 -*-
#
utilisant des données et des informations depuis R. La démarche est illustrée
sur :ref:`subsection_tui_example`, proposé dans la description de l'interface
API/TUI. Dans l'interpréteur R, on peut exécuter les commandes suivantes,
-directement issues de l'exemple simple::
+directement issues de l'exemple simple :
+::
#-*- coding: utf-8 -*-
#
case.execute()
")
-dont le résultat est::
+dont le résultat est :
+::
Analysis [ 0.25000264 0.79999797 0.94999939]
oeuvre. On peut transformer l'exemple ci-dessus pour utiliser des données
provenant de R pour alimenter les trois variables d'ébauche, d'observation et
d'opérateur d'observation. On récupère à la fin l'état optimal dans une variable
-R aussi. Les autres lignes sont identiques. L'exemple devient ainsi::
+R aussi. Les autres lignes sont identiques. L'exemple devient ainsi :
+::
#-*- coding: utf-8 -*-
#
Pour faciliter l'édition rapide avec EFICAS d'ADAO d'un fichier de commandes
ADAO (JDC, ou paire de fichiers ".comm/.py", qui se trouvent ensemble dans un
-répertoire), on peut lancer l'interface graphique depuis l'interpréteur Python.
-Pour cela, dans un interpréteur Python obtenu depuis le "SALOME shell", on
-utilise les commandes suivantes::
+répertoire d'étude de l'utilisateur), on peut lancer l'interface graphique
+directement depuis l'interpréteur Python. Pour cela, dans un interpréteur
+Python obtenu depuis le "SALOME shell", on utilise les commandes suivantes :
+::
from adao import adaoBuilder
adaoBuilder.Gui()
-si nécessaire, des messages explicites permettent d'identifier les variables
+Si nécessaire, des messages explicites permettent d'identifier les variables
d'environnement requises qui seraient absentes. Cette commande ne doit
néanmoins pas être lancée dans la console Python de SALOME (car dans ce cas il
-suffit d'activer le module...), mais elle peut l'être dans une session "SALOME
-shell" obtenue depuis le menu "Outils/Extensions" de SALOME. Pour mémoire, le
-moyen le plus simple d'obtenir un interpréteur Python inclu dans une session
-"SALOME shell" est de lancer la commande suivante dans un terminal::
+suffit d'activer le module puisque l'on est déjà dans l'interface
+graphique...), mais elle peut l'être dans une session "SALOME shell" obtenue
+depuis le menu "Outils/Extensions" de SALOME. Pour mémoire, le moyen le plus
+simple d'obtenir un interpréteur Python inclu dans une session "SALOME shell"
+est de lancer la commande suivante dans un terminal :
+::
$SALOMEDIR/salome shell -- python
"*ERROR*", "*CRITICAL*". Toutes les informations associées à un niveau sont
affichées à tous les niveaux au-dessus de celui-ci (inclut). La méthode la plus
facile consiste à changer le niveau de surveillance en utilisant les lignes
-Python suivantes::
+Python suivantes :
+::
import logging
logging.getLogger().setLevel(logging.DEBUG)
ce que vos fichiers scripts utilisateurs utilisent une syntaxe compatible avec
Python 2 et avec Python 3. En particulier, on recommande d'utiliser la syntaxe
fonctionnelle pour les "*print*" et non pas la syntaxe "*commande*", comme par
-exemple::
+exemple :
+::
# Python 2 & 3
x, unit = 1., "cm"
print( "x = %s %s"%(str(x),str(unit)) )
-ou::
+ou :
+::
# Python 2 & 3
x, unit = 1., "cm"
print( "x = {0} {1}".format(str(x),str(unit)) )
-plutôt que::
+plutôt que :
+::
# Python 2 uniquement
x, unit = 1., "cm"
Il y a une incompatibilité introduite dans les fichiers de script de
post-processing ou d'observers. L'ancienne syntaxe pour interroger un objet
résultat, comme celui d'analyse "*Analysis*" (fourni dans un script à travers le
-mot-clé "*UserPostAnalysis*"), était par exemple::
+mot-clé "*UserPostAnalysis*"), était par exemple :
+::
Analysis = ADD.get("Analysis").valueserie(-1)
Analysis = ADD.get("Analysis").valueserie()
La nouvelle syntaxe est entièrement compatible avec celle (classique) pour les
-objets de type liste ou tuple::
+objets de type liste ou tuple :
+::
Analysis = ADD.get("Analysis")[-1]
Analysis = ADD.get("Analysis")[:]
def ExecuteFunction( triplet ):
assert len(triplet) == 3, "Incorrect number of arguments"
X, xArgs, funcrepr = triplet
- __X = numpy.asmatrix(numpy.ravel( X )).T
+ __X = numpy.ravel( X ).reshape((-1,1))
__sys_path_tmp = sys.path ; sys.path.insert(0,funcrepr["__userFunction__path"])
__module = __import__(funcrepr["__userFunction__modl"], globals(), locals(), [])
__fonction = getattr(__module,funcrepr["__userFunction__name"])
if dX is None:
self.__dX = None
else:
- self.__dX = numpy.asmatrix(numpy.ravel( dX )).T
+ self.__dX = numpy.ravel( dX )
logging.debug("FDA Reduction des doublons de calcul : %s"%self.__avoidRC)
if self.__avoidRC:
logging.debug("FDA Tolerance de determination des doublons : %.2e"%self.__tolerBP)
if self.__mfEnabled:
_HX = self.__userFunction( X, argsAsSerie = True )
else:
- _X = numpy.asmatrix(numpy.ravel( X )).T
- _HX = numpy.ravel(self.__userFunction( _X ))
+ _HX = numpy.ravel(self.__userFunction( numpy.ravel(X) ))
#
return _HX
if X is None or len(X)==0:
raise ValueError("Nominal point X for approximate derivatives can not be None or void (given X: %s)."%(str(X),))
#
- _X = numpy.asmatrix(numpy.ravel( X )).T
+ _X = numpy.ravel( X )
#
if self.__dX is None:
_dX = self.__increment * _X
else:
- _dX = numpy.asmatrix(numpy.ravel( self.__dX )).T
+ _dX = numpy.ravel( self.__dX )
+ assert len(_X) == len(_dX), "Inconsistent dX increment length with respect to the X one"
+ assert _X.size == _dX.size, "Inconsistent dX increment size with respect to the X one"
#
if (_dX == 0.).any():
moyenne = _dX.mean()
__bidon, __alreadyCalculatedI = self.__doublon__(_dX, self.__listJPCI, self.__listJPIN, None)
if __alreadyCalculatedP == __alreadyCalculatedI > -1:
__alreadyCalculated, __i = True, __alreadyCalculatedP
- logging.debug("FDA Cas J déja calculé, récupération du doublon %i"%__i)
+ logging.debug("FDA Cas J déjà calculé, récupération du doublon %i"%__i)
#
if __alreadyCalculated:
logging.debug("FDA Calcul Jacobienne (par récupération du doublon %i)"%__i)
_jobs = []
for i in range( len(_dX) ):
_dXi = _dX[i]
- _X_plus_dXi = numpy.array( _X.A1, dtype=float )
+ _X_plus_dXi = numpy.array( _X, dtype=float )
_X_plus_dXi[i] = _X[i] + _dXi
- _X_moins_dXi = numpy.array( _X.A1, dtype=float )
+ _X_moins_dXi = numpy.array( _X, dtype=float )
_X_moins_dXi[i] = _X[i] - _dXi
#
_jobs.append( (_X_plus_dXi, self.__extraArgs, funcrepr) )
_xserie = []
for i in range( len(_dX) ):
_dXi = _dX[i]
- _X_plus_dXi = numpy.array( _X.A1, dtype=float )
+ _X_plus_dXi = numpy.array( _X, dtype=float )
_X_plus_dXi[i] = _X[i] + _dXi
- _X_moins_dXi = numpy.array( _X.A1, dtype=float )
+ _X_moins_dXi = numpy.array( _X, dtype=float )
_X_moins_dXi[i] = _X[i] - _dXi
#
_xserie.append( _X_plus_dXi )
_Jacobienne = []
for i in range( _dX.size ):
_dXi = _dX[i]
- _X_plus_dXi = numpy.array( _X.A1, dtype=float )
+ _X_plus_dXi = numpy.array( _X, dtype=float )
_X_plus_dXi[i] = _X[i] + _dXi
- _X_moins_dXi = numpy.array( _X.A1, dtype=float )
+ _X_moins_dXi = numpy.array( _X, dtype=float )
_X_moins_dXi[i] = _X[i] - _dXi
#
_HX_plus_dXi = self.DirectOperator( _X_plus_dXi )
"__userFunction__name" : self.__userFunction__name,
}
_jobs = []
- _jobs.append( (_X.A1, self.__extraArgs, funcrepr) )
+ _jobs.append( (_X, self.__extraArgs, funcrepr) )
for i in range( len(_dX) ):
- _X_plus_dXi = numpy.array( _X.A1, dtype=float )
+ _X_plus_dXi = numpy.array( _X, dtype=float )
_X_plus_dXi[i] = _X[i] + _dX[i]
#
_jobs.append( (_X_plus_dXi, self.__extraArgs, funcrepr) )
#
elif self.__mfEnabled:
_xserie = []
- _xserie.append( _X.A1 )
+ _xserie.append( _X )
for i in range( len(_dX) ):
- _X_plus_dXi = numpy.array( _X.A1, dtype=float )
+ _X_plus_dXi = numpy.array( _X, dtype=float )
_X_plus_dXi[i] = _X[i] + _dX[i]
#
_xserie.append( _X_plus_dXi )
_HX = self.DirectOperator( _X )
for i in range( _dX.size ):
_dXi = _dX[i]
- _X_plus_dXi = numpy.array( _X.A1, dtype=float )
+ _X_plus_dXi = numpy.array( _X, dtype=float )
_X_plus_dXi[i] = _X[i] + _dXi
#
_HX_plus_dXi = self.DirectOperator( _X_plus_dXi )
_Jacobienne.append( numpy.ravel(( _HX_plus_dXi - _HX ) / _dXi) )
#
#
- _Jacobienne = numpy.asmatrix( numpy.vstack( _Jacobienne ) ).T
+ _Jacobienne = numpy.transpose( numpy.vstack( _Jacobienne ) )
if self.__avoidRC:
if self.__lenghtRJ < 0: self.__lenghtRJ = 2 * _X.size
while len(self.__listJPCP) > self.__lenghtRJ:
#
# Calcul de la valeur linéarisée de H en X appliqué à dX
# ------------------------------------------------------
- _dX = numpy.asmatrix(numpy.ravel( dX )).T
+ _dX = numpy.ravel( dX )
_HtX = numpy.dot(_Jacobienne, _dX)
- if self.__mfEnabled: return [_HtX.A1,]
- else: return _HtX.A1
+ if self.__mfEnabled: return [_HtX,]
+ else: return _HtX
# ---------------------------------------------------------
def AdjointOperator(self, paire, **extraArgs ):
#
# Calcul de la valeur de l'adjoint en X appliqué à Y
# --------------------------------------------------
- _Y = numpy.asmatrix(numpy.ravel( Y )).T
+ _Y = numpy.ravel( Y )
_HaY = numpy.dot(_JacobienneT, _Y)
- if self.__mfEnabled: return [_HaY.A1,]
- else: return _HaY.A1
+ if self.__mfEnabled: return [_HaY,]
+ else: return _HaY
# ==============================================================================
def EnsembleOfCenteredPerturbations( _bgcenter, _bgcovariance, _nbmembers ):
if Cm is not None and Un is not None: # Attention : si Cm est aussi dans M, doublon !
Cm = Cm.reshape(__n,Un.size) # ADAO & check shape
Xn_predicted = Xn_predicted + Cm * Un
- Pn_predicted = Q + Mt * Pn * Ma
+ Pn_predicted = Q + Mt * (Pn * Ma)
elif selfA._parameters["EstimationOf"] == "Parameters": # Observation of forecast
# --- > Par principe, M = Id, Q = 0
Xn_predicted = Xn
if Cm is not None and Un is not None: # Attention : si Cm est aussi dans M, doublon !
Cm = Cm.reshape(__n,Un.size) # ADAO & check shape
Xn_predicted = Xn_predicted + Cm * Un
- Pn_predicted = Q + Mt * Pn * Ma
+ Pn_predicted = Q + Mt * (Pn * Ma)
elif selfA._parameters["EstimationOf"] == "Parameters": # Observation of forecast
# --- > Par principe, M = Id, Q = 0
Xn_predicted = Xn
Ma = EM["Adjoint"].asMatrix(ValueForMethodForm = _Xn)
Ma = Ma.reshape(_Xn.size,_Xn.size) # ADAO & check shape
# Calcul du gradient par état adjoint
- GradJo = GradJo + Ha * RI * _YmHMX # Équivaut pour Ha linéaire à : Ha( (_Xn, RI * _YmHMX) )
- GradJo = Ma * GradJo # Équivaut pour Ma linéaire à : Ma( (_Xn, GradJo) )
+ GradJo = GradJo + Ha * (RI * _YmHMX) # Équivaut pour Ha linéaire à : Ha( (_Xn, RI * _YmHMX) )
+ GradJo = Ma * GradJo # Équivaut pour Ma linéaire à : Ma( (_Xn, GradJo) )
GradJ = numpy.ravel( GradJb ) - numpy.ravel( GradJo )
return GradJ
#
#
# Obtention de l'analyse
# ----------------------
- Xa = numpy.asmatrix(numpy.ravel( Minimum )).T
+ Xa = Minimum
#
selfA.StoredVariables["Analysis"].store( Xa )
#
if Cm is not None and Un is not None: # Attention : si Cm est aussi dans M, doublon !
Cm = Cm.reshape(__n,Un.size) # ADAO & check shape
Xn_predicted = Xn_predicted + Cm * Un
- Pn_predicted = Q + Mt * Pn * Ma
+ Pn_predicted = Q + Mt * (Pn * Ma)
elif selfA._parameters["EstimationOf"] == "Parameters": # Observation of forecast
# --- > Par principe, M = Id, Q = 0
Xn_predicted = Xn
