# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
-"Test des versions de modules"
+"Test du système et des versions de modules"
+
+import sys
+import unittest
# ==============================================================================
#
minimal_numpy_version = "1.8.2"
minimal_scipy_version = "0.14.0"
minimal_matplotlib_version = "1.4.2"
+minimal_nlopt_version = "2.4.2"
+#
+# ==============================================================================
+class Test_Adao(unittest.TestCase):
+ def test1_minimalVersion(self):
+ "Affichage des versions minimales"
+ print(" Les versions minimales attendues sont :")
+ print(" - Python systeme....: %s"%minimal_python_version)
+ print(" - Numpy.............: %s"%minimal_numpy_version)
+ print(" - Scipy.............: %s"%minimal_scipy_version)
+ print(" - NLopt.............: %s"%minimal_nlopt_version)
+ print(" - Matplotlib........: %s"%minimal_matplotlib_version)
+ print("")
+
+ def test2_Version(self):
+ "Test du système et des versions de modules"
+ print(" Les versions disponibles sont :")
+ v=sys.version.split()
+ print(" - Python systeme....: %s"%v[0])
+ assert compare_versions(sys.version.split()[0], minimal_python_version)
+
+ def test3_Version(self):
+ try:
+ import numpy
+ print(" - Numpy.............: %s"%numpy.version.version)
+ assert compare_versions(numpy.version.version, minimal_numpy_version)
+ except ImportError as e:
+ raise ImportError(str(e))
+
+ def test4_Version(self):
+ try:
+ import scipy
+ print(" - Scipy.............: %s"%scipy.version.version)
+ assert compare_versions(scipy.version.version, minimal_scipy_version)
+ except ImportError as e:
+ raise ImportError(str(e))
+
+ def test5_Version(self):
+ try:
+ import nlopt
+ __version = "%s.%s.%s"%(
+ nlopt.version_major(),
+ nlopt.version_minor(),
+ nlopt.version_bugfix(),
+ )
+ print(" - NLopt.............: %s"%__version)
+ assert compare_versions(__version, minimal_nlopt_version)
+ except ImportError as e:
+ raise ImportError(str(e))
+
+ def test6_Version(self):
+ try:
+ import matplotlib
+ mplversion = matplotlib.__version__
+ print(" - Matplotlib........: %s"%mplversion)
+ assert compare_versions(mplversion, minimal_matplotlib_version)
+ #
+ print("")
+ backends_OK = []
+ backends_KO = []
+ backend_now = matplotlib.get_backend()
+
+ for backend in ['bidon', 'pdf', 'pgf', 'Qt4Agg', 'GTK', 'GTKAgg', 'ps',
+ 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg',
+ 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg',
+ 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX']:
+ try:
+ matplotlib.use(backend)
+ backends_OK.append(backend)
+ except ValueError:
+ backends_KO.append(backend)
+ #
+ print(" Backends disponibles pour Matplotlib %s :"%mplversion)
+ print(" Defaut initial......: '%s'"%backend_now)
+ print(" Fonctionnant........:")
+ for b in backends_OK:
+ print(" '%s'"%b)
+ print(" Non fonctionnant....:")
+ for b in backends_KO:
+ print(" '%s'"%b)
+ print(" (Le backend 'bidon' n'est ici que pour verifier le test, il n'existe pas)")
+ except ImportError as e:
+ raise ImportError(str(e))
+ print("")
+ print(" Les résultats obtenus sont corrects.")
+ print("")
+ #
+ return 0
def compare_versions(v1,v2):
"Comparaison v1 >= v2"
lv2 = 1e6*v21 + 1e3*v22 + v23
return lv1 >= lv2
-def minimalVersion():
- "Description"
- print(" Les versions minimales attendues sont :")
- print(" - Python systeme....: %s"%minimal_python_version)
- print(" - Numpy.............: %s"%minimal_numpy_version)
- print(" - Scipy.............: %s"%minimal_scipy_version)
- print(" - Matplotlib........: %s"%minimal_matplotlib_version)
- print("")
-
-import sys
-def testSysteme():
- "Test des versions de modules"
- print(" Les versions disponibles sont :")
- v=sys.version.split()
- print(" - Python systeme....: %s"%v[0])
- assert compare_versions(sys.version.split()[0], minimal_python_version)
- #
- try:
- import numpy
- print(" - Numpy.............: %s"%numpy.version.version)
- assert compare_versions(numpy.version.version, minimal_numpy_version)
- except ImportError:
- return 1
- #
- try:
- import scipy
- print(" - Scipy.............: %s"%scipy.version.version)
- assert compare_versions(scipy.version.version, minimal_scipy_version)
- except ImportError:
- return 1
- #
- try:
- import matplotlib
- mplversion = matplotlib.__version__
- print(" - Matplotlib........: %s"%mplversion)
- assert compare_versions(mplversion, minimal_matplotlib_version)
- #
- print("")
- backends_OK = []
- backends_KO = []
- backend_now = matplotlib.get_backend()
-
- for backend in ['bidon', 'pdf', 'pgf', 'Qt4Agg', 'GTK', 'GTKAgg', 'ps',
- 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg',
- 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg',
- 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX']:
- try:
- matplotlib.use(backend)
- backends_OK.append(backend)
- except ValueError:
- backends_KO.append(backend)
- #
- print(" Backends disponibles pour Matplotlib %s :"%mplversion)
- print(" Defaut initial......: '%s'"%backend_now)
- print(" Fonctionnant........:")
- for b in backends_OK:
- print(" '%s'"%b)
- print(" Non fonctionnant....:")
- for b in backends_KO:
- print(" '%s'"%b)
- print(" (Le backend 'bidon' n'est ici que pour verifier le test, il n'existe pas)")
- except ImportError:
- pass
- print("")
- print(" Les résultats obtenus sont corrects.")
- print("")
- #
- return 0
-
-# ==============================================================================
+#===============================================================================
if __name__ == "__main__":
- print('\nAUTODIAGNOSTIC\n')
- minimalVersion()
- sys.exit(testSysteme())
-
+ print("\nAUTODIAGNOSTIC\n==============")
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"Test de fonctionnement et de performances de Numpy et Scipy"
-# ==============================================================================
-import numpy, time
+import sys
+import time
+import unittest
+import numpy
+import scipy
numpy.set_printoptions(precision=5)
-def testSysteme():
- print(" Les caracteristiques des applications et outils systeme :")
- import sys ; v=sys.version.split() ; print(" - Python systeme....: %s"%v[0])
- import numpy ; print(" - Numpy.............: %s"%numpy.version.version)
- try:
- import scipy ; print(" - Scipy.............: %s"%scipy.version.version)
- except:
- print(" - Scipy.............: %s"%("absent",))
- try:
- import numpy.distutils.system_info as sysinfo ; la = sysinfo.get_info('lapack') ; print(" - Lapack............: %s/lib%s.so"%(la['library_dirs'][0],la['libraries'][0]))
- except:
- print(" - Lapack............: %s"%("absent",))
- print("")
- return True
+# ==============================================================================
+class Test_Adao(unittest.TestCase):
+ def test1_Systeme(self):
+ "Test Système"
+ print()
+ print(" %s"%self.test1_Systeme.__doc__)
+ print(" Les caracteristiques des applications et outils systeme :")
+ import sys ; v=sys.version.split() ; print(" - Python systeme....: %s"%v[0])
+ import numpy ; print(" - Numpy.............: %s"%numpy.version.version)
+ try:
+ import scipy ; print(" - Scipy.............: %s"%scipy.version.version)
+ except:
+ print(" - Scipy.............: %s"%("absent",))
+ try:
+ import numpy.distutils.system_info as sysinfo ; la = sysinfo.get_info('lapack') ; print(" - Lapack............: %s/lib%s.so"%(la['library_dirs'][0],la['libraries'][0]))
+ except:
+ print(" - Lapack............: %s"%("absent",))
+ print("")
+ return True
-def testNumpy01(dimension = 3, precision = 1.e-17, repetitions = 10):
- "Test Numpy"
- __d = int(dimension)
- print(" Taille du test..................................: %.0e"%__d)
- t_init = time.time()
- A = numpy.array([numpy.arange(dimension)+1.,]*__d)
- x = numpy.arange(__d)+1.
- print(" La duree elapsed moyenne de l'initialisation est: %4.1f s"%(time.time()-t_init))
- #
- t_init = time.time()
- for i in range(repetitions):
- b = numpy.dot(A,x)
- print(" La duree elapsed pour %3i produits est de.......: %4.1f s"%(repetitions, time.time()-t_init))
- r = [__d*(__d+1.)*(2.*__d+1.)/6.,]*__d
- if max(abs(b-r)) > precision:
- raise ValueError("Resultat du test errone (1)")
- else:
- print(" Test correct, erreur maximale inferieure a %s"%precision)
- print("")
- del A, x, b
+ def test_Numpy01(self, dimension = 10000, precision = 1.e-17, repetitions = 10):
+ "Test Numpy"
+ __d = int(dimension)
+ print(" %s"%self.test_Numpy01.__doc__)
+ print(" Taille du test..................................: %.0e"%__d)
+ t_init = time.time()
+ A = numpy.array([numpy.arange(dimension)+1.,]*__d)
+ x = numpy.arange(__d)+1.
+ print(" La duree elapsed moyenne de l'initialisation est: %4.1f s"%(time.time()-t_init))
+ #
+ t_init = time.time()
+ for i in range(repetitions):
+ b = numpy.dot(A,x)
+ print(" La duree elapsed pour %3i produits est de.......: %4.1f s"%(repetitions, time.time()-t_init))
+ r = [__d*(__d+1.)*(2.*__d+1.)/6.,]*__d
+ if max(abs(b-r)) > precision:
+ raise ValueError("Resultat du test errone (1)")
+ else:
+ print(" Test correct, erreur maximale inferieure a %s"%precision)
+ print("")
+ del A, x, b
-def testNumpy02(dimension = 3, precision = 1.e-17, repetitions = 100):
- "Test Numpy"
- __d = int(dimension)
- print(" Taille du test..................................: %.0e"%__d)
- t_init = time.time()
- A = numpy.random.normal(0.,1.,size=(__d,__d))
- x = numpy.random.normal(0.,1.,size=(__d,))
- print(" La duree elapsed moyenne de l'initialisation est: %4.1f s"%(time.time()-t_init))
- #
- t_init = time.time()
- for i in range(repetitions):
- b = numpy.dot(A,x)
- print(" La duree elapsed pour %3i produits est de.......: %4.1f s"%(repetitions, time.time()-t_init))
- print("")
- del A, x, b
+ def test_Numpy02(self, dimension = 3000, precision = 1.e-17, repetitions = 100):
+ "Test Numpy"
+ __d = int(dimension)
+ print(" %s"%self.test_Numpy02.__doc__)
+ print(" Taille du test..................................: %.0e"%__d)
+ t_init = time.time()
+ A = numpy.random.normal(0.,1.,size=(__d,__d))
+ x = numpy.random.normal(0.,1.,size=(__d,))
+ print(" La duree elapsed moyenne de l'initialisation est: %4.1f s"%(time.time()-t_init))
+ #
+ t_init = time.time()
+ for i in range(repetitions):
+ b = numpy.dot(A,x)
+ print(" La duree elapsed pour %3i produits est de.......: %4.1f s"%(repetitions, time.time()-t_init))
+ print("")
+ del A, x, b
+
+ def test_Scipy01(self, dimension = 3000, precision = 1.e-17, repetitions = 10):
+ "Test Scipy"
+ __d = int(dimension)
+ print(" %s"%self.test_Scipy01.__doc__)
+ print(" Taille du test..................................: %.0e"%__d)
+ t_init = time.time()
+ A = numpy.array([numpy.arange(dimension)+1.,]*__d)
+ x = numpy.arange(__d)+1.
+ print(" La duree elapsed moyenne de l'initialisation est: %4.1f s"%(time.time()-t_init))
+ #
+ t_init = time.time()
+ for i in range(repetitions):
+ b = scipy.dot(A,x)
+ print(" La duree elapsed pour %3i produits est de.......: %4.1f s"%(repetitions, time.time()-t_init))
+ r = [__d*(__d+1.)*(2.*__d+1.)/6.,]*__d
+ if max(abs(b-r)) > precision:
+ raise ValueError("Resultat du test errone (1)")
+ else:
+ print(" Test correct, erreur maximale inferieure a %s"%precision)
+ print("")
+ del A, x, b
# ==============================================================================
if __name__ == "__main__":
- print('\nAUTODIAGNOSTIC\n')
- testSysteme()
numpy.random.seed(1000)
- testNumpy01(dimension = 1.e4)
- testNumpy02(dimension = 3.e3)
+ print("\nAUTODIAGNOSTIC\n==============")
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
print("")
print(" Les résultats obtenus sont corrects.")
print("")
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"Verification d'un exemple de la documentation"
+import sys
+import unittest
+
# ==============================================================================
-def test1():
- """Test"""
- from numpy import array, matrix
- from adao import adaoBuilder
- case = adaoBuilder.New()
- case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
- case.set( 'Background', Vector=[0, 1, 2] )
- case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
- case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
- case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
- case.set( 'ObservationOperator', Matrix='1 0 0;0 2 0;0 0 3' )
- case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
- case.execute()
- #
- return case.get("Analysis")[-1]
+class Test_Adao(unittest.TestCase):
+ def test1(self):
+ """Test"""
+ print("""Exemple de la doc :
+
+ Un exemple simple de creation d'un cas de calcul TUI ADAO
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ """)
+ #---------------------------------------------------------------------------
+ from numpy import array, matrix
+ from adao import adaoBuilder
+ case = adaoBuilder.New()
+ case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
+ case.set( 'Background', Vector=[0, 1, 2] )
+ case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
+ case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
+ case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
+ case.set( 'ObservationOperator', Matrix='1 0 0;0 2 0;0 0 3' )
+ case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
+ case.execute()
+ #---------------------------------------------------------------------------
+ xa = case.get("Analysis")[-1]
+ ecart = assertAlmostEqualArrays(xa, [0.25, 0.80, 0.95], places = 5)
+ print("")
+ print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
+ print(" Les résultats obtenus sont corrects.")
+ print("")
# ==============================================================================
def assertAlmostEqualArrays(first, second, places=7, msg=None, delta=None):
if msg is not None:
print(msg)
if delta is not None:
- if ( (numpy.asarray(first) - numpy.asarray(second)) > float(delta) ).any():
+ if ( numpy.abs(numpy.asarray(first) - numpy.asarray(second)) > float(delta) ).any():
raise AssertionError("%s != %s within %s places"%(first,second,delta))
else:
- if ( (numpy.asarray(first) - numpy.asarray(second)) > 10**(-int(places)) ).any():
+ if ( numpy.abs(numpy.asarray(first) - numpy.asarray(second)) > 10**(-int(places)) ).any():
raise AssertionError("%s != %s within %i places"%(first,second,places))
return max(abs(numpy.asarray(first) - numpy.asarray(second)))
# ==============================================================================
if __name__ == "__main__":
print('\nAUTODIAGNOSTIC\n')
- print("""Exemple de la doc :
-
- Un exemple simple de creation d'un cas de calcul TUI ADAO
- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- """)
- xa = test1()
- ecart = assertAlmostEqualArrays(xa, [0.25, 0.80, 0.95], places = 5)
- print("")
- print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
- print(" Les résultats obtenus sont corrects.")
- print("")
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"Verification d'un exemple de la documentation"
+import sys
+import unittest
+
# ==============================================================================
-def test1():
- """Test"""
- from numpy import array, matrix
- from adao import adaoBuilder
- case = adaoBuilder.New()
- case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
- case.set( 'Background', Vector=[0, 1, 2] )
- case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
- case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
- case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
- case.set( 'ObservationOperator', Matrix='1 0 0;0 2 0;0 0 3' )
- case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
- case.execute()
- #
- return case.get("Analysis")[-1]
+class Test_Adao(unittest.TestCase):
+ results = []
+ def test1(self):
+ """Test"""
+ print("""Exemple de la doc :
+
+ Creation detaillee d'un cas de calcul TUI ADAO
+ ++++++++++++++++++++++++++++++++++++++++++++++
+ Les deux resultats sont testes pour etre identiques.
+ """)
+ from numpy import array, matrix
+ from adao import adaoBuilder
+ case = adaoBuilder.New()
+ case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
+ case.set( 'Background', Vector=[0, 1, 2] )
+ case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
+ case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
+ case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
+ case.set( 'ObservationOperator', Matrix='1 0 0;0 2 0;0 0 3' )
+ case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
+ case.execute()
+ #
+ xa = case.get("Analysis")[-1]
+ Test_Adao.results.append( xa )
+ return xa
-def test2():
- """Test"""
- from numpy import array, matrix
- from adao import adaoBuilder
- case = adaoBuilder.New()
- case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
- case.set( 'Background', Vector=[0, 1, 2] )
- case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
- case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
- case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
- def simulation(x):
- import numpy
- __x = numpy.matrix(numpy.ravel(numpy.matrix(x))).T
- __H = numpy.matrix("1 0 0;0 2 0;0 0 3")
- return __H * __x
- #
- case.set( 'ObservationOperator',
- OneFunction = simulation,
- Parameters = {"DifferentialIncrement":0.01},
- )
- case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
- case.execute()
- #
- return case.get("Analysis")[-1]
+ def test2(self):
+ """Test"""
+ from numpy import array, matrix
+ from adao import adaoBuilder
+ case = adaoBuilder.New()
+ case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
+ case.set( 'Background', Vector=[0, 1, 2] )
+ case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
+ case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
+ case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
+ def simulation(x):
+ import numpy
+ __x = numpy.matrix(numpy.ravel(numpy.matrix(x))).T
+ __H = numpy.matrix("1 0 0;0 2 0;0 0 3")
+ return __H * __x
+ #
+ case.set( 'ObservationOperator',
+ OneFunction = simulation,
+ Parameters = {"DifferentialIncrement":0.01},
+ )
+ case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
+ case.execute()
+ #
+ xa = case.get("Analysis")[-1]
+ Test_Adao.results.append( xa )
+ return xa
+
+ def test3(self):
+ """Test"""
+ xa2 = Test_Adao.results.pop()
+ xa1 = Test_Adao.results.pop()
+ ecart = assertAlmostEqualArrays(xa1, xa2, places = 15)
+ print("")
+ print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
+ print(" Les résultats obtenus sont corrects.")
+ print("")
# ==============================================================================
def assertAlmostEqualArrays(first, second, places=7, msg=None, delta=None):
if msg is not None:
print(msg)
if delta is not None:
- if ( (numpy.asarray(first) - numpy.asarray(second)) > float(delta) ).any():
+ if ( numpy.abs(numpy.asarray(first) - numpy.asarray(second)) > float(delta) ).any():
raise AssertionError("%s != %s within %s places"%(first,second,delta))
else:
- if ( (numpy.asarray(first) - numpy.asarray(second)) > 10**(-int(places)) ).any():
+ if ( numpy.abs(numpy.asarray(first) - numpy.asarray(second)) > 10**(-int(places)) ).any():
raise AssertionError("%s != %s within %i places"%(first,second,places))
return max(abs(numpy.asarray(first) - numpy.asarray(second)))
# ==============================================================================
if __name__ == "__main__":
print('\nAUTODIAGNOSTIC\n')
- print("""Exemple de la doc :
-
- Creation detaillee d'un cas de calcul TUI ADAO
- ++++++++++++++++++++++++++++++++++++++++++++++
- Les deux resultats sont testes pour etre identiques.
- """)
- xa1 = test1()
- xa2 = test2()
- ecart = assertAlmostEqualArrays(xa1, xa2, places = 15)
- print("")
- print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
- print(" Les résultats obtenus sont corrects.")
- print("")
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"Verification d'un exemple de la documentation"
+import sys
+import unittest
+
# ==============================================================================
#
# Construction artificielle d'un exemple de donnees utilisateur
observations = simulation((2, 3, 4))
# ==============================================================================
-def test1():
- "Test"
- import numpy
- from adao import adaoBuilder
- #
- # Mise en forme des entrees
- # -------------------------
- Xb = (alpha, beta, gamma)
- Bounds = (
- (alphamin, alphamax),
- (betamin, betamax ),
- (gammamin, gammamax))
- #
- # TUI ADAO
- # --------
- case = adaoBuilder.New()
- case.set(
- 'AlgorithmParameters',
- Algorithm = '3DVAR',
- Parameters = {
- "Bounds":Bounds,
- "MaximumNumberOfSteps":100,
- "StoreSupplementaryCalculations":[
- "CostFunctionJ",
- "CurrentState",
- "SimulatedObservationAtOptimum",
- ],
- }
- )
- case.set( 'Background', Vector = numpy.array(Xb), Stored = True )
- case.set( 'Observation', Vector = numpy.array(observations) )
- case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 )
- case.set( 'ObservationError', ScalarSparseMatrix = 1.0 )
- case.set(
- 'ObservationOperator',
- OneFunction = simulation,
- Parameters = {"DifferentialIncrement":0.0001},
- )
- case.set( 'Observer', Variable="CurrentState", Template="ValuePrinter" )
- case.execute()
- #
- # Exploitation independante
- # -------------------------
- Xbackground = case.get("Background")
- Xoptimum = case.get("Analysis")[-1]
- FX_at_optimum = case.get("SimulatedObservationAtOptimum")[-1]
- J_values = case.get("CostFunctionJ")[:]
- print("")
- print("Number of internal iterations...: %i"%len(J_values))
- print("Initial state...................: %s"%(numpy.ravel(Xbackground),))
- print("Optimal state...................: %s"%(numpy.ravel(Xoptimum),))
- print("Simulation at optimal state.....: %s"%(numpy.ravel(FX_at_optimum),))
- print("")
- #
- return case.get("Analysis")[-1]
+class Test_Adao(unittest.TestCase):
+ def test1(self):
+ "Test"
+ print("""Exemple de la doc :
+
+ Exploitation independante des resultats d'un cas de calcul
+ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ """)
+ #---------------------------------------------------------------------------
+ import numpy
+ from adao import adaoBuilder
+ #
+ # Mise en forme des entrees
+ # -------------------------
+ Xb = (alpha, beta, gamma)
+ Bounds = (
+ (alphamin, alphamax),
+ (betamin, betamax ),
+ (gammamin, gammamax))
+ #
+ # TUI ADAO
+ # --------
+ case = adaoBuilder.New()
+ case.set(
+ 'AlgorithmParameters',
+ Algorithm = '3DVAR',
+ Parameters = {
+ "Bounds":Bounds,
+ "MaximumNumberOfSteps":100,
+ "StoreSupplementaryCalculations":[
+ "CostFunctionJ",
+ "CurrentState",
+ "SimulatedObservationAtOptimum",
+ ],
+ }
+ )
+ case.set( 'Background', Vector = numpy.array(Xb), Stored = True )
+ case.set( 'Observation', Vector = numpy.array(observations) )
+ case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 )
+ case.set( 'ObservationError', ScalarSparseMatrix = 1.0 )
+ case.set(
+ 'ObservationOperator',
+ OneFunction = simulation,
+ Parameters = {"DifferentialIncrement":0.0001},
+ )
+ case.set( 'Observer', Variable="CurrentState", Template="ValuePrinter" )
+ case.execute()
+ #
+ # Exploitation independante
+ # -------------------------
+ Xbackground = case.get("Background")
+ Xoptimum = case.get("Analysis")[-1]
+ FX_at_optimum = case.get("SimulatedObservationAtOptimum")[-1]
+ J_values = case.get("CostFunctionJ")[:]
+ print("")
+ print("Number of internal iterations...: %i"%len(J_values))
+ print("Initial state...................: %s"%(numpy.ravel(Xbackground),))
+ print("Optimal state...................: %s"%(numpy.ravel(Xoptimum),))
+ print("Simulation at optimal state.....: %s"%(numpy.ravel(FX_at_optimum),))
+ print("")
+ #
+ #---------------------------------------------------------------------------
+ xa = case.get("Analysis")[-1]
+ ecart = assertAlmostEqualArrays(xa, [ 2., 3., 4.])
+ #
+ print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
+ print(" Les résultats obtenus sont corrects.")
+ print("")
+ #
+ return xa
# ==============================================================================
def assertAlmostEqualArrays(first, second, places=7, msg=None, delta=None):
# ==============================================================================
if __name__ == "__main__":
print('\nAUTODIAGNOSTIC\n')
- print("""Exemple de la doc :
-
- Exploitation independante des resultats d'un cas de calcul
- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- """)
- xa = test1()
- ecart = assertAlmostEqualArrays(xa, [ 2., 3., 4.])
- #
- print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
- print(" Les résultats obtenus sont corrects.")
- print("")
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"Verification d'un exemple de la documentation"
+import sys
+import unittest
+
# ==============================================================================
#
# Construction artificielle d'un exemple de donnees utilisateur
observations = simulation((2, 3, 4))
# ==============================================================================
-def test1():
- "Test"
- import numpy
- from adao import adaoBuilder
- #
- # Mise en forme des entrees
- # -------------------------
- Xb = (alpha, beta, gamma)
- Bounds = (
- (alphamin, alphamax),
- (betamin, betamax ),
- (gammamin, gammamax))
- #
- # TUI ADAO
- # --------
- case = adaoBuilder.New()
- case.set(
- 'AlgorithmParameters',
- Algorithm = '3DVAR',
- Parameters = {
- "Bounds":Bounds,
- "MaximumNumberOfSteps":100,
- "StoreSupplementaryCalculations":[
- "CostFunctionJ",
- "CurrentState",
- "SimulatedObservationAtOptimum",
- ],
- }
- )
- case.set( 'Background', Vector = numpy.array(Xb), Stored = True )
- case.set( 'Observation', Vector = numpy.array(observations) )
- case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 )
- case.set( 'ObservationError', ScalarSparseMatrix = 1.0 )
- case.set(
- 'ObservationOperator',
- OneFunction = multisimulation,
- Parameters = {"DifferentialIncrement":0.0001},
- InputFunctionAsMulti = True,
- )
- case.set( 'Observer', Variable="CurrentState", Template="ValuePrinter" )
- case.execute()
- #
- # Exploitation independante
- # -------------------------
- Xbackground = case.get("Background")
- Xoptimum = case.get("Analysis")[-1]
- FX_at_optimum = case.get("SimulatedObservationAtOptimum")[-1]
- J_values = case.get("CostFunctionJ")[:]
- print("")
- print("Number of internal iterations...: %i"%len(J_values))
- print("Initial state...................: %s"%(numpy.ravel(Xbackground),))
- print("Optimal state...................: %s"%(numpy.ravel(Xoptimum),))
- print("Simulation at optimal state.....: %s"%(numpy.ravel(FX_at_optimum),))
- print("")
- #
- return case.get("Analysis")[-1]
+class Test_Adao(unittest.TestCase):
+ def test1(self):
+ "Test"
+ print("""Exemple de la doc :
+
+ Exploitation independante des resultats d'un cas de calcul
+ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ """)
+ #---------------------------------------------------------------------------
+ import numpy
+ from adao import adaoBuilder
+ #
+ # Mise en forme des entrees
+ # -------------------------
+ Xb = (alpha, beta, gamma)
+ Bounds = (
+ (alphamin, alphamax),
+ (betamin, betamax ),
+ (gammamin, gammamax))
+ #
+ # TUI ADAO
+ # --------
+ case = adaoBuilder.New()
+ case.set(
+ 'AlgorithmParameters',
+ Algorithm = '3DVAR',
+ Parameters = {
+ "Bounds":Bounds,
+ "MaximumNumberOfSteps":100,
+ "StoreSupplementaryCalculations":[
+ "CostFunctionJ",
+ "CurrentState",
+ "SimulatedObservationAtOptimum",
+ ],
+ }
+ )
+ case.set( 'Background', Vector = numpy.array(Xb), Stored = True )
+ case.set( 'Observation', Vector = numpy.array(observations) )
+ case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 )
+ case.set( 'ObservationError', ScalarSparseMatrix = 1.0 )
+ case.set(
+ 'ObservationOperator',
+ OneFunction = multisimulation,
+ Parameters = {"DifferentialIncrement":0.0001},
+ InputFunctionAsMulti = True,
+ )
+ case.set( 'Observer', Variable="CurrentState", Template="ValuePrinter" )
+ case.execute()
+ #
+ # Exploitation independante
+ # -------------------------
+ Xbackground = case.get("Background")
+ Xoptimum = case.get("Analysis")[-1]
+ FX_at_optimum = case.get("SimulatedObservationAtOptimum")[-1]
+ J_values = case.get("CostFunctionJ")[:]
+ print("")
+ print("Number of internal iterations...: %i"%len(J_values))
+ print("Initial state...................: %s"%(numpy.ravel(Xbackground),))
+ print("Optimal state...................: %s"%(numpy.ravel(Xoptimum),))
+ print("Simulation at optimal state.....: %s"%(numpy.ravel(FX_at_optimum),))
+ print("")
+ #
+ #---------------------------------------------------------------------------
+ xa = case.get("Analysis")[-1]
+ ecart = assertAlmostEqualArrays(xa, [ 2., 3., 4.])
+ #
+ print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
+ print(" Les résultats obtenus sont corrects.")
+ print("")
+ #
+ return xa
# ==============================================================================
def assertAlmostEqualArrays(first, second, places=7, msg=None, delta=None):
# ==============================================================================
if __name__ == "__main__":
print('\nAUTODIAGNOSTIC\n')
- print("""Exemple de la doc :
-
- Exploitation independante des resultats d'un cas de calcul
- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- """)
- xa = test1()
- ecart = assertAlmostEqualArrays(xa, [ 2., 3., 4.])
- #
- print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
- print(" Les résultats obtenus sont corrects.")
- print("")
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
"Verification d'un exemple de la documentation"
-import os, pprint
+import sys, os, pprint
+import unittest
# ==============================================================================
-def test1():
- """Test"""
- from numpy import array, matrix
- from adao import adaoBuilder
- case = adaoBuilder.New()
- case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
- case.set( 'Background', Vector=[0, 1, 2] )
- case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
- case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
- case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
- case.set( 'ObservationOperator', Matrix='1 0 0;0 2 0;0 0 3' )
- case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
- #
- case.setObserver("Analysis", String="print('==> Nombre d analyses : %i'%len(var))")
- #
- case.execute()
- #
- base_file = "output_test6711"
- print("")
- print("#===============================================================================")
- #
- print("#=== Restitution en dictionnaire basique =======================================")
- case.get()
- print("#===============================================================================")
- #
- print("#=== Restitution en fichier TUI ================================================")
- # print(case.dump(FileName=base_file+"_TUI.py", Formater="TUI"))
- case.dump(FileName=base_file+"_TUI.py", Formater="TUI")
- print("#===============================================================================")
- #
- print("#=== Restitution en fichier SCD ================================================")
- # print(case.dump(FileName=base_file+"_SCD.py", Formater="SCD"))
- case.dump(FileName=base_file+"_SCD.py", Formater="SCD")
- print("#===============================================================================")
- #
- # print("#=== Restitution en fichier YACS ===============================================")
- # # print(case.dump(FileName=base_file+"_YACS.xml", Formater="YACS"))
- # case.dump(FileName=base_file+"_YACS.xml", Formater="YACS")
- # print("#===============================================================================")
- #
- print("")
- cwd = os.getcwd()
- for f in [
- base_file+"_TUI.py",
- base_file+"_SCD.py",
- # base_file+"_YACS.xml",
- ]:
- if os.path.exists(os.path.abspath(cwd+"/"+f)):
- print("#=== Fichier \"%s\" correctement généré"%f)
- os.remove(os.path.abspath(cwd+"/"+f))
- else:
- raise ValueError("Fichier \"%s\" inexistant"%f)
- print("")
- #
- return case.get("Analysis")[-1]
+class Test_Adao(unittest.TestCase):
+ def test1(self):
+ """Test"""
+ print("""Exemple de la doc :
+
+ Cas-test vérifiant les conversions
+ ++++++++++++++++++++++++++++++++++\n""")
+ #-----------------------------------------------------------------------
+ from numpy import array, matrix
+ from adao import adaoBuilder
+ case = adaoBuilder.New()
+ case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
+ case.set( 'Background', Vector=[0, 1, 2] )
+ case.set( 'BackgroundError', ScalarSparseMatrix=1.0 )
+ case.set( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
+ case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
+ case.set( 'ObservationOperator', Matrix='1 0 0;0 2 0;0 0 3' )
+ case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
+ #
+ case.setObserver("Analysis", String="print('==> Nombre d analyses : %i'%len(var))")
+ #
+ case.execute()
+ #
+ base_file = "output_test6711"
+ print("")
+ print("#===============================================================================")
+ #
+ print("#=== Restitution en dictionnaire basique =======================================")
+ case.get()
+ print("#===============================================================================")
+ #
+ print("#=== Restitution en fichier TUI ================================================")
+ # print(case.dump(FileName=base_file+"_TUI.py", Formater="TUI"))
+ case.dump(FileName=base_file+"_TUI.py", Formater="TUI")
+ print("#===============================================================================")
+ #
+ print("#=== Restitution en fichier SCD ================================================")
+ # print(case.dump(FileName=base_file+"_SCD.py", Formater="SCD"))
+ case.dump(FileName=base_file+"_SCD.py", Formater="SCD")
+ print("#===============================================================================")
+ #
+ # print("#=== Restitution en fichier YACS ===============================================")
+ # # print(case.dump(FileName=base_file+"_YACS.xml", Formater="YACS"))
+ # case.dump(FileName=base_file+"_YACS.xml", Formater="YACS")
+ # print("#===============================================================================")
+ #
+ print("")
+ cwd = os.getcwd()
+ for f in [
+ base_file+"_TUI.py",
+ base_file+"_SCD.py",
+ # base_file+"_YACS.xml",
+ ]:
+ if os.path.exists(os.path.abspath(cwd+"/"+f)):
+ print("#=== Fichier \"%s\" correctement généré"%f)
+ os.remove(os.path.abspath(cwd+"/"+f))
+ else:
+ raise ValueError("Fichier \"%s\" inexistant"%f)
+ print("")
+ #-----------------------------------------------------------------------
+ xa = case.get("Analysis")[-1]
+ ecart = assertAlmostEqualArrays(xa, [0.25, 0.80, 0.95], places = 5)
+ #
+ print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
+ print(" Les résultats obtenus sont corrects.")
+ print("")
+ #
+ return xa
# ==============================================================================
def assertAlmostEqualArrays(first, second, places=7, msg=None, delta=None):
# ==============================================================================
if __name__ == "__main__":
- print('\n AUTODIAGNOSTIC\n')
- print("""Exemple de la doc :
-
- Cas-test vérifiant les conversions
- ++++++++++++++++++++++++++++++++++
-""")
- xa = test1()
- ecart = assertAlmostEqualArrays(xa, [0.25, 0.80, 0.95], places = 5)
- #
- print(" L'écart absolu maximal obtenu lors du test est de %.2e."%ecart)
- print(" Les résultats obtenus sont corrects.")
- print("")
+ print('\nAUTODIAGNOSTIC\n')
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
from adao import adaoBuilder
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""Verification de la disponibilite de l'ensemble des algorithmes\n(Utilisation d'un operateur matriciel)"""
print(self.test1.__doc__)
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
from adao import adaoBuilder
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
for algo in ("AdjointTest", "FunctionTest", "GradientTest", "LinearityTest", "TangentTest"):
print("")
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
return _mulHX
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""
Verification du fonctionnement identique pour les algorithmes non-temporels
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
return _mulHX
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""
Verification du fonctionnement identique pour les algorithmes temporels
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
return _mulHX
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""
Verification du fonctionnement identique pour les algorithmes autres
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
return _ySerie
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""
Verification du fonctionnement identique pour les algorithmes non-temporels
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
return _ySerie
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""
Verification du fonctionnement identique pour les algorithmes temporels
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
return _ySerie
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
"""
Verification du fonctionnement identique pour les algorithmes autres
#===============================================================================
if __name__ == "__main__":
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
observations = simulation((2, 3, 4))
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
print("""
Full definition of a use case for the standard user
# ==============================================================================
if __name__ == '__main__':
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
observations = simulation((2, 3, 4))
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
print("""
Full definition of a use case for the standard user
# ==============================================================================
if __name__ == '__main__':
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
observations = simulation((2, 3, 4))
# ==============================================================================
-class InTest(unittest.TestCase):
+class Test_Adao(unittest.TestCase):
def test1(self):
print("""
Full definition of a use case for the standard user
# ==============================================================================
if __name__ == '__main__':
print("\nAUTODIAGNOSTIC\n==============")
- unittest.main()
+ sys.stderr = sys.stdout
+ unittest.main(verbosity=2)
