Adao/ADAO_Cata_V0.py

   1 # -*- coding: utf-8 -*-
   2
   3 # --------------------------------------------------------
   4 # generated by AdaoCatalogGenerator at 2012-12-13 18:42:40
   5 # --------------------------------------------------------
   6
   7 import Accas
   8 from Accas import *
   9
  10 VERSION_CATALOGUE='agathe'
  11
  12 JdC = JDC_CATA (code = 'ADAO',
  13                 execmodul = None,
  14                 regles = ( AU_MOINS_UN ('ASSIMILATION_STUDY','CHECKING_STUDY'), AU_PLUS_UN ('ASSIMILATION_STUDY','CHECKING_STUDY')),
  15                )
  16
  17 def F_VectorSerie(statut) : return FACT(statut = statut,
  18                                          FROM = SIMP(statut = "o", typ = "TXM", into=("String", "Script", ), defaut="Script"),
  19                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
  20
  21                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant la définition d'une variable interne de même nom que le concept parent", ang="Waiting for a script file name, with or without the full path to find it, containing the definition of an internal variable of the same name as the parent concept"),
  22                                                      ),
  23                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
  24
  25                                                       STRING = SIMP(statut = "o", typ = "TXM", fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"),
  26                                                      ),
  27                                          SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
  28
  29                                                       SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"),
  30                                                      ),
  31                                          SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
  32
  33                                                       SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
  34                                                       DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
  35                                                      ),
  36                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
  37
  38                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
  39                                                      ),
  40                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
  41
  42                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
  43                                                      ),
  44                                     )
  45
  46 def F_Function(statut) : return FACT(statut = statut,
  47                                          FROM = SIMP(statut = "o", typ = "TXM", into=("ScriptWithOneFunction", "ScriptWithFunctions", "ScriptWithSwitch", "FunctionDict", ), defaut="ScriptWithOneFunction"),
  48                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
  49
  50                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant la définition d'une variable interne de même nom que le concept parent", ang="Waiting for a script file name, with or without the full path to find it, containing the definition of an internal variable of the same name as the parent concept"),
  51                                                      ),
  52                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
  53
  54                                                       STRING = SIMP(statut = "o", typ = "TXM", fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"),
  55                                                      ),
  56                                          SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
  57
  58                                                       SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"),
  59                                                      ),
  60                                          SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
  61
  62                                                       SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
  63                                                       DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
  64                                                      ),
  65                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
  66
  67                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
  68                                                      ),
  69                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
  70
  71                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
  72                                                      ),
  73                                     )
  74
  75 def F_Vector(statut) : return FACT(statut = statut,
  76                                          FROM = SIMP(statut = "o", typ = "TXM", into=("String", "Script", ), defaut="Script"),
  77                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
  78
  79                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant la définition d'une variable interne de même nom que le concept parent", ang="Waiting for a script file name, with or without the full path to find it, containing the definition of an internal variable of the same name as the parent concept"),
  80                                                      ),
  81                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
  82
  83                                                       STRING = SIMP(statut = "o", typ = "TXM", fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"),
  84                                                      ),
  85                                          SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
  86
  87                                                       SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"),
  88                                                      ),
  89                                          SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
  90
  91                                                       SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
  92                                                       DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
  93                                                      ),
  94                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
  95
  96                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
  97                                                      ),
  98                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
  99
 100                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
 101                                                      ),
 102                                     )
 103
 104 def F_Dict(statut) : return FACT(statut = statut,
 105                                          FROM = SIMP(statut = "o", typ = "TXM", into=("Script", ), defaut="Script"),
 106                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 107
 108                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant la définition d'une variable interne de même nom que le concept parent", ang="Waiting for a script file name, with or without the full path to find it, containing the definition of an internal variable of the same name as the parent concept"),
 109                                                      ),
 110                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 111
 112                                                       STRING = SIMP(statut = "o", typ = "TXM", fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"),
 113                                                      ),
 114                                          SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 115
 116                                                       SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"),
 117                                                      ),
 118                                          SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 119
 120                                                       SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
 121                                                       DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
 122                                                      ),
 123                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 124
 125                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
 126                                                      ),
 127                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
 128
 129                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
 130                                                      ),
 131                                     )
 132
 133 def F_Matrix(statut) : return FACT(statut = statut,
 134                                          FROM = SIMP(statut = "o", typ = "TXM", into=("String", "Script", ), defaut="Script"),
 135                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 136
 137                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant la définition d'une variable interne de même nom que le concept parent", ang="Waiting for a script file name, with or without the full path to find it, containing the definition of an internal variable of the same name as the parent concept"),
 138                                                      ),
 139                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 140
 141                                                       STRING = SIMP(statut = "o", typ = "TXM", fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"),
 142                                                      ),
 143                                          SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 144
 145                                                       SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"),
 146                                                      ),
 147                                          SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 148
 149                                                       SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
 150                                                       DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
 151                                                      ),
 152                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 153
 154                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
 155                                                      ),
 156                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
 157
 158                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
 159                                                      ),
 160                                     )
 161
 162 def F_ObservationError(statut) : return FACT(statut=statut,
 163                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 164                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Matrix", ), defaut="Matrix"),
 165
 166                                                  Matrix = BLOC ( condition = " INPUT_TYPE in ( 'Matrix', ) ",
 167                                                  data = F_Matrix("o"),
 168                                                  ),
 169
 170                                                 )
 171
 172 def F_Observation(statut) : return FACT(statut=statut,
 173                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 174                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Vector", "VectorSerie", ), defaut="Vector"),
 175
 176                                                  Vector = BLOC ( condition = " INPUT_TYPE in ( 'Vector', ) ",
 177                                                  data = F_Vector("o"),
 178                                                  ),
 179
 180                                                  VectorSerie = BLOC ( condition = " INPUT_TYPE in ( 'VectorSerie', ) ",
 181                                                  data = F_VectorSerie("o"),
 182                                                  ),
 183
 184                                                 )
 185
 186 def F_BackgroundError(statut) : return FACT(statut=statut,
 187                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 188                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Matrix", ), defaut="Matrix"),
 189
 190                                                  Matrix = BLOC ( condition = " INPUT_TYPE in ( 'Matrix', ) ",
 191                                                  data = F_Matrix("o"),
 192                                                  ),
 193
 194                                                 )
 195
 196 def F_ObservationOperator(statut) : return FACT(statut=statut,
 197                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 198                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Matrix", "Function", ), defaut="Function"),
 199
 200                                                  Matrix = BLOC ( condition = " INPUT_TYPE in ( 'Matrix', ) ",
 201                                                  data = F_Matrix("o"),
 202                                                  ),
 203
 204                                                  Function = BLOC ( condition = " INPUT_TYPE in ( 'Function', ) ",
 205                                                  data = F_Function("o"),
 206                                                  ),
 207
 208                                                 )
 209
 210 def F_CheckingPoint(statut) : return FACT(statut=statut,
 211                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 212                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Vector", ), defaut="Vector"),
 213
 214                                                  Vector = BLOC ( condition = " INPUT_TYPE in ( 'Vector', ) ",
 215                                                  data = F_Vector("o"),
 216                                                  ),
 217
 218                                                 )
 219
 220 def F_Background(statut) : return FACT(statut=statut,
 221                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 222                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Vector", ), defaut="Vector"),
 223
 224                                                  Vector = BLOC ( condition = " INPUT_TYPE in ( 'Vector', ) ",
 225                                                  data = F_Vector("o"),
 226                                                  ),
 227
 228                                                 )
 229
 230 def F_AlgorithmParameters(statut) : return FACT(statut=statut,
 231
 232                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Dict", ), defaut="Dict"),
 233
 234                                                  Dict = BLOC ( condition = " INPUT_TYPE in ( 'Dict', ) ",
 235                                                  data = F_Dict("o"),
 236                                                  ),
 237
 238                                                 )
 239
 240 def F_EvolutionError(statut) : return FACT(statut=statut,
 241                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 242                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Matrix", ), defaut="Matrix"),
 243
 244                                                  Matrix = BLOC ( condition = " INPUT_TYPE in ( 'Matrix', ) ",
 245                                                  data = F_Matrix("o"),
 246                                                  ),
 247
 248                                                 )
 249
 250 def F_UserDataInit(statut) : return FACT(statut=statut,
 251
 252                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Dict", ), defaut="Dict"),
 253
 254                                                  Dict = BLOC ( condition = " INPUT_TYPE in ( 'Dict', ) ",
 255                                                  data = F_Dict("o"),
 256                                                  ),
 257
 258                                                 )
 259
 260 def F_EvolutionModel(statut) : return FACT(statut=statut,
 261                                           Stored = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Choix de stockage interne ou non du concept parent", ang="Choice of the storage or not of the parent concept"),
 262                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=("Matrix", "Function", ), defaut="Function"),
 263
 264                                                  Matrix = BLOC ( condition = " INPUT_TYPE in ( 'Matrix', ) ",
 265                                                  data = F_Matrix("o"),
 266                                                  ),
 267
 268                                                  Function = BLOC ( condition = " INPUT_TYPE in ( 'Function', ) ",
 269                                                  data = F_Function("o"),
 270                                                  ),
 271
 272                                                 )
 273
 274 def F_UserPostAnalysis(statut) : return FACT(statut = statut,
 275                                          FROM = SIMP(statut = "o", typ = "TXM", into=("String", "Script", ), defaut="Script"),
 276                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 277
 278                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant la définition d'une variable interne de même nom que le concept parent", ang="Waiting for a script file name, with or without the full path to find it, containing the definition of an internal variable of the same name as the parent concept"),
 279                                                      ),
 280                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 281
 282                                                       STRING = SIMP(statut = "o", typ = "TXM", fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"),
 283                                                      ),
 284                                          SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 285
 286                                                       SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variables internes trois fonctions de calcul nommées DirectOperator, TangentOperator et AdjointOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variables three computation functions named DirectOperator, TangentOperator and AdjointOperator"),
 287                                                      ),
 288                                          SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 289
 290                                                       SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant en variable interne une seule fonction de calcul nommée DirectOperator", ang="Waiting for a script file name, with or without the full path to find it, containing as internal variable only one function named DirectOperator"),
 291                                                       DifferentialIncrement = SIMP(statut="o", typ = "R", val_min=0, val_max=1, defaut=0.01, fr="Incrément de la perturbation dX pour calculer la dérivée, construite en multipliant X par l'incrément en évitant les valeurs nulles", ang="Increment of dX perturbation to calculate the derivative, build multiplying X by the increment avoiding null values"),
 292                                                      ),
 293                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 294
 295                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
 296                                                      ),
 297                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
 298
 299                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
 300                                                      ),
 301                                     )
 302
 303 def F_InitChoice() : return  ("Background",
 304                               "BackgroundError",
 305                               "Observation",
 306                               "ObservationError",
 307                               "ObservationOperator",
 308                               "EvolutionModel",
 309                               "EvolutionError",
 310                               "AlgorithmParameters",
 311                               "UserPostAnalysis",
 312                              )
 313
 314 def F_Init(statut) : return FACT(statut = statut,
 315                                  INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr())),
 316                                  TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
 317                                 )
 318
 319 def F_Observers(statut) : return FACT(statut=statut,
 320                                       SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", validators=NoRepeat(), into=(['Analysis', 'CurrentState', 'Innovation', 'OMA', 'OMB', 'BMA', 'CostFunctionJ', 'CostFunctionJb', 'CostFunctionJo', 'GradientOfCostFunctionJ', 'GradientOfCostFunctionJb', 'GradientOfCostFunctionJo', 'SigmaObs2', 'SigmaBck2', 'APosterioriCovariance'])),
 321
 322                                        Analysis = BLOC (condition=" 'Analysis' in set(SELECTION) ",
 323                                                   Analysis_data = FACT(statut = "o",
 324                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 325                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 326                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 327                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 328                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 329                                                                                  ),
 330                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 331                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 332                                                                              )
 333                                                                       ),
 334                                                           ),
 335
 336                                        CurrentState = BLOC (condition=" 'CurrentState' in set(SELECTION) ",
 337                                                   CurrentState_data = FACT(statut = "o",
 338                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 339                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 340                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 341                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 342                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 343                                                                                  ),
 344                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 345                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 346                                                                              )
 347                                                                       ),
 348                                                           ),
 349
 350                                        Innovation = BLOC (condition=" 'Innovation' in set(SELECTION) ",
 351                                                   Innovation_data = FACT(statut = "o",
 352                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 353                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 354                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 355                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 356                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 357                                                                                  ),
 358                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 359                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 360                                                                              )
 361                                                                       ),
 362                                                           ),
 363
 364                                        OMA = BLOC (condition=" 'OMA' in set(SELECTION) ",
 365                                                   OMA_data = FACT(statut = "o",
 366                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 367                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 368                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 369                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 370                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 371                                                                                  ),
 372                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 373                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 374                                                                              )
 375                                                                       ),
 376                                                           ),
 377
 378                                        OMB = BLOC (condition=" 'OMB' in set(SELECTION) ",
 379                                                   OMB_data = FACT(statut = "o",
 380                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 381                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 382                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 383                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 384                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 385                                                                                  ),
 386                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 387                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 388                                                                              )
 389                                                                       ),
 390                                                           ),
 391
 392                                        BMA = BLOC (condition=" 'BMA' in set(SELECTION) ",
 393                                                   BMA_data = FACT(statut = "o",
 394                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 395                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 396                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 397                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 398                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 399                                                                                  ),
 400                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 401                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 402                                                                              )
 403                                                                       ),
 404                                                           ),
 405
 406                                        CostFunctionJ = BLOC (condition=" 'CostFunctionJ' in set(SELECTION) ",
 407                                                   CostFunctionJ_data = FACT(statut = "o",
 408                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 409                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 410                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 411                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 412                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 413                                                                                  ),
 414                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 415                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 416                                                                              )
 417                                                                       ),
 418                                                           ),
 419
 420                                        CostFunctionJb = BLOC (condition=" 'CostFunctionJb' in set(SELECTION) ",
 421                                                   CostFunctionJb_data = FACT(statut = "o",
 422                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 423                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 424                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 425                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 426                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 427                                                                                  ),
 428                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 429                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 430                                                                              )
 431                                                                       ),
 432                                                           ),
 433
 434                                        CostFunctionJo = BLOC (condition=" 'CostFunctionJo' in set(SELECTION) ",
 435                                                   CostFunctionJo_data = FACT(statut = "o",
 436                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 437                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 438                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 439                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 440                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 441                                                                                  ),
 442                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 443                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 444                                                                              )
 445                                                                       ),
 446                                                           ),
 447
 448                                        GradientOfCostFunctionJ = BLOC (condition=" 'GradientOfCostFunctionJ' in set(SELECTION) ",
 449                                                   GradientOfCostFunctionJ_data = FACT(statut = "o",
 450                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 451                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 452                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 453                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 454                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 455                                                                                  ),
 456                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 457                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 458                                                                              )
 459                                                                       ),
 460                                                           ),
 461
 462                                        GradientOfCostFunctionJb = BLOC (condition=" 'GradientOfCostFunctionJb' in set(SELECTION) ",
 463                                                   GradientOfCostFunctionJb_data = FACT(statut = "o",
 464                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 465                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 466                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 467                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 468                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 469                                                                                  ),
 470                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 471                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 472                                                                              )
 473                                                                       ),
 474                                                           ),
 475
 476                                        GradientOfCostFunctionJo = BLOC (condition=" 'GradientOfCostFunctionJo' in set(SELECTION) ",
 477                                                   GradientOfCostFunctionJo_data = FACT(statut = "o",
 478                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 479                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 480                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 481                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 482                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 483                                                                                  ),
 484                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 485                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 486                                                                              )
 487                                                                       ),
 488                                                           ),
 489
 490                                        SigmaObs2 = BLOC (condition=" 'SigmaObs2' in set(SELECTION) ",
 491                                                   SigmaObs2_data = FACT(statut = "o",
 492                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 493                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 494                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 495                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 496                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 497                                                                                  ),
 498                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 499                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 500                                                                              )
 501                                                                       ),
 502                                                           ),
 503
 504                                        SigmaBck2 = BLOC (condition=" 'SigmaBck2' in set(SELECTION) ",
 505                                                   SigmaBck2_data = FACT(statut = "o",
 506                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 507                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 508                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 509                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 510                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 511                                                                                  ),
 512                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 513                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 514                                                                              )
 515                                                                       ),
 516                                                           ),
 517
 518                                        APosterioriCovariance = BLOC (condition=" 'APosterioriCovariance' in set(SELECTION) ",
 519                                                   APosterioriCovariance_data = FACT(statut = "o",
 520                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 521                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 522                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 523                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 524                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 525                                                                                  ),
 526                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 527                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 528                                                                              )
 529                                                                       ),
 530                                                           ),
 531
 532                                      )
 533
 534
 535 def F_variables(statut) : return FACT(statut=statut,
 536                                       regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 537                                       NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 538                                       SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 539                                       )
 540
 541 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 542                           op=None,
 543                           repetable           = "n",
 544                           Study_name          = SIMP(statut="o", typ = "TXM"),
 545                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 546                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 547                           Algorithm           = SIMP(statut="o", typ = "TXM", into=("3DVAR", "Blue", "EnsembleBlue", "KalmanFilter", "LinearLeastSquares", "NonLinearLeastSquares", "ParticleSwarmOptimization", "QuantileRegression", )),
 548                           Background          = F_Background("o"),
 549                           BackgroundError     = F_BackgroundError("o"),
 550                           Observation         = F_Observation("o"),
 551                           ObservationError    = F_ObservationError("o"),
 552                           ObservationOperator = F_ObservationOperator("o"),
 553                           EvolutionModel      = F_EvolutionModel("f"),
 554                           EvolutionError      = F_EvolutionError("f"),
 555                           AlgorithmParameters = F_AlgorithmParameters("f"),
 556                           UserDataInit        = F_Init("f"),
 557                           UserPostAnalysis    = F_UserPostAnalysis("f"),
 558                           InputVariables      = F_variables("f"),
 559                           OutputVariables     = F_variables("f"),
 560                           Observers           = F_Observers("f")
 561                          )
 562
 563 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 564                           op=None,
 565                           repetable           = "n",
 566                           Study_name          = SIMP(statut="o", typ = "TXM"),
 567                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 568                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 569                           Algorithm           = SIMP(statut="o", typ = "TXM", into=("AdjointTest", "GradientTest", )),
 570                           CheckingPoint       = F_CheckingPoint("o"),
 571                           ObservationOperator = F_ObservationOperator("o"),
 572                           AlgorithmParameters = F_AlgorithmParameters("f"),
 573                           UserDataInit        = F_Init("f"),
 574                          )