From 06f3de22e3d123367ac2548ad7d5567f43352916 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Tue, 7 Feb 2023 21:17:27 +0100 Subject: [PATCH] Code and documentation update for ControledFunctionTest --- doc/en/examples.rst | 1 + .../ref_algorithm_ControledFunctionTest.rst | 131 +++++++++ doc/en/ref_algorithm_FunctionTest.rst | 1 + doc/en/ref_algorithm_InputValuesTest.rst | 1 + doc/en/ref_algorithm_ParallelFunctionTest.rst | 3 +- .../scripts/simple_ControledFunctionTest1.py | 17 ++ .../scripts/simple_ControledFunctionTest1.res | 74 +++++ .../scripts/simple_ControledFunctionTest1.rst | 21 ++ .../scripts/simple_ControledFunctionTest2.py | 35 +++ .../scripts/simple_ControledFunctionTest2.res | 74 +++++ .../scripts/simple_ControledFunctionTest2.rst | 19 ++ .../ref_algorithm_ControledFunctionTest.rst | 132 +++++++++ doc/fr/ref_algorithm_FunctionTest.rst | 1 + doc/fr/ref_algorithm_ParallelFunctionTest.rst | 3 +- doc/fr/reference.rst | 1 + .../scripts/simple_ControledFunctionTest1.py | 17 ++ .../scripts/simple_ControledFunctionTest1.res | 74 +++++ .../scripts/simple_ControledFunctionTest1.rst | 22 ++ .../scripts/simple_ControledFunctionTest2.py | 35 +++ .../scripts/simple_ControledFunctionTest2.res | 74 +++++ .../scripts/simple_ControledFunctionTest2.rst | 21 ++ .../daAlgorithms/ControledFunctionTest.py | 268 ++++++++++++++++++ 22 files changed, 1023 insertions(+), 2 deletions(-) create mode 100644 doc/en/ref_algorithm_ControledFunctionTest.rst create mode 100644 doc/en/scripts/simple_ControledFunctionTest1.py create mode 100644 doc/en/scripts/simple_ControledFunctionTest1.res create mode 100644 doc/en/scripts/simple_ControledFunctionTest1.rst create mode 100644 doc/en/scripts/simple_ControledFunctionTest2.py create mode 100644 doc/en/scripts/simple_ControledFunctionTest2.res create mode 100644 doc/en/scripts/simple_ControledFunctionTest2.rst create mode 100644 doc/fr/ref_algorithm_ControledFunctionTest.rst create mode 100644 doc/fr/scripts/simple_ControledFunctionTest1.py create mode 100644 doc/fr/scripts/simple_ControledFunctionTest1.res create mode 100644 doc/fr/scripts/simple_ControledFunctionTest1.rst create mode 100644 doc/fr/scripts/simple_ControledFunctionTest2.py create mode 100644 doc/fr/scripts/simple_ControledFunctionTest2.res create mode 100644 doc/fr/scripts/simple_ControledFunctionTest2.rst create mode 100644 src/daComposant/daAlgorithms/ControledFunctionTest.py diff --git a/doc/en/examples.rst b/doc/en/examples.rst index df4b031..c3feccc 100644 --- a/doc/en/examples.rst +++ b/doc/en/examples.rst @@ -54,6 +54,7 @@ Checking algorithms uses ------------------------ #. :ref:`Examples with the "AdjointTest" check` +#. :ref:`Examples with the "ControledFunctionTest"` #. :ref:`Examples with the "FunctionTest" check` #. :ref:`Examples with the "ParallelFunctionTest" check` diff --git a/doc/en/ref_algorithm_ControledFunctionTest.rst b/doc/en/ref_algorithm_ControledFunctionTest.rst new file mode 100644 index 0000000..9d059d9 --- /dev/null +++ b/doc/en/ref_algorithm_ControledFunctionTest.rst @@ -0,0 +1,131 @@ +.. + Copyright (C) 2008-2023 EDF R&D + + This file is part of SALOME ADAO module. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com + + Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D + +.. index:: single: ControledFunctionTest +.. _section_ref_algorithm_ControledFunctionTest: + +Checking algorithm "*ControledFunctionTest*" +-------------------------------------------- + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo01.rst + +This algorithm allows to verify that a given operator :math:`F`, in particular +the observation one, is working correctly and that its call is compatible with +its usage in ADAO algorithms. In practice, it allows to call one or several +times the operator, activating or not the "debug" mode during execution. The +:math:`F` operator is considered to depend on a state vector variable +:math:`\mathbf{x}` and on a control vector variable :math:`\mathbf{u}`, the two +not necessarily being of the same size. + +Statistics on input and output vectors for each execution of operator are +given, and an another global statistic is given at the end of the checking +algorithm. The precision of printed outputs can be controlled to facilitate +automatic tests of operator. It may also be useful to check the entries +themselves beforehand with the intended test +:ref:`section_ref_algorithm_InputValuesTest`. + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo02.rst + +.. include:: snippets/CheckingPoint.rst + +.. include:: snippets/ObservationOperator.rst + +.. include:: snippets/ControlInput.rst + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo03Chck.rst + +.. include:: snippets/NumberOfPrintedDigits.rst + +.. include:: snippets/NumberOfRepetition.rst + +.. include:: snippets/SetDebug.rst + +.. include:: snippets/ShowElementarySummary.rst + +StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ + "CurrentState", + "SimulatedObservationAtCurrentState", + ]. + + Example : + ``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}`` + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo04.rst + +.. include:: snippets/NoUnconditionalOutput.rst + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo05.rst + +.. include:: snippets/CurrentState.rst + +.. include:: snippets/SimulatedObservationAtCurrentState.rst + +.. ------------------------------------ .. +.. _section_ref_algorithm_ControledFunctionTest_examples: + +.. include:: snippets/Header2Algo09.rst + +.. --------- .. +.. include:: scripts/simple_ControledFunctionTest1.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest1.py + +.. include:: snippets/Header2Algo10.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest1.res + :language: none + +.. --------- .. +.. include:: scripts/simple_ControledFunctionTest2.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest2.py + +.. include:: snippets/Header2Algo10.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest2.res + :language: none + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo06.rst + +- :ref:`section_ref_algorithm_InputValuesTest` +- :ref:`section_ref_algorithm_LinearityTest` +- :ref:`section_ref_algorithm_FunctionTest` +- :ref:`section_ref_algorithm_ParallelFunctionTest` diff --git a/doc/en/ref_algorithm_FunctionTest.rst b/doc/en/ref_algorithm_FunctionTest.rst index 81755ae..bc8a7d4 100644 --- a/doc/en/ref_algorithm_FunctionTest.rst +++ b/doc/en/ref_algorithm_FunctionTest.rst @@ -124,5 +124,6 @@ StoreSupplementaryCalculations - :ref:`section_ref_algorithm_InputValuesTest` - :ref:`section_ref_algorithm_LinearityTest` +- :ref:`section_ref_algorithm_ControledFunctionTest` - :ref:`section_ref_algorithm_ParallelFunctionTest` - :ref:`section_ref_algorithm_EnsembleOfSimulationGenerationTask` diff --git a/doc/en/ref_algorithm_InputValuesTest.rst b/doc/en/ref_algorithm_InputValuesTest.rst index 32ff3da..aa49e3e 100644 --- a/doc/en/ref_algorithm_InputValuesTest.rst +++ b/doc/en/ref_algorithm_InputValuesTest.rst @@ -72,5 +72,6 @@ if a variable is large in size, this can be difficult*). .. include:: snippets/Header2Algo06.rst +- :ref:`section_ref_algorithm_ControledFunctionTest` - :ref:`section_ref_algorithm_FunctionTest` - :ref:`section_ref_algorithm_ParallelFunctionTest` diff --git a/doc/en/ref_algorithm_ParallelFunctionTest.rst b/doc/en/ref_algorithm_ParallelFunctionTest.rst index 3f4ace7..d439c9b 100644 --- a/doc/en/ref_algorithm_ParallelFunctionTest.rst +++ b/doc/en/ref_algorithm_ParallelFunctionTest.rst @@ -110,7 +110,8 @@ StoreSupplementaryCalculations .. ------------------------------------ .. .. include:: snippets/Header2Algo06.rst -- :ref:`section_ref_algorithm_FunctionTest` - :ref:`section_ref_algorithm_InputValuesTest` - :ref:`section_ref_algorithm_LinearityTest` +- :ref:`section_ref_algorithm_FunctionTest` +- :ref:`section_ref_algorithm_ControledFunctionTest` - :ref:`section_ref_algorithm_EnsembleOfSimulationGenerationTask` diff --git a/doc/en/scripts/simple_ControledFunctionTest1.py b/doc/en/scripts/simple_ControledFunctionTest1.py new file mode 100644 index 0000000..58d4645 --- /dev/null +++ b/doc/en/scripts/simple_ControledFunctionTest1.py @@ -0,0 +1,17 @@ +# -*- coding: utf-8 -*- +# +from numpy import array, eye +from adao import adaoBuilder +case = adaoBuilder.New() +case.setCheckingPoint( Vector = array([0., 1., 2.]), Stored=True ) +case.setObservationOperator( Matrix = eye(3) ) +case.setAlgorithmParameters( + Algorithm='ControledFunctionTest', + Parameters={ + 'NumberOfRepetition' : 5, + 'NumberOfPrintedDigits' : 2, + 'ShowElementarySummary':False, + }, + ) +case.setControlInput( Vector = 1. ) +case.execute() diff --git a/doc/en/scripts/simple_ControledFunctionTest1.res b/doc/en/scripts/simple_ControledFunctionTest1.res new file mode 100644 index 0000000..a5c93df --- /dev/null +++ b/doc/en/scripts/simple_ControledFunctionTest1.res @@ -0,0 +1,74 @@ + + CONTROLEDFUNCTIONTEST + ===================== + + This test allows to analyze the (repetition of the) launch of some + given simulation operator F, applied to one single vector x and to + one control vector u as arguments, in a sequential way. + The output shows simple statistics related to its successful execution, + or related to the similarities of repetition of its execution. + +===> Information before launching: + ----------------------------- + + Characteristics of input vector X, internally converted: + Type...............: + Length of vector...: 3 + Minimum value......: 0.00e+00 + Maximum value......: 2.00e+00 + Mean of vector.....: 1.00e+00 + Standard error.....: 8.16e-01 + L2 norm of vector..: 2.24e+00 + + Characteristics of control parameter U, internally converted: + Type...............: + Length of vector...: 1 + Minimum value......: 1.00e+00 + Maximum value......: 1.00e+00 + Mean of vector.....: 1.00e+00 + Standard error.....: 0.00e+00 + L2 norm of vector..: 1.00e+00 + + --------------------------------------------------------------------------- + +===> Beginning of repeated evaluation, without activating debug + + --------------------------------------------------------------------------- + +===> End of repeated evaluation, without deactivating debug + + --------------------------------------------------------------------------- + +===> Launching statistical summary calculation for 5 states + + --------------------------------------------------------------------------- + +===> Statistical analysis of the outputs obtained through sequential repeated evaluations + + (Remark: numbers that are (about) under 2e-16 represent 0 to machine precision) + + Number of evaluations...........................: 5 + + Characteristics of the whole set of outputs Y: + Size of each of the outputs...................: 3 + Minimum value of the whole set of outputs.....: 0.00e+00 + Maximum value of the whole set of outputs.....: 2.00e+00 + Mean of vector of the whole set of outputs....: 1.00e+00 + Standard error of the whole set of outputs....: 8.16e-01 + + Characteristics of the vector Ym, mean of the outputs Y: + Size of the mean of the outputs...............: 3 + Minimum value of the mean of the outputs......: 0.00e+00 + Maximum value of the mean of the outputs......: 2.00e+00 + Mean of the mean of the outputs...............: 1.00e+00 + Standard error of the mean of the outputs.....: 8.16e-01 + + Characteristics of the mean of the differences between the outputs Y and their mean Ym: + Size of the mean of the differences...........: 3 + Minimum value of the mean of the differences..: 0.00e+00 + Maximum value of the mean of the differences..: 0.00e+00 + Mean of the mean of the differences...........: 0.00e+00 + Standard error of the mean of the differences.: 0.00e+00 + + --------------------------------------------------------------------------- + diff --git a/doc/en/scripts/simple_ControledFunctionTest1.rst b/doc/en/scripts/simple_ControledFunctionTest1.rst new file mode 100644 index 0000000..39bb568 --- /dev/null +++ b/doc/en/scripts/simple_ControledFunctionTest1.rst @@ -0,0 +1,21 @@ +.. index:: single: ControledFunctionTest (example) + +First example +............. + +This example describes the test that the given operator works properly, and +that its call proceeds in a way compatible with its common use in the ADAO +algorithms. The required information are minimal, namely here an operator +:math:`F` (described for the test by the command "*ObservationOperator*"), a +particular state :math:`\mathbf{x}` to test it on (described for the test by +the command "*CheckingPoint*") and a control :math:`\mathbf{u}` (described for +the test by the command "*ControlInput*"), both being not necessarily of the +same size. + +The test is repeated a configurable number of times, and a final statistic +makes it possible to quickly verify the operator's good behavior. The simplest +diagnostic consists in checking, at the very end of the display, the order of +magnitude of variations in the values indicated as the mean of the differences between the +repeated outputs and their mean, under the part entitled "*Characteristics of +the mean of the differences between the outputs Y and their mean Ym*". For a +satisfactory operator, these values should be close to the numerical zero. diff --git a/doc/en/scripts/simple_ControledFunctionTest2.py b/doc/en/scripts/simple_ControledFunctionTest2.py new file mode 100644 index 0000000..03da7ec --- /dev/null +++ b/doc/en/scripts/simple_ControledFunctionTest2.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# +from numpy import array, ravel +def ControledQuadFunction( pair ): + """ + Controlled quadratic simulation + """ + coefficients, control = pair + # + u, v = list(ravel(control)) + a, b, c = list(ravel(coefficients)) + x_points = (-5, 0, 1, 3, 10) + y_points = [] + for x in x_points: + y_points.append( (a*x*x + b*x + c + v) * u ) + return array(y_points) +# +from adao import adaoBuilder +case = adaoBuilder.New() +case.set( 'CheckingPoint', Vector = array([1., 1., 1.]), Stored=True ) +case.set( 'ObservationOperator', ThreeFunctions = { + "Direct" :ControledQuadFunction, + "Tangent":0, # Empty operator (not None) as not used + "Adjoint":0, # Empty operator (not None) as not used + } ) +case.set( "ControlInput", Vector = (1, 0) ) +case.setAlgorithmParameters( + Algorithm='ControledFunctionTest', + Parameters={ + 'NumberOfRepetition' : 15, + 'NumberOfPrintedDigits' : 3, + 'ShowElementarySummary':False, + }, + ) +case.execute() diff --git a/doc/en/scripts/simple_ControledFunctionTest2.res b/doc/en/scripts/simple_ControledFunctionTest2.res new file mode 100644 index 0000000..46e700b --- /dev/null +++ b/doc/en/scripts/simple_ControledFunctionTest2.res @@ -0,0 +1,74 @@ + + CONTROLEDFUNCTIONTEST + ===================== + + This test allows to analyze the (repetition of the) launch of some + given simulation operator F, applied to one single vector x and to + one control vector u as arguments, in a sequential way. + The output shows simple statistics related to its successful execution, + or related to the similarities of repetition of its execution. + +===> Information before launching: + ----------------------------- + + Characteristics of input vector X, internally converted: + Type...............: + Length of vector...: 3 + Minimum value......: 1.000e+00 + Maximum value......: 1.000e+00 + Mean of vector.....: 1.000e+00 + Standard error.....: 0.000e+00 + L2 norm of vector..: 1.732e+00 + + Characteristics of control parameter U, internally converted: + Type...............: + Length of vector...: 2 + Minimum value......: 0.000e+00 + Maximum value......: 1.000e+00 + Mean of vector.....: 5.000e-01 + Standard error.....: 5.000e-01 + L2 norm of vector..: 1.000e+00 + + --------------------------------------------------------------------------- + +===> Beginning of repeated evaluation, without activating debug + + --------------------------------------------------------------------------- + +===> End of repeated evaluation, without deactivating debug + + --------------------------------------------------------------------------- + +===> Launching statistical summary calculation for 15 states + + --------------------------------------------------------------------------- + +===> Statistical analysis of the outputs obtained through sequential repeated evaluations + + (Remark: numbers that are (about) under 2e-16 represent 0 to machine precision) + + Number of evaluations...........................: 15 + + Characteristics of the whole set of outputs Y: + Size of each of the outputs...................: 5 + Minimum value of the whole set of outputs.....: 1.000e+00 + Maximum value of the whole set of outputs.....: 1.110e+02 + Mean of vector of the whole set of outputs....: 2.980e+01 + Standard error of the whole set of outputs....: 4.123e+01 + + Characteristics of the vector Ym, mean of the outputs Y: + Size of the mean of the outputs...............: 5 + Minimum value of the mean of the outputs......: 1.000e+00 + Maximum value of the mean of the outputs......: 1.110e+02 + Mean of the mean of the outputs...............: 2.980e+01 + Standard error of the mean of the outputs.....: 4.123e+01 + + Characteristics of the mean of the differences between the outputs Y and their mean Ym: + Size of the mean of the differences...........: 5 + Minimum value of the mean of the differences..: 0.000e+00 + Maximum value of the mean of the differences..: 0.000e+00 + Mean of the mean of the differences...........: 0.000e+00 + Standard error of the mean of the differences.: 0.000e+00 + + --------------------------------------------------------------------------- + diff --git a/doc/en/scripts/simple_ControledFunctionTest2.rst b/doc/en/scripts/simple_ControledFunctionTest2.rst new file mode 100644 index 0000000..e23455d --- /dev/null +++ b/doc/en/scripts/simple_ControledFunctionTest2.rst @@ -0,0 +1,19 @@ +Second example +.............. + +This new example describes the test of the correct operation of a given +operator named ``ControledQuadFunction``, available under its functional form. +It is defined by the command "*ObservationOperator*" as +:ref:`section_ref_operator_funcs` (here, even with this functional form, one +can exceptionally not define the tangent and adjoint forms of the operator +because they are not useful in this test). Using the command "*CheckingPoint*", +one add also a particular state :math:`\mathbf{x}` to test the operator on, and +using the command "*ControlInput*", one add a fixed control :math:`\mathbf{u}`. + +The test is repeated here 15 times, and a final statistic makes it possible to +quickly verify the operator's good behavior. The simplest diagnostic consists +in checking, at the very end of the display, the order of magnitude of +variations in the values indicated as the mean of the differences between the +repeated outputs and their mean, under the part entitled "*Characteristics of +the mean of the differences between the outputs Y and their mean Ym*". For a +satisfactory operator, these values should be close to the numerical zero. diff --git a/doc/fr/ref_algorithm_ControledFunctionTest.rst b/doc/fr/ref_algorithm_ControledFunctionTest.rst new file mode 100644 index 0000000..ccdcc2d --- /dev/null +++ b/doc/fr/ref_algorithm_ControledFunctionTest.rst @@ -0,0 +1,132 @@ +.. + Copyright (C) 2008-2023 EDF R&D + + This file is part of SALOME ADAO module. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com + + Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D + +.. index:: single: ControledFunctionTest +.. _section_ref_algorithm_ControledFunctionTest: + +Algorithme de vérification "*ControledFunctionTest*" +---------------------------------------------------- + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo01.rst + +Cet algorithme permet de vérifier qu'un opérateur :math:`F` quelconque, dont en +particulier celui d'observation, fonctionne correctement et que son appel se +déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De +manière pratique, il permet d'appeler une ou plusieurs fois l'opérateur, en +activant ou non le mode "debug" lors de l'exécution. L'opérateur :math:`F` est +considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et d'un +contrôle :math:`\mathbf{u}`, les deux n'étant pas nécessairement de la même +taille. + +Une statistique sur les vecteurs en entrée et en sortie de chaque exécution de +l'opérateur est indiquée, et une autre globale est fournie de manière +récapitulative à la fin de l'algorithme de vérification. La précision +d'affichage est contrôlable pour permettre l'automatisation des tests +d'opérateur. Il peut être aussi utile de vérifier préalablement les entrées +elles-mêmes avec le test prévu :ref:`section_ref_algorithm_InputValuesTest`. + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo02.rst + +.. include:: snippets/CheckingPoint.rst + +.. include:: snippets/ObservationOperator.rst + +.. include:: snippets/ControlInput.rst + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo03Chck.rst + +.. include:: snippets/NumberOfPrintedDigits.rst + +.. include:: snippets/NumberOfRepetition.rst + +.. include:: snippets/SetDebug.rst + +.. include:: snippets/ShowElementarySummary.rst + +StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, + qui peuvent être disponibles au cours du déroulement ou à la fin de + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ + "CurrentState", + "SimulatedObservationAtCurrentState", + ]. + + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}`` + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo04.rst + +.. include:: snippets/NoUnconditionalOutput.rst + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo05.rst + +.. include:: snippets/CurrentState.rst + +.. include:: snippets/SimulatedObservationAtCurrentState.rst + +.. ------------------------------------ .. +.. _section_ref_algorithm_ControledFunctionTest_examples: + +.. include:: snippets/Header2Algo09.rst + +.. --------- .. +.. include:: scripts/simple_ControledFunctionTest1.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest1.py + +.. include:: snippets/Header2Algo10.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest1.res + :language: none + +.. --------- .. +.. include:: scripts/simple_ControledFunctionTest2.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest2.py + +.. include:: snippets/Header2Algo10.rst + +.. literalinclude:: scripts/simple_ControledFunctionTest2.res + :language: none + +.. ------------------------------------ .. +.. include:: snippets/Header2Algo06.rst + +- :ref:`section_ref_algorithm_InputValuesTest` +- :ref:`section_ref_algorithm_LinearityTest` +- :ref:`section_ref_algorithm_FunctionTest` +- :ref:`section_ref_algorithm_ParallelFunctionTest` diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index c1c8fc7..1f9e429 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -124,5 +124,6 @@ StoreSupplementaryCalculations - :ref:`section_ref_algorithm_InputValuesTest` - :ref:`section_ref_algorithm_LinearityTest` +- :ref:`section_ref_algorithm_ControledFunctionTest` - :ref:`section_ref_algorithm_ParallelFunctionTest` - :ref:`section_ref_algorithm_EnsembleOfSimulationGenerationTask` diff --git a/doc/fr/ref_algorithm_ParallelFunctionTest.rst b/doc/fr/ref_algorithm_ParallelFunctionTest.rst index c0d56a9..89af1e6 100644 --- a/doc/fr/ref_algorithm_ParallelFunctionTest.rst +++ b/doc/fr/ref_algorithm_ParallelFunctionTest.rst @@ -111,7 +111,8 @@ StoreSupplementaryCalculations .. ------------------------------------ .. .. include:: snippets/Header2Algo06.rst -- :ref:`section_ref_algorithm_FunctionTest` - :ref:`section_ref_algorithm_InputValuesTest` - :ref:`section_ref_algorithm_LinearityTest` +- :ref:`section_ref_algorithm_FunctionTest` +- :ref:`section_ref_algorithm_ControledFunctionTest` - :ref:`section_ref_algorithm_EnsembleOfSimulationGenerationTask` diff --git a/doc/fr/reference.rst b/doc/fr/reference.rst index bad2e78..9dfa1b9 100644 --- a/doc/fr/reference.rst +++ b/doc/fr/reference.rst @@ -137,6 +137,7 @@ dans la section :ref:`section_theory`. :maxdepth: 1 ref_algorithm_AdjointTest + ref_algorithm_ControledFunctionTest ref_algorithm_FunctionTest ref_algorithm_GradientTest ref_algorithm_InputValuesTest diff --git a/doc/fr/scripts/simple_ControledFunctionTest1.py b/doc/fr/scripts/simple_ControledFunctionTest1.py new file mode 100644 index 0000000..58d4645 --- /dev/null +++ b/doc/fr/scripts/simple_ControledFunctionTest1.py @@ -0,0 +1,17 @@ +# -*- coding: utf-8 -*- +# +from numpy import array, eye +from adao import adaoBuilder +case = adaoBuilder.New() +case.setCheckingPoint( Vector = array([0., 1., 2.]), Stored=True ) +case.setObservationOperator( Matrix = eye(3) ) +case.setAlgorithmParameters( + Algorithm='ControledFunctionTest', + Parameters={ + 'NumberOfRepetition' : 5, + 'NumberOfPrintedDigits' : 2, + 'ShowElementarySummary':False, + }, + ) +case.setControlInput( Vector = 1. ) +case.execute() diff --git a/doc/fr/scripts/simple_ControledFunctionTest1.res b/doc/fr/scripts/simple_ControledFunctionTest1.res new file mode 100644 index 0000000..a5c93df --- /dev/null +++ b/doc/fr/scripts/simple_ControledFunctionTest1.res @@ -0,0 +1,74 @@ + + CONTROLEDFUNCTIONTEST + ===================== + + This test allows to analyze the (repetition of the) launch of some + given simulation operator F, applied to one single vector x and to + one control vector u as arguments, in a sequential way. + The output shows simple statistics related to its successful execution, + or related to the similarities of repetition of its execution. + +===> Information before launching: + ----------------------------- + + Characteristics of input vector X, internally converted: + Type...............: + Length of vector...: 3 + Minimum value......: 0.00e+00 + Maximum value......: 2.00e+00 + Mean of vector.....: 1.00e+00 + Standard error.....: 8.16e-01 + L2 norm of vector..: 2.24e+00 + + Characteristics of control parameter U, internally converted: + Type...............: + Length of vector...: 1 + Minimum value......: 1.00e+00 + Maximum value......: 1.00e+00 + Mean of vector.....: 1.00e+00 + Standard error.....: 0.00e+00 + L2 norm of vector..: 1.00e+00 + + --------------------------------------------------------------------------- + +===> Beginning of repeated evaluation, without activating debug + + --------------------------------------------------------------------------- + +===> End of repeated evaluation, without deactivating debug + + --------------------------------------------------------------------------- + +===> Launching statistical summary calculation for 5 states + + --------------------------------------------------------------------------- + +===> Statistical analysis of the outputs obtained through sequential repeated evaluations + + (Remark: numbers that are (about) under 2e-16 represent 0 to machine precision) + + Number of evaluations...........................: 5 + + Characteristics of the whole set of outputs Y: + Size of each of the outputs...................: 3 + Minimum value of the whole set of outputs.....: 0.00e+00 + Maximum value of the whole set of outputs.....: 2.00e+00 + Mean of vector of the whole set of outputs....: 1.00e+00 + Standard error of the whole set of outputs....: 8.16e-01 + + Characteristics of the vector Ym, mean of the outputs Y: + Size of the mean of the outputs...............: 3 + Minimum value of the mean of the outputs......: 0.00e+00 + Maximum value of the mean of the outputs......: 2.00e+00 + Mean of the mean of the outputs...............: 1.00e+00 + Standard error of the mean of the outputs.....: 8.16e-01 + + Characteristics of the mean of the differences between the outputs Y and their mean Ym: + Size of the mean of the differences...........: 3 + Minimum value of the mean of the differences..: 0.00e+00 + Maximum value of the mean of the differences..: 0.00e+00 + Mean of the mean of the differences...........: 0.00e+00 + Standard error of the mean of the differences.: 0.00e+00 + + --------------------------------------------------------------------------- + diff --git a/doc/fr/scripts/simple_ControledFunctionTest1.rst b/doc/fr/scripts/simple_ControledFunctionTest1.rst new file mode 100644 index 0000000..823c2fc --- /dev/null +++ b/doc/fr/scripts/simple_ControledFunctionTest1.rst @@ -0,0 +1,22 @@ +.. index:: single: ControledFunctionTest (exemple) + +Premier exemple +............... + +Cet exemple décrit le test du bon fonctionnement d'un opérateur quelconque, et +que son appel se déroule de manière compatible avec son usage courant dans les +algorithmes d'ADAO. Les informations nécessaires sont minimales, à savoir ici +un opérateur (décrit pour le test par la commande d'observation +"*ObservationOperator*"), un état particulier :math:`\mathbf{x}` sur lequel le +tester (décrit pour le test par la commande "*CheckingPoint*") et un contrôle +:math:`\mathbf{u}` (décrit pour le test par la commande "*ControlInput*"), les +deux n'étant pas nécessairement de la même taille. + +Le test est répété un nombre paramétrable de fois, et une statistique finale +permet de vérifier rapidement le bon comportement de l'opérateur. Le diagnostic +le plus simple consiste à vérifier, à la toute fin de l'affichage, l'ordre de +grandeur des variations des valeurs indiquées comme la moyenne des différences +entre les sorties répétées et leur moyenne, sous la partie titrée +"*Characteristics of the mean of the differences between the outputs Y and +their mean Ym*". Pour un opérateur satisfaisant, ces valeurs doivent être +proches du zéro numérique. diff --git a/doc/fr/scripts/simple_ControledFunctionTest2.py b/doc/fr/scripts/simple_ControledFunctionTest2.py new file mode 100644 index 0000000..aee0075 --- /dev/null +++ b/doc/fr/scripts/simple_ControledFunctionTest2.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# +from numpy import array, ravel +def ControledQuadFunction( paire ): + """ + Simulation quadratique contrôlée + """ + coefficients, controle = paire + # + u, v = list(ravel(controle)) + a, b, c = list(ravel(coefficients)) + x_points = (-5, 0, 1, 3, 10) + y_points = [] + for x in x_points: + y_points.append( (a*x*x + b*x + c + v) * u ) + return array(y_points) +# +from adao import adaoBuilder +case = adaoBuilder.New() +case.set( 'CheckingPoint', Vector = array([1., 1., 1.]), Stored=True ) +case.set( 'ObservationOperator', ThreeFunctions = { + "Direct" :ControledQuadFunction, + "Tangent":0, # Opérateur vide (et pas None) car non utilisé + "Adjoint":0, # Opérateur vide (et pas None) car non utilisé + } ) +case.set( "ControlInput", Vector = (1, 0) ) +case.setAlgorithmParameters( + Algorithm='ControledFunctionTest', + Parameters={ + 'NumberOfRepetition' : 15, + 'NumberOfPrintedDigits' : 3, + 'ShowElementarySummary':False, + }, + ) +case.execute() diff --git a/doc/fr/scripts/simple_ControledFunctionTest2.res b/doc/fr/scripts/simple_ControledFunctionTest2.res new file mode 100644 index 0000000..46e700b --- /dev/null +++ b/doc/fr/scripts/simple_ControledFunctionTest2.res @@ -0,0 +1,74 @@ + + CONTROLEDFUNCTIONTEST + ===================== + + This test allows to analyze the (repetition of the) launch of some + given simulation operator F, applied to one single vector x and to + one control vector u as arguments, in a sequential way. + The output shows simple statistics related to its successful execution, + or related to the similarities of repetition of its execution. + +===> Information before launching: + ----------------------------- + + Characteristics of input vector X, internally converted: + Type...............: + Length of vector...: 3 + Minimum value......: 1.000e+00 + Maximum value......: 1.000e+00 + Mean of vector.....: 1.000e+00 + Standard error.....: 0.000e+00 + L2 norm of vector..: 1.732e+00 + + Characteristics of control parameter U, internally converted: + Type...............: + Length of vector...: 2 + Minimum value......: 0.000e+00 + Maximum value......: 1.000e+00 + Mean of vector.....: 5.000e-01 + Standard error.....: 5.000e-01 + L2 norm of vector..: 1.000e+00 + + --------------------------------------------------------------------------- + +===> Beginning of repeated evaluation, without activating debug + + --------------------------------------------------------------------------- + +===> End of repeated evaluation, without deactivating debug + + --------------------------------------------------------------------------- + +===> Launching statistical summary calculation for 15 states + + --------------------------------------------------------------------------- + +===> Statistical analysis of the outputs obtained through sequential repeated evaluations + + (Remark: numbers that are (about) under 2e-16 represent 0 to machine precision) + + Number of evaluations...........................: 15 + + Characteristics of the whole set of outputs Y: + Size of each of the outputs...................: 5 + Minimum value of the whole set of outputs.....: 1.000e+00 + Maximum value of the whole set of outputs.....: 1.110e+02 + Mean of vector of the whole set of outputs....: 2.980e+01 + Standard error of the whole set of outputs....: 4.123e+01 + + Characteristics of the vector Ym, mean of the outputs Y: + Size of the mean of the outputs...............: 5 + Minimum value of the mean of the outputs......: 1.000e+00 + Maximum value of the mean of the outputs......: 1.110e+02 + Mean of the mean of the outputs...............: 2.980e+01 + Standard error of the mean of the outputs.....: 4.123e+01 + + Characteristics of the mean of the differences between the outputs Y and their mean Ym: + Size of the mean of the differences...........: 5 + Minimum value of the mean of the differences..: 0.000e+00 + Maximum value of the mean of the differences..: 0.000e+00 + Mean of the mean of the differences...........: 0.000e+00 + Standard error of the mean of the differences.: 0.000e+00 + + --------------------------------------------------------------------------- + diff --git a/doc/fr/scripts/simple_ControledFunctionTest2.rst b/doc/fr/scripts/simple_ControledFunctionTest2.rst new file mode 100644 index 0000000..6c05fa8 --- /dev/null +++ b/doc/fr/scripts/simple_ControledFunctionTest2.rst @@ -0,0 +1,21 @@ +Deuxième exemple +................ + +Ce nouvel exemple décrit le test du bon fonctionnement d'un opérateur +quelconque nommé ``ControledQuadFunction``, disponible sous forme +fonctionnelle. Il est définit par la commande "*ObservationOperator*" selon la +:ref:`section_ref_operator_funcs` (ici, même avec cette forme fonctionnelle, on +peut exceptionnellement ne pas définir les formes tangente et adjointe de +l'opérateur car elles ne sont pas utiles dans ce test). Par la commande +"*CheckingPoint*", on ajoute aussi un état particulier :math:`\mathbf{x}` sur +lequel tester l'opérateur, et par la commande "*ControlInput*" on ajoute un +contrôle fixe :math:`\mathbf{u}`. + +Ce test est répété ici 15 fois, et une statistique finale permet de vérifier +rapidement le bon comportement de l'opérateur. Le diagnostic le plus simple +consiste à vérifier, à la toute fin de l'affichage, l'ordre de grandeur des +variations des valeurs indiquées comme la moyenne des différences entre les +sorties répétées et leur moyenne, sous la partie titrée "*Characteristics of +the mean of the differences between the outputs Y and their mean Ym*". Pour +qu'un opérateur soit satisfaisant, ces valeurs doivent être proches du zéro +numérique. diff --git a/src/daComposant/daAlgorithms/ControledFunctionTest.py b/src/daComposant/daAlgorithms/ControledFunctionTest.py new file mode 100644 index 0000000..d6597c1 --- /dev/null +++ b/src/daComposant/daAlgorithms/ControledFunctionTest.py @@ -0,0 +1,268 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2008-2023 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D + +import numpy, copy, logging +from daCore import BasicObjects, PlatformInfo +mpr = PlatformInfo.PlatformInfo().MachinePrecision() +mfp = PlatformInfo.PlatformInfo().MaximumPrecision() + +# ============================================================================== +class ElementaryAlgorithm(BasicObjects.Algorithm): + def __init__(self): + BasicObjects.Algorithm.__init__(self, "CONTROLEDFUNCTIONTEST") + self.defineRequiredParameter( + name = "ShowElementarySummary", + default = True, + typecast = bool, + message = "Calcule et affiche un résumé à chaque évaluation élémentaire", + ) + self.defineRequiredParameter( + name = "NumberOfPrintedDigits", + default = 5, + typecast = int, + message = "Nombre de chiffres affichés pour les impressions de réels", + minval = 0, + ) + self.defineRequiredParameter( + name = "NumberOfRepetition", + default = 1, + typecast = int, + message = "Nombre de fois où l'exécution de la fonction est répétée", + minval = 1, + ) + self.defineRequiredParameter( + name = "ResultTitle", + default = "", + typecast = str, + message = "Titre du tableau et de la figure", + ) + self.defineRequiredParameter( + name = "SetDebug", + default = False, + typecast = bool, + message = "Activation du mode debug lors de l'exécution", + ) + self.defineRequiredParameter( + name = "StoreSupplementaryCalculations", + default = [], + typecast = tuple, + message = "Liste de calculs supplémentaires à stocker et/ou effectuer", + listval = [ + "CurrentState", + "SimulatedObservationAtCurrentState", + ] + ) + self.requireInputArguments( + mandatory= ("Xb", "HO"), + optional = ("U"), + ) + self.setAttributes(tags=( + "Checking", + )) + + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): + self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q) + # + Hm = HO["Direct"].appliedControledFormTo + # + X0 = copy.copy( Xb ) + if U is not None: + if hasattr(U,"store") and len(U)>1: + Un = numpy.ravel( U[step] ).reshape((-1,1)) + elif hasattr(U,"store") and len(U)==1: + Un = numpy.ravel( U[0] ).reshape((-1,1)) + else: + Un = numpy.ravel( U ).reshape((-1,1)) + else: + Un = None + # + # ---------- + __s = self._parameters["ShowElementarySummary"] + __p = self._parameters["NumberOfPrintedDigits"] + __r = self._parameters["NumberOfRepetition"] + # + __marge = 5*u" " + __flech = 3*"="+"> " + msgs = ("\n") # 1 + if len(self._parameters["ResultTitle"]) > 0: + __rt = str(self._parameters["ResultTitle"]) + msgs += (__marge + "====" + "="*len(__rt) + "====\n") + msgs += (__marge + " " + __rt + "\n") + msgs += (__marge + "====" + "="*len(__rt) + "====\n") + else: + msgs += (__marge + "%s\n"%self._name) + msgs += (__marge + "%s\n"%("="*len(self._name),)) + # + msgs += ("\n") + msgs += (__marge + "This test allows to analyze the (repetition of the) launch of some\n") + msgs += (__marge + "given simulation operator F, applied to one single vector x and to\n") + msgs += (__marge + "one control vector u as arguments, in a sequential way.\n") + msgs += (__marge + "The output shows simple statistics related to its successful execution,\n") + msgs += (__marge + "or related to the similarities of repetition of its execution.\n") + msgs += ("\n") + msgs += (__flech + "Information before launching:\n") + msgs += (__marge + "-----------------------------\n") + msgs += ("\n") + msgs += (__marge + "Characteristics of input vector X, internally converted:\n") + msgs += (__marge + " Type...............: %s\n")%type( X0 ) + msgs += (__marge + " Length of vector...: %i\n")%max(numpy.ravel( X0 ).shape) + msgs += (__marge + " Minimum value......: %."+str(__p)+"e\n")%numpy.min( X0 ) + msgs += (__marge + " Maximum value......: %."+str(__p)+"e\n")%numpy.max( X0 ) + msgs += (__marge + " Mean of vector.....: %."+str(__p)+"e\n")%numpy.mean( X0, dtype=mfp ) + msgs += (__marge + " Standard error.....: %."+str(__p)+"e\n")%numpy.std( X0, dtype=mfp ) + msgs += (__marge + " L2 norm of vector..: %."+str(__p)+"e\n")%numpy.linalg.norm( X0 ) + msgs += ("\n") + if Un is None: + msgs += (__marge + "Characteristics of control parameter U, internally converted: None\n") + else: + msgs += (__marge + "Characteristics of control parameter U, internally converted:\n") + msgs += (__marge + " Type...............: %s\n")%type( Un ) + msgs += (__marge + " Length of vector...: %i\n")%max(numpy.ravel( Un ).shape) + msgs += (__marge + " Minimum value......: %."+str(__p)+"e\n")%numpy.min( Un ) + msgs += (__marge + " Maximum value......: %."+str(__p)+"e\n")%numpy.max( Un ) + msgs += (__marge + " Mean of vector.....: %."+str(__p)+"e\n")%numpy.mean( Un, dtype=mfp ) + msgs += (__marge + " Standard error.....: %."+str(__p)+"e\n")%numpy.std( Un, dtype=mfp ) + msgs += (__marge + " L2 norm of vector..: %."+str(__p)+"e\n")%numpy.linalg.norm( Un ) + msgs += ("\n") + msgs += (__marge + "%s\n\n"%("-"*75,)) + # + if self._parameters["SetDebug"]: + CUR_LEVEL = logging.getLogger().getEffectiveLevel() + logging.getLogger().setLevel(logging.DEBUG) + if __r > 1: + msgs += (__flech + "Beginning of repeated evaluation, activating debug\n") + else: + msgs += (__flech + "Beginning of evaluation, activating debug\n") + else: + if __r > 1: + msgs += (__flech + "Beginning of repeated evaluation, without activating debug\n") + else: + msgs += (__flech + "Beginning of evaluation, without activating debug\n") + print(msgs) # 1 + # + # ---------- + HO["Direct"].disableAvoidingRedundancy() + # ---------- + Ys = [] + for i in range(__r): + if self._toStore("CurrentState"): + self.StoredVariables["CurrentState"].store( X0 ) + if __s: + msgs = (__marge + "%s\n"%("-"*75,)) # 2-1 + if __r > 1: + msgs += ("\n") + msgs += (__flech + "Repetition step number %i on a total of %i\n"%(i+1,__r)) + msgs += ("\n") + msgs += (__flech + "Launching operator sequential evaluation\n") + print(msgs) # 2-1 + # + Yn = Hm( (X0, Un) ) + # + if __s: + msgs = ("\n") # 2-2 + msgs += (__flech + "End of operator sequential evaluation\n") + msgs += ("\n") + msgs += (__flech + "Information after evaluation:\n") + msgs += ("\n") + msgs += (__marge + "Characteristics of simulated output vector Y=F((X,U)), to compare to others:\n") + msgs += (__marge + " Type...............: %s\n")%type( Yn ) + msgs += (__marge + " Length of vector...: %i\n")%max(numpy.ravel( Yn ).shape) + msgs += (__marge + " Minimum value......: %."+str(__p)+"e\n")%numpy.min( Yn ) + msgs += (__marge + " Maximum value......: %."+str(__p)+"e\n")%numpy.max( Yn ) + msgs += (__marge + " Mean of vector.....: %."+str(__p)+"e\n")%numpy.mean( Yn, dtype=mfp ) + msgs += (__marge + " Standard error.....: %."+str(__p)+"e\n")%numpy.std( Yn, dtype=mfp ) + msgs += (__marge + " L2 norm of vector..: %."+str(__p)+"e\n")%numpy.linalg.norm( Yn ) + print(msgs) # 2-2 + if self._toStore("SimulatedObservationAtCurrentState"): + self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(Yn) ) + # + Ys.append( copy.copy( numpy.ravel( + Yn + ) ) ) + # ---------- + HO["Direct"].enableAvoidingRedundancy() + # ---------- + # + msgs = (__marge + "%s\n\n"%("-"*75,)) # 3 + if self._parameters["SetDebug"]: + if __r > 1: + msgs += (__flech + "End of repeated evaluation, deactivating debug if necessary\n") + else: + msgs += (__flech + "End of evaluation, deactivating debug if necessary\n") + logging.getLogger().setLevel(CUR_LEVEL) + else: + if __r > 1: + msgs += (__flech + "End of repeated evaluation, without deactivating debug\n") + else: + msgs += (__flech + "End of evaluation, without deactivating debug\n") + msgs += ("\n") + msgs += (__marge + "%s\n"%("-"*75,)) + # + if __r > 1: + msgs += ("\n") + msgs += (__flech + "Launching statistical summary calculation for %i states\n"%__r) + msgs += ("\n") + msgs += (__marge + "%s\n"%("-"*75,)) + msgs += ("\n") + msgs += (__flech + "Statistical analysis of the outputs obtained through sequential repeated evaluations\n") + msgs += ("\n") + msgs += (__marge + "(Remark: numbers that are (about) under %.0e represent 0 to machine precision)\n"%mpr) + msgs += ("\n") + Yy = numpy.array( Ys ) + msgs += (__marge + "Number of evaluations...........................: %i\n")%len( Ys ) + msgs += ("\n") + msgs += (__marge + "Characteristics of the whole set of outputs Y:\n") + msgs += (__marge + " Size of each of the outputs...................: %i\n")%Ys[0].size + msgs += (__marge + " Minimum value of the whole set of outputs.....: %."+str(__p)+"e\n")%numpy.min( Yy ) + msgs += (__marge + " Maximum value of the whole set of outputs.....: %."+str(__p)+"e\n")%numpy.max( Yy ) + msgs += (__marge + " Mean of vector of the whole set of outputs....: %."+str(__p)+"e\n")%numpy.mean( Yy, dtype=mfp ) + msgs += (__marge + " Standard error of the whole set of outputs....: %."+str(__p)+"e\n")%numpy.std( Yy, dtype=mfp ) + msgs += ("\n") + Ym = numpy.mean( numpy.array( Ys ), axis=0, dtype=mfp ) + msgs += (__marge + "Characteristics of the vector Ym, mean of the outputs Y:\n") + msgs += (__marge + " Size of the mean of the outputs...............: %i\n")%Ym.size + msgs += (__marge + " Minimum value of the mean of the outputs......: %."+str(__p)+"e\n")%numpy.min( Ym ) + msgs += (__marge + " Maximum value of the mean of the outputs......: %."+str(__p)+"e\n")%numpy.max( Ym ) + msgs += (__marge + " Mean of the mean of the outputs...............: %."+str(__p)+"e\n")%numpy.mean( Ym, dtype=mfp ) + msgs += (__marge + " Standard error of the mean of the outputs.....: %."+str(__p)+"e\n")%numpy.std( Ym, dtype=mfp ) + msgs += ("\n") + Ye = numpy.mean( numpy.array( Ys ) - Ym, axis=0, dtype=mfp ) + msgs += (__marge + "Characteristics of the mean of the differences between the outputs Y and their mean Ym:\n") + msgs += (__marge + " Size of the mean of the differences...........: %i\n")%Ye.size + msgs += (__marge + " Minimum value of the mean of the differences..: %."+str(__p)+"e\n")%numpy.min( Ye ) + msgs += (__marge + " Maximum value of the mean of the differences..: %."+str(__p)+"e\n")%numpy.max( Ye ) + msgs += (__marge + " Mean of the mean of the differences...........: %."+str(__p)+"e\n")%numpy.mean( Ye, dtype=mfp ) + msgs += (__marge + " Standard error of the mean of the differences.: %."+str(__p)+"e\n")%numpy.std( Ye, dtype=mfp ) + msgs += ("\n") + msgs += (__marge + "%s\n"%("-"*75,)) + # + msgs += ("\n") + msgs += (__marge + "End of the \"%s\" verification\n\n"%self._name) + msgs += (__marge + "%s\n"%("-"*75,)) + print(msgs) # 3 + # + self._post_run(HO) + return 0 + +# ============================================================================== +if __name__ == "__main__": + print('\n AUTODIAGNOSTIC\n') -- 2.39.2