#
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
#
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")))
self.setParameters(Parameters)
#
Hm = HO["Direct"].appliedTo
- if self._parameters["ResiduFormula"] is "Taylor":
+ if self._parameters["ResiduFormula"] == "Taylor":
Ht = HO["Tangent"].appliedInXTo
#
# ----------
#
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 :
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) ||
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 = []
NormesdFXsAm = []
NormesdFXGdX = []
#
- # ----------
for i,amplitude in enumerate(Perturbations):
dX = amplitude * dX0
#
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
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"]:
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(
YRef = PerturbationsCarre,
normdY0 = numpy.log10( NormesdFX[0] ),
)
- elif self._parameters["ResiduFormula"] is "Norm":
+ elif self._parameters["ResiduFormula"] == "Norm":
dessiner(
Perturbations,
Residus,
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')
# 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
#
# 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) ||
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 :
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 :
|| 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 :
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
#
#
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
#
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
#
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")))
