From: Jean-Philippe ARGAUD Date: Mon, 17 Feb 2014 09:25:57 +0000 (+0100) Subject: Homogeneization and improvment of *test printed outputs X-Git-Tag: V7_4_0rc1~17^2~6 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=19e343fd330c2d8087a7eb4b8a8eeb5c2009d346;p=modules%2Fadao.git Homogeneization and improvment of *test printed outputs --- diff --git a/src/daComposant/daAlgorithms/AdjointTest.py b/src/daComposant/daAlgorithms/AdjointTest.py index 66f25fb..31bb832 100644 --- a/src/daComposant/daAlgorithms/AdjointTest.py +++ b/src/daComposant/daAlgorithms/AdjointTest.py @@ -102,33 +102,34 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # dX0 = float(self._parameters["AmplitudeOfInitialDirection"]) * numpy.matrix( dX0 ).T # - # ---------- - if self._parameters["ResiduFormula"] is "ScalarProduct": - __doc__ = """ + # Entete des resultats + # -------------------- + __marge = 12*" " + if self._parameters["ResiduFormula"] == "ScalarProduct": + __entete = " i Alpha ||X|| ||Y|| ||dX|| R(Alpha) " + __msgdoc = """ On observe le residu qui est la difference de deux produits scalaires : - + R(Alpha) = | < TangentF_X(dX) , Y > - < dX , AdjointF_X(Y) > | - + qui doit rester constamment egal zero a la precision du calcul. On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. Y doit etre dans l'image de F. S'il n'est pas donne, on prend Y = F(X). """ - else: - __doc__ = "" # if len(self._parameters["ResultTitle"]) > 0: - msgs = " ====" + "="*len(self._parameters["ResultTitle"]) + "====\n" - msgs += " " + self._parameters["ResultTitle"] + "\n" - msgs += " ====" + "="*len(self._parameters["ResultTitle"]) + "====\n" + msgs = "\n" + msgs += __marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" + msgs += __marge + " " + self._parameters["ResultTitle"] + "\n" + msgs += __marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" else: msgs = "" - msgs += __doc__ + msgs += __msgdoc # - msg = " i Alpha ||X|| ||Y|| ||dX|| R(Alpha) " - nbtirets = len(msg) - msgs += "\n" + "-"*nbtirets - msgs += "\n" + msg - msgs += "\n" + "-"*nbtirets + __nbtirets = len(__entete) + msgs += "\n" + __marge + "-"*__nbtirets + msgs += "\n" + __marge + __entete + msgs += "\n" + __marge + "-"*__nbtirets # Normalisation= -1 # @@ -143,15 +144,17 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): Residu = abs(float(numpy.dot( TangentFXdX.A1 , Y.A1 ) - numpy.dot( dX.A1 , AdjointFXY.A1 ))) # msg = " %2i %5.0e %9.3e %9.3e %9.3e | %9.3e"%(i,amplitude,NormeX,NormeY,NormedX,Residu) - msgs += "\n" + msg + msgs += "\n" + __marge + msg # self.StoredVariables["CostFunctionJ"].store( Residu ) - msgs += "\n" + "-"*nbtirets + # + msgs += "\n" + __marge + "-"*__nbtirets msgs += "\n" # - # ---------- + # Sorties eventuelles + # ------------------- print - print "Results of adjoint stability check:" + print "Results of adjoint check by \"%s\" formula:"%self._parameters["ResiduFormula"] print msgs # logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) diff --git a/src/daComposant/daAlgorithms/GradientTest.py b/src/daComposant/daAlgorithms/GradientTest.py index 2e6b728..e8edcc5 100644 --- a/src/daComposant/daAlgorithms/GradientTest.py +++ b/src/daComposant/daAlgorithms/GradientTest.py @@ -95,7 +95,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): self.setParameters(Parameters) # Hm = HO["Direct"].appliedTo - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": Ht = HO["Tangent"].appliedInXTo # # ---------- @@ -119,13 +119,16 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # dX0 = float(self._parameters["AmplitudeOfInitialDirection"]) * numpy.matrix( dX0 ).T # - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": GradFxdX = Ht( (X, dX0) ) GradFxdX = numpy.asmatrix(numpy.ravel( GradFxdX )).T # - # ---------- - if self._parameters["ResiduFormula"] is "Taylor": - __doc__ = """ + # Entete des resultats + # -------------------- + __marge = 12*" " + if self._parameters["ResiduFormula"] == "Taylor": + __entete = " i Alpha ||X|| ||F(X)|| ||F(X+dX)|| ||dX|| ||F(X+dX)-F(X)|| ||F(X+dX)-F(X)||/||dX|| R(Alpha) log( R ) " + __msgdoc = """ On observe le residu issu du développement de Taylor de la fonction F, normalisée par la valeur au point nominal : @@ -136,16 +139,17 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): Si le résidu décroit et que la décroissance se fait en Alpha**2 selon Alpha, cela signifie que le gradient est bien calculé jusqu'à la précision d'arrêt de la décroissance quadratique et que F n'est pas linéaire. - + Si le résidu décroit et que la décroissance se fait en Alpha selon Alpha, jusqu'à un certain seuil aprés lequel le résidu est faible et constant, cela signifie que F est linéaire et que le résidu décroit à partir de l'erreur faite dans le calcul du terme GradientF_X. - + On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. """ - elif self._parameters["ResiduFormula"] is "Norm": - __doc__ = """ + if self._parameters["ResiduFormula"] == "Norm": + __entete = " i Alpha ||X|| ||F(X)|| ||F(X+dX)|| ||dX|| ||F(X+dX)-F(X)|| ||F(X+dX)-F(X)||/||dX|| R(Alpha) log( R ) " + __msgdoc = """ On observe le residu, qui est basé sur une approximation du gradient : || F(X+Alpha*dX) - F(X) || @@ -153,25 +157,26 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): Alpha qui doit rester constant jusqu'à ce qu'on atteigne la précision du calcul. + On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. """ - else: - __doc__ = "" # if len(self._parameters["ResultTitle"]) > 0: - msgs = " ====" + "="*len(self._parameters["ResultTitle"]) + "====\n" - msgs += " " + self._parameters["ResultTitle"] + "\n" - msgs += " ====" + "="*len(self._parameters["ResultTitle"]) + "====\n" + msgs = "\n" + msgs += __marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" + msgs += __marge + " " + self._parameters["ResultTitle"] + "\n" + msgs += __marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" else: msgs = "" - msgs += __doc__ + msgs += __msgdoc # - msg = " i Alpha ||X|| ||F(X)|| ||F(X+dX)|| ||dX|| ||F(X+dX)-F(X)|| ||F(X+dX)-F(X)||/||dX|| R(Alpha) log( R ) " - nbtirets = len(msg) - msgs += "\n" + "-"*nbtirets - msgs += "\n" + msg - msgs += "\n" + "-"*nbtirets + __nbtirets = len(__entete) + msgs += "\n" + __marge + "-"*__nbtirets + msgs += "\n" + __marge + __entete + msgs += "\n" + __marge + "-"*__nbtirets # + # Boucle sur les perturbations + # ---------------------------- Normalisation= -1 NormesdX = [] NormesFXdX = [] @@ -180,7 +185,6 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): NormesdFXsAm = [] NormesdFXGdX = [] # - # ---------- for i,amplitude in enumerate(Perturbations): dX = amplitude * dX0 # @@ -192,7 +196,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): NormedFX = numpy.linalg.norm( FX_plus_dX - FX ) NormedFXsdX = NormedFX/NormedX # Residu Taylor - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": NormedFXGdX = numpy.linalg.norm( FX_plus_dX - FX - amplitude * GradFxdX ) # Residu Norm NormedFXsAm = NormedFX/amplitude @@ -203,27 +207,28 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): NormesdX.append( NormedX ) NormesFXdX.append( NormeFXdX ) NormesdFX.append( NormedFX ) - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": NormesdFXGdX.append( NormedFXGdX ) NormesdFXsdX.append( NormedFXsdX ) NormesdFXsAm.append( NormedFXsAm ) # - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": Residu = NormedFXGdX / NormeFX - elif self._parameters["ResiduFormula"] is "Norm": + elif self._parameters["ResiduFormula"] == "Norm": Residu = NormedFXsAm if Normalisation < 0 : Normalisation = Residu # msg = " %2i %5.0e %9.3e %9.3e %9.3e %9.3e %9.3e | %9.3e | %9.3e %4.0f"%(i,amplitude,NormeX,NormeFX,NormeFXdX,NormedX,NormedFX,NormedFXsdX,Residu,math.log10(max(1.e-99,Residu))) - msgs += "\n" + msg + msgs += "\n" + __marge + msg # self.StoredVariables["CostFunctionJ"].store( Residu ) - msgs += "\n" + "-"*nbtirets + # + msgs += "\n" + __marge + "-"*__nbtirets msgs += "\n" # # ---------- print - print "Results of gradient stability check:" + print "Results of gradient check by \"%s\" formula:"%self._parameters["ResiduFormula"] print msgs # if self._parameters["PlotAndSave"]: @@ -232,7 +237,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): f.close() # Residus = self.StoredVariables["CostFunctionJ"][-len(Perturbations):] - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": PerturbationsCarre = [ 10**(2*i) for i in xrange(-len(NormesdFXGdX)+1,1) ] PerturbationsCarre.reverse() dessiner( @@ -246,7 +251,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): YRef = PerturbationsCarre, normdY0 = numpy.log10( NormesdFX[0] ), ) - elif self._parameters["ResiduFormula"] is "Norm": + elif self._parameters["ResiduFormula"] == "Norm": dessiner( Perturbations, Residus, @@ -316,7 +321,7 @@ def dessiner( pass __g.replot( __gnuplot.Data( steps, valuesRef, title="Reference", with_='lines lw 1' ) ) # - if filename is not "": + if filename != "": __g.hardcopy( filename, color=1) if pause: raw_input('Please press return to continue...\n') diff --git a/src/daComposant/daAlgorithms/LinearityTest.py b/src/daComposant/daAlgorithms/LinearityTest.py index 8825783..768b89a 100644 --- a/src/daComposant/daAlgorithms/LinearityTest.py +++ b/src/daComposant/daAlgorithms/LinearityTest.py @@ -85,7 +85,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # Opérateurs # ---------- Hm = HO["Direct"].appliedTo - if self._parameters["ResiduFormula"] in ["Taylor", "NominalTaylor", "NotNominalTaylor", "NominalTaylorRMS", "NotNominalTaylorRMS"]: + if self._parameters["ResiduFormula"] in ["Taylor", "NominalTaylor", "NominalTaylorRMS"]: Ht = HO["Tangent"].appliedInXTo # # Construction des perturbations @@ -116,20 +116,20 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Calcul du gradient au point courant X pour l'incrément dX # --------------------------------------------------------- - if self._parameters["ResiduFormula"] in ["Taylor", "NominalTaylor", "NotNominalTaylor", "NominalTaylorRMS", "NotNominalTaylorRMS"]: + if self._parameters["ResiduFormula"] in ["Taylor", "NominalTaylor", "NominalTaylorRMS"]: GradFxdX = Ht( (Xn, dX0) ) GradFxdX = numpy.asmatrix(numpy.ravel( GradFxdX )).T # # Entete des resultats # -------------------- - marge = 12*" " - if self._parameters["ResiduFormula"] is "CenteredDL": - entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) log( R ) " - __doc__ = """ + __marge = 12*" " + if self._parameters["ResiduFormula"] == "CenteredDL": + __entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) log( R ) " + __msgdoc = """ On observe le residu provenant de la différence centrée des valeurs de F au point nominal et aux points perturbés, normalisée par la valeur au point nominal : - + || F(X+Alpha*dX) + F(X-Alpha*dX) - 2*F(X) || R(Alpha) = -------------------------------------------- || F(X) || @@ -144,12 +144,12 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): Si le résidu décroit et que la décroissance se fait en Alpha**2 selon Alpha, cela signifie que le gradient est bien calculé jusqu'à la précision d'arrêt de la décroissance quadratique. - + On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. """ - if self._parameters["ResiduFormula"] is "Taylor": - entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) log( R ) " - __doc__ = """ + if self._parameters["ResiduFormula"] == "Taylor": + __entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) log( R ) " + __msgdoc = """ On observe le residu issu du développement de Taylor de la fonction F, normalisée par la valeur au point nominal : @@ -167,12 +167,12 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): Si le résidu décroit et que la décroissance se fait en Alpha**2 selon Alpha, cela signifie que le gradient est bien calculé jusqu'à la précision d'arrêt de la décroissance. - + On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. """ - if self._parameters["ResiduFormula"] is "NominalTaylor": - entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) |R-1| en % " - __doc__ = """ + if self._parameters["ResiduFormula"] == "NominalTaylor": + __entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) |R-1| en % " + __msgdoc = """ On observe le residu obtenu à partir de deux approximations d'ordre 1 de F(X), normalisées par la valeur au point nominal : @@ -181,18 +181,19 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): || F(X-Alpha*dX) + Alpha * F(dX) || / || F(X) ||, ) - S'il reste constamment égal à 1 à moins de 2 ou 3 pourcents prés, c'est - que l'hypothèse de linéarité de F est vérifiée. - + S'il reste constamment égal à 1 à moins de 2 ou 3 pourcents prés (c'est-à-dire + que |R-1| reste égal à 2 ou 3 pourcents), c'est que l'hypothèse de linéarité + de F est vérifiée. + S'il est égal à 1 sur une partie seulement du domaine de variation de l'incrément Alpha, c'est sur cette partie que l'hypothèse de linéarité de F est vérifiée. - + On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. """ - if self._parameters["ResiduFormula"] is "NominalTaylorRMS": - entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) |R| en % " - __doc__ = """ + if self._parameters["ResiduFormula"] == "NominalTaylorRMS": + __entete = " i Alpha ||X|| ||F(X)|| | R(Alpha) |R| en % " + __msgdoc = """ On observe le residu obtenu à partir de deux approximations d'ordre 1 de F(X), normalisées par la valeur au point nominal : @@ -203,33 +204,34 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): S'il reste constamment égal à 0 à moins de 1 ou 2 pourcents prés, c'est que l'hypothèse de linéarité de F est vérifiée. - + S'il est égal à 0 sur une partie seulement du domaine de variation de l'incrément Alpha, c'est sur cette partie que l'hypothèse de linéarité de F est vérifiée. - + On prend dX0 = Normal(0,X) et dX = Alpha*dX0. F est le code de calcul. """ # if len(self._parameters["ResultTitle"]) > 0: - msgs = marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" - msgs += marge + " " + self._parameters["ResultTitle"] + "\n" - msgs += marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" + msgs = "\n" + msgs += __marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" + msgs += __marge + " " + self._parameters["ResultTitle"] + "\n" + msgs += __marge + "====" + "="*len(self._parameters["ResultTitle"]) + "====\n" else: msgs = "" - msgs += __doc__ + msgs += __msgdoc # - nbtirets = len(entete) - msgs += "\n" + marge + "-"*nbtirets - msgs += "\n" + marge + entete - msgs += "\n" + marge + "-"*nbtirets + __nbtirets = len(__entete) + msgs += "\n" + __marge + "-"*__nbtirets + msgs += "\n" + __marge + __entete + msgs += "\n" + __marge + "-"*__nbtirets # # Boucle sur les perturbations # ---------------------------- for i,amplitude in enumerate(Perturbations): dX = amplitude * dX0 # - if self._parameters["ResiduFormula"] is "CenteredDL": + if self._parameters["ResiduFormula"] == "CenteredDL": FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T FX_moins_dX = numpy.asmatrix(numpy.ravel( Hm( Xn - dX ) )).T # @@ -237,18 +239,18 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # self.StoredVariables["CostFunctionJ"].store( Residu ) msg = " %2i %5.0e %9.3e %9.3e | %9.3e %4.0f"%(i,amplitude,NormeX,NormeFX,Residu,math.log10(max(1.e-99,Residu))) - msgs += "\n" + marge + msg + msgs += "\n" + __marge + msg # - if self._parameters["ResiduFormula"] is "Taylor": + if self._parameters["ResiduFormula"] == "Taylor": FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T # Residu = numpy.linalg.norm( FX_plus_dX - FX - amplitude * GradFxdX ) / NormeFX # self.StoredVariables["CostFunctionJ"].store( Residu ) msg = " %2i %5.0e %9.3e %9.3e | %9.3e %4.0f"%(i,amplitude,NormeX,NormeFX,Residu,math.log10(max(1.e-99,Residu))) - msgs += "\n" + marge + msg + msgs += "\n" + __marge + msg # - if self._parameters["ResiduFormula"] is "NominalTaylor": + if self._parameters["ResiduFormula"] == "NominalTaylor": FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T FX_moins_dX = numpy.asmatrix(numpy.ravel( Hm( Xn - dX ) )).T FdX = numpy.asmatrix(numpy.ravel( Hm( dX ) )).T @@ -260,9 +262,9 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # self.StoredVariables["CostFunctionJ"].store( Residu ) msg = " %2i %5.0e %9.3e %9.3e | %9.3e %5i %s"%(i,amplitude,NormeX,NormeFX,Residu,100*abs(Residu-1),"%") - msgs += "\n" + marge + msg + msgs += "\n" + __marge + msg # - if self._parameters["ResiduFormula"] is "NominalTaylorRMS": + if self._parameters["ResiduFormula"] == "NominalTaylorRMS": FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T FX_moins_dX = numpy.asmatrix(numpy.ravel( Hm( Xn - dX ) )).T FdX = numpy.asmatrix(numpy.ravel( Hm( dX ) )).T @@ -274,15 +276,15 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # self.StoredVariables["CostFunctionJ"].store( Residu ) msg = " %2i %5.0e %9.3e %9.3e | %9.3e %5i %s"%(i,amplitude,NormeX,NormeFX,Residu,100*Residu,"%") - msgs += "\n" + marge + msg + msgs += "\n" + __marge + msg # - msgs += "\n" + marge + "-"*nbtirets + msgs += "\n" + __marge + "-"*__nbtirets msgs += "\n" # # Sorties eventuelles # ------------------- print - print "Results of linearity check by \"%s\" formula:\n"%self._parameters["ResiduFormula"] + print "Results of linearity check by \"%s\" formula:"%self._parameters["ResiduFormula"] print msgs # logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M")))