From: Jean-Philippe ARGAUD Date: Mon, 25 May 2015 13:11:52 +0000 (+0200) Subject: Documentation and source minor corrections and improvements X-Git-Tag: V7_6_0~5 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=e5d72c98fe0d01217729d498408c6f6b2180969b;p=modules%2Fadao.git Documentation and source minor corrections and improvements --- diff --git a/doc/en/ref_algorithm_3DVAR.rst b/doc/en/ref_algorithm_3DVAR.rst index 3dce275..ed3ef44 100644 --- a/doc/en/ref_algorithm_3DVAR.rst +++ b/doc/en/ref_algorithm_3DVAR.rst @@ -165,10 +165,12 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["APosterioriCorrelations", "APosterioriCovariance", "APosterioriStandardDeviations", - "APosterioriVariances", "BMA", "CostFunctionJ", "CurrentState", "OMA", - "OMB", "Innovation", "SigmaObs2", "MahalanobisConsistency", - "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", - "SimulatedObservationAtOptimum", "SimulationQuantiles"]. + "APosterioriVariances", "BMA", "CostFunctionJ", "CurrentOptimum", + "CurrentState", "IndexOfOptimum", "Innovation", "MahalanobisConsistency", + "OMA", "OMB", "SigmaObs2", "SimulatedObservationAtBackground", + "SimulatedObservationAtCurrentOptimum", + "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum", + "SimulationQuantiles"]. Example : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` @@ -249,8 +251,9 @@ The unconditional outputs of the algorithm are the following: The conditional outputs of the algorithm are the following: APosterioriCorrelations - *List of matrices*. Each element is an *a posteriori* error correlation - matrix of the optimal state. + *List of matrices*. Each element is an *a posteriori* error correlations + matrix of the optimal state, coming from the :math:`\mathbf{A}*` covariance + matrix. Example : ``C = ADD.get("APosterioriCorrelations")[-1]`` @@ -262,13 +265,15 @@ The conditional outputs of the algorithm are the following: APosterioriStandardDeviations *List of matrices*. Each element is an *a posteriori* error standard - deviation matrix of the optimal state. + errors diagonal matrix of the optimal state, coming from the + :math:`\mathbf{A}*` covariance matrix. - Example : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` + Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]`` APosterioriVariances - *List of matrices*. Each element is an *a posteriori* error variance matrix - of the optimal state. + *List of matrices*. Each element is an *a posteriori* error variance + errors diagonal matrix of the optimal state, coming from the + :math:`\mathbf{A}*` covariance matrix. Example : ``V = ADD.get("APosterioriVariances")[-1]`` @@ -278,12 +283,25 @@ The conditional outputs of the algorithm are the following: Example : ``bma = ADD.get("BMA")[-1]`` + CurrentOptimum + *List of vectors*. Each element is the optimal state obtained at the current + step of the optimization algorithm. It is not necessarely the last state. + + Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` + CurrentState *List of vectors*. Each element is a usual state vector used during the optimization algorithm procedure. Example : ``Xs = ADD.get("CurrentState")[:]`` + IndexOfOptimum + *List of integers*. Each element is the iteration index of the optimum + obtained at the current step the optimization algorithm. It is not + necessarely the number of the last iteration. + + Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` + Innovation *List of vectors*. Each element is an innovation vector, which is in static the difference between the optimal and the background, and in dynamic the @@ -321,11 +339,18 @@ The conditional outputs of the algorithm are the following: Example : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + SimulatedObservationAtCurrentOptimum + *List of vectors*. Each element is a vector of observation simulated from + the optimal state obtained at the current step the optimization algorithm, + that is, in the observation space. + + Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + SimulatedObservationAtCurrentState *List of vectors*. Each element is an observed vector at the current state, that is, in the observation space. - Example : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` SimulatedObservationAtOptimum *List of vectors*. Each element is a vector of observation simulated from diff --git a/doc/en/ref_output_variables.rst b/doc/en/ref_output_variables.rst index 28ac19a..996096e 100644 --- a/doc/en/ref_output_variables.rst +++ b/doc/en/ref_output_variables.rst @@ -211,12 +211,33 @@ at the input. All other information are conditioned by the algorithm and/or the user requests of availability. They are the following, in alphabetical order: + APosterioriCorrelations + *List of matrices*. Each element is an *a posteriori* error correlations + matrix of the optimal state, coming from the :math:`\mathbf{A}*` covariance + matrix. + + Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` + APosterioriCovariance *List of matrices*. Each element is an *a posteriori* error covariance matrix :math:`\mathbf{A}*` of the optimal state. Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + APosterioriStandardDeviations + *List of matrices*. Each element is an *a posteriori* error standard errors + diagonal matrix of the optimal state, coming from the :math:`\mathbf{A}*` + covariance matrix. + + Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]`` + + APosterioriVariances + *List of matrices*. Each element is an *a posteriori* error variances + diagonal matrix of the optimal state, coming from the :math:`\mathbf{A}*` + covariance matrix. + + Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` + BMA *List of vectors*. Each element is a vector of difference between the background and the optimal state. @@ -240,12 +261,25 @@ of availability. They are the following, in alphabetical order: Example : ``Jo = ADD.get("CostFunctionJo")[:]`` + CurrentOptimum + *List of vectors*. Each element is the optimal state obtained at the current + step of the optimization algorithm. It is not necessarely the last state. + + Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` + CurrentState *List of vectors*. Each element is a usual state vector used during the optimization algorithm procedure. Example : ``Xs = ADD.get("CurrentState")[:]`` + IndexOfOptimum + *List of integers*. Each element is the iteration index of the optimum + obtained at the current step the optimization algorithm. It is not + necessarely the number of the last iteration. + + Exemple : ``i = ADD.get("MahalanobisConsistency")[-1]`` + Innovation *List of vectors*. Each element is an innovation vector, which is in static the difference between the optimal and the background, and in dynamic the @@ -289,11 +323,18 @@ of availability. They are the following, in alphabetical order: Example : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + SimulatedObservationAtCurrentOptimum + *List of vectors*. Each element is a vector of observation simulated from + the optimal state obtained at the current step the optimization algorithm, + that is, in the observation space. + + Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + SimulatedObservationAtCurrentState *List of vectors*. Each element is an observed vector at the current state, that is, in the observation space. - Example : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` SimulatedObservationAtOptimum *List of vectors*. Each element is a vector of observation simulated from diff --git a/doc/fr/ref_algorithm_3DVAR.rst b/doc/fr/ref_algorithm_3DVAR.rst index fa5e425..b6b3b97 100644 --- a/doc/fr/ref_algorithm_3DVAR.rst +++ b/doc/fr/ref_algorithm_3DVAR.rst @@ -170,10 +170,12 @@ Les options de l'algorithme sont les suivantes: aucune de ces variables n'étant calculée et stockée par défaut. Les noms possibles sont dans la liste suivante : ["APosterioriCorrelations", "APosterioriCovariance", "APosterioriStandardDeviations", - "APosterioriVariances", "BMA", "CostFunctionJ", "CurrentState", "OMA", - "OMB", "Innovation", "SigmaObs2", "MahalanobisConsistency", - "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", - "SimulatedObservationAtOptimum", "SimulationQuantiles"]. + "APosterioriVariances", "BMA", "CostFunctionJ", "CurrentOptimum", + "CurrentState", "IndexOfOptimum", "Innovation", "MahalanobisConsistency", + "OMA", "OMB", "SigmaObs2", "SimulatedObservationAtBackground", + "SimulatedObservationAtCurrentOptimum", + "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum", + "SimulationQuantiles"]. Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` @@ -256,8 +258,9 @@ Les sorties non conditionnelles de l'algorithme sont les suivantes: Les sorties conditionnelles de l'algorithme sont les suivantes: APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélation des - erreurs *a posteriori* de l'état optimal. + *Liste de matrices*. Chaque élément est une matrice de corrélations des + erreurs *a posteriori* de l'état optimal, issue de la matrice + :math:`\mathbf{A}*` des covariances. Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` @@ -268,14 +271,16 @@ Les sorties conditionnelles de l'algorithme sont les suivantes: Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice d'écart-types des - erreurs *a posteriori* de l'état optimal. + *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types + des erreurs *a posteriori* de l'état optimal, issue de la matrice + :math:`\mathbf{A}*` des covariances. - Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` + Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]`` APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice de variances des erreurs - *a posteriori* de l'état optimal. + *Liste de matrices*. Chaque élément est une matrice diagonale de variances + des erreurs *a posteriori* de l'état optimal, issue de la matrice + :math:`\mathbf{A}*` des covariances. Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` @@ -285,12 +290,26 @@ Les sorties conditionnelles de l'algorithme sont les suivantes: Exemple : ``bma = ADD.get("BMA")[-1]`` + CurrentOptimum + *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de + temps courant au cours du déroulement de l'algorithme d'optimisation. Ce + n'est pas nécessairement le dernier état. + + Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` + CurrentState *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé au cours du déroulement de l'algorithme d'optimisation. Exemple : ``Xs = ADD.get("CurrentState")[:]`` + IndexOfOptimum + *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum + obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas + nécessairement le numéro de la dernière itération. + + Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` + Innovation *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément @@ -328,11 +347,18 @@ Les sorties conditionnelles de l'algorithme sont les suivantes: Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + SimulatedObservationAtCurrentOptimum + *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à + partir de l'état optimal au pas de temps courant au cours du déroulement de + l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations. + + Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant, - c'est-à-dire dans l'espace des observations. + *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à + partir de l'état courant, c'est-à-dire dans l'espace des observations. - Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` SimulatedObservationAtOptimum *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à diff --git a/doc/fr/ref_output_variables.rst b/doc/fr/ref_output_variables.rst index e64ebb2..656c29d 100644 --- a/doc/fr/ref_output_variables.rst +++ b/doc/fr/ref_output_variables.rst @@ -220,12 +220,33 @@ Toutes les autres informations sont conditionn demande utilisateur de disponibilité. Ce sont les suivantes, par ordre alphabétique: + APosterioriCorrelations + *Liste de matrices*. Chaque élément est une matrice de corrélations des + erreurs *a posteriori* de l'état optimal, issue de la matrice + :math:`\mathbf{A}*` des covariances. + + Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` + APosterioriCovariance *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de covariances des erreurs *a posteriori* de l'état optimal. Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + APosterioriStandardDeviations + *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types + des erreurs *a posteriori* de l'état optimal, issue de la matrice + :math:`\mathbf{A}*` des covariances. + + Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]`` + + APosterioriVariances + *Liste de matrices*. Chaque élément est une matrice diagonale de variances + des erreurs *a posteriori* de l'état optimal, issue de la matrice + :math:`\mathbf{A}*` des covariances. + + Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` + BMA *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre l'ébauche et l'état optimal. @@ -250,12 +271,26 @@ alphab Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + CurrentOptimum + *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de + temps courant au cours du déroulement de l'algorithme d'optimisation. Ce + n'est pas nécessairement le dernier état. + + Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` + CurrentState *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé au cours du déroulement de l'algorithme d'optimisation. Exemple : ``Xs = ADD.get("CurrentState")[:]`` + IndexOfOptimum + *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum + obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas + nécessairement le numéro de la dernière itération. + + Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` + Innovation *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément @@ -299,11 +334,18 @@ alphab Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + SimulatedObservationAtCurrentOptimum + *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à + partir de l'état optimal au pas de temps courant au cours du déroulement de + l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations. + + Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant, - c'est-à-dire dans l'espace des observations. + *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à + partir de l'état courant, c'est-à-dire dans l'espace des observations. - Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` SimulatedObservationAtOptimum *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à diff --git a/src/daComposant/daAlgorithms/3DVAR.py b/src/daComposant/daAlgorithms/3DVAR.py index 382f12a..ae62c43 100644 --- a/src/daComposant/daAlgorithms/3DVAR.py +++ b/src/daComposant/daAlgorithms/3DVAR.py @@ -72,7 +72,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): default = [], typecast = tuple, message = "Liste de calculs supplémentaires à stocker et/ou effectuer", - listval = ["APosterioriCorrelations", "APosterioriCovariance", "APosterioriStandardDeviations", "APosterioriVariances", "BMA", "OMA", "OMB", "CurrentState", "CostFunctionJ", "Innovation", "SigmaObs2", "MahalanobisConsistency", "SimulationQuantiles", "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"] + listval = ["APosterioriCorrelations", "APosterioriCovariance", "APosterioriStandardDeviations", "APosterioriVariances", "BMA", "OMA", "OMB", "CurrentState", "CostFunctionJ", "CurrentOptimum", "IndexOfOptimum", "Innovation", "SigmaObs2", "MahalanobisConsistency", "SimulationQuantiles", "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum", "SimulatedObservationAtCurrentOptimum"] ) self.defineRequiredParameter( name = "Quantiles", @@ -159,11 +159,14 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # ------------------------------ def CostFunction(x): _X = numpy.asmatrix(numpy.ravel( x )).T - if self._parameters["StoreInternalVariables"] or "CurrentState" in self._parameters["StoreSupplementaryCalculations"]: + if self._parameters["StoreInternalVariables"] or \ + "CurrentState" in self._parameters["StoreSupplementaryCalculations"] or \ + "CurrentOptimum" in self._parameters["StoreSupplementaryCalculations"]: self.StoredVariables["CurrentState"].store( _X ) _HX = Hm( _X ) _HX = numpy.asmatrix(numpy.ravel( _HX )).T - if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]: + if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"] or \ + "SimulatedObservationAtCurrentOptimum" in self._parameters["StoreSupplementaryCalculations"]: self.StoredVariables["SimulatedObservationAtCurrentState"].store( _HX ) Jb = 0.5 * (_X - Xb).T * BI * (_X - Xb) Jo = 0.5 * (Y - _HX).T * RI * (Y - _HX) @@ -171,6 +174,16 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): self.StoredVariables["CostFunctionJb"].store( Jb ) self.StoredVariables["CostFunctionJo"].store( Jo ) self.StoredVariables["CostFunctionJ" ].store( J ) + if "IndexOfOptimum" in self._parameters["StoreSupplementaryCalculations"] or \ + "CurrentOptimum" in self._parameters["StoreSupplementaryCalculations"] or \ + "SimulatedObservationAtCurrentOptimum" in self._parameters["StoreSupplementaryCalculations"]: + IndexMin = numpy.argmin( self.StoredVariables["CostFunctionJ"][nbPreviousSteps:] ) + nbPreviousSteps + if "IndexOfOptimum" in self._parameters["StoreSupplementaryCalculations"]: + self.StoredVariables["IndexOfOptimum"].store( IndexMin ) + if "CurrentOptimum" in self._parameters["StoreSupplementaryCalculations"]: + self.StoredVariables["CurrentOptimum"].store( self.StoredVariables["CurrentState"][IndexMin] ) + if "SimulatedObservationAtCurrentOptimum" in self._parameters["StoreSupplementaryCalculations"]: + self.StoredVariables["SimulatedObservationAtCurrentOptimum"].store( self.StoredVariables["SimulatedObservationAtCurrentState"][IndexMin] ) return J # def GradientOfCostFunction(x): @@ -273,7 +286,12 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): "SigmaObs2" in self._parameters["StoreSupplementaryCalculations"] or \ "SimulatedObservationAtOptimum" in self._parameters["StoreSupplementaryCalculations"] or \ "SimulationQuantiles" in self._parameters["StoreSupplementaryCalculations"]: - HXa = Hm(Xa) + if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]: + HXa = self.StoredVariables["SimulatedObservationAtCurrentState"][IndexMin] + elif "SimulatedObservationAtCurrentOptimum" in self._parameters["StoreSupplementaryCalculations"]: + HXa = self.StoredVariables["SimulatedObservationAtCurrentOptimum"][-1] + else: + HXa = Hm(Xa) # # Calcul de la covariance d'analyse # --------------------------------- diff --git a/src/daComposant/daAlgorithms/SamplingTest.py b/src/daComposant/daAlgorithms/SamplingTest.py index 67cfa2d..41d0bfa 100644 --- a/src/daComposant/daAlgorithms/SamplingTest.py +++ b/src/daComposant/daAlgorithms/SamplingTest.py @@ -124,7 +124,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # ---------- BI = B.getI() RI = R.getI() - def CostFunction(x,HmX, QualityMeasure="AugmentedWeightedLeastSquares"): + def CostFunction(x, HmX, QualityMeasure="AugmentedWeightedLeastSquares"): if numpy.any(numpy.isnan(HmX)): _X = numpy.nan _HX = numpy.nan diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py index fc6708b..35625ad 100644 --- a/src/daComposant/daCore/BasicObjects.py +++ b/src/daComposant/daCore/BasicObjects.py @@ -296,9 +296,12 @@ class Algorithm: self.StoredVariables["GradientOfCostFunctionJo"] = Persistence.OneVector(name = "GradientOfCostFunctionJo") self.StoredVariables["CurrentState"] = Persistence.OneVector(name = "CurrentState") self.StoredVariables["Analysis"] = Persistence.OneVector(name = "Analysis") + self.StoredVariables["IndexOfOptimum"] = Persistence.OneIndex(name = "IndexOfOptimum") + self.StoredVariables["CurrentOptimum"] = Persistence.OneVector(name = "CurrentOptimum") self.StoredVariables["SimulatedObservationAtBackground"] = Persistence.OneVector(name = "SimulatedObservationAtBackground") self.StoredVariables["SimulatedObservationAtCurrentState"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentState") self.StoredVariables["SimulatedObservationAtOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtOptimum") + self.StoredVariables["SimulatedObservationAtCurrentOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentOptimum") self.StoredVariables["Innovation"] = Persistence.OneVector(name = "Innovation") self.StoredVariables["SigmaObs2"] = Persistence.OneScalar(name = "SigmaObs2") self.StoredVariables["SigmaBck2"] = Persistence.OneScalar(name = "SigmaBck2") diff --git a/src/daComposant/daCore/Persistence.py b/src/daComposant/daCore/Persistence.py index 0bf1b4d..eecba7f 100644 --- a/src/daComposant/daCore/Persistence.py +++ b/src/daComposant/daCore/Persistence.py @@ -652,6 +652,13 @@ class OneScalar(Persistence): def __init__(self, name="", unit="", basetype = float): Persistence.__init__(self, name, unit, basetype) +class OneIndex(Persistence): + """ + 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 diff --git a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py index 457fc0b..95d3693 100644 --- a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py +++ b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py @@ -245,12 +245,17 @@ OptDefaultDict["UserPostAnalysis"] = "Template" # Observers ObserversList = [ "Analysis", - "CurrentState", "Innovation", + "CurrentState", + "CurrentOptimum", + "IndexOfOptimum", + "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", + "SimulatedObservationAtOptimum", + "SimulatedObservationAtCurrentOptimum", + "BMA", "OMA", "OMB", - "BMA", "CostFunctionJ", "CostFunctionJb", "CostFunctionJo",