bin/AdaoCatalogGenerator.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # Copyright (C) 2008-2022 EDF R&D
   4 #
   5 # This file is part of SALOME ADAO module
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License.
  11 #
  12 # This library is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  24
  25 import logging
  26 import traceback
  27 import sys
  28 import io
  29 import os
  30
  31 import module_version
  32
  33 logging.basicConfig(level=logging.WARNING)
  34
  35 if sys.version_info.major > 2:
  36     def unicode(text, encoding='utf-8'): return text
  37
  38 print("-- Starting AdaoCalatogGenerator.py --")
  39
  40 try:
  41   import adao
  42   import daEficas
  43   import daYacsSchemaCreator
  44   import daCore.Aidsm
  45   import daYacsSchemaCreator.infos_daComposant as infos
  46 except:
  47   logging.fatal("Import of ADAO python modules failed !" +
  48                 "\n add ADAO python installation directory in your PYTHONPATH")
  49   traceback.print_exc()
  50   sys.exit(1)
  51
  52 #===============================================================================
  53
  54 #----------- Templates Part ---------------#
  55
  56 begin_catalog_file = """# -*- coding: utf-8 -*-
  57 #
  58 # Copyright (C) 2008-2022 EDF R&D
  59 #
  60 # This file is part of SALOME ADAO module
  61 #
  62 # This library is free software; you can redistribute it and/or
  63 # modify it under the terms of the GNU Lesser General Public
  64 # License as published by the Free Software Foundation; either
  65 # version 2.1 of the License.
  66 #
  67 # This library is distributed in the hope that it will be useful,
  68 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  69 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  70 # Lesser General Public License for more details.
  71 #
  72 # You should have received a copy of the GNU Lesser General Public
  73 # License along with this library; if not, write to the Free Software
  74 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  75 #
  76 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  77 #
  78 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  79
  80 # --------------------------------------------------------
  81 # Generated by AdaoCatalogGenerator on {date}
  82 # --------------------------------------------------------
  83
  84 import os, re
  85 import Accas
  86 from Accas import *
  87
  88 JdC = JDC_CATA (
  89     code = '%s',
  90     execmodul = None,
  91     regles = ( AU_MOINS_UN ('ASSIMILATION_STUDY','OPTIMIZATION_STUDY','REDUCTION_STUDY','CHECKING_STUDY'), AU_PLUS_UN ('ASSIMILATION_STUDY','OPTIMIZATION_STUDY','REDUCTION_STUDY','CHECKING_STUDY')),
  92     )
  93 VERSION_CATALOGUE='%s'
  94
  95 def NoCheckInNS(filename):
  96     return 1
  97 NoCheckInNS.info = u""
  98 def DirectOperatorInNS(filename):
  99     if os.path.isfile(filename):
 100         fc = open(filename, 'r').readlines()
 101         cr = re.compile("^def[\s]*DirectOperator[\s]*\(")
 102         for ln in fc:
 103             if cr.match(ln): return 1
 104         cr = re.compile("^DirectOperator[\s]*=")
 105         for ln in fc:
 106             if cr.match(ln): return 1
 107     return 0
 108 DirectOperatorInNS.info = u"The Python file has to contain explicitly a \\"DirectOperator\\" function definition with only one vector as argument."
 109 def TangentOperatorInNS(filename):
 110     if os.path.isfile(filename):
 111         fc = open(filename, 'r').readlines()
 112         cr = re.compile("^def[\s]*TangentOperator[\s]*\(")
 113         for ln in fc:
 114             if cr.match(ln): return 1
 115         cr = re.compile("^TangentOperator[\s]*=")
 116         for ln in fc:
 117             if cr.match(ln): return 1
 118     return 0
 119 TangentOperatorInNS.info = u"The Python file has to contain explicitly a \\"TangentOperator\\" function definition with only one pair of vectors as argument."
 120 def AdjointOperatorInNS(filename):
 121     if os.path.isfile(filename):
 122         fc = open(filename, 'r').readlines()
 123         cr = re.compile("^def[\s]*AdjointOperator[\s]*\(")
 124         for ln in fc:
 125             if cr.match(ln): return 1
 126         cr = re.compile("^AdjointOperator[\s]*=")
 127         for ln in fc:
 128             if cr.match(ln): return 1
 129     return 0
 130 AdjointOperatorInNS.info = u"The Python file has to contain explicitly an \\"AdjointOperator\\" function definition with only one pair of vectors as argument."
 131 def ColDataFileExtVal(filename):
 132     __readable = (".csv", ".tsv", ".txt", ".npy", ".npz")
 133     if os.path.isfile(filename) and os.path.splitext(filename)[1] in __readable:
 134         return 1
 135     return 0
 136 ColDataFileExtVal.info = u"The data file has to contain explicitly one or more number columns with separator, or one variable, that can fit in a unique continuous vector."
 137 """%(module_version.name,module_version.cata)
 138
 139 # --------------------------------------
 140
 141 from daCore.Templates import UserPostAnalysisTemplates
 142 upa_list = UserPostAnalysisTemplates.keys_in_presentation_order()
 143 upa_list = '"%s"'%str('", "'.join(upa_list))
 144 upa_cont = ""
 145 for k in UserPostAnalysisTemplates.keys_in_presentation_order():
 146     upa_cont += """        %s = BLOC (condition = " Template == '%s' ",\n"""%(k,k)
 147     upa_cont += """            ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "%s", fr="%s", ang="%s" ),\n"""%(
 148         UserPostAnalysisTemplates[k].replace("\n","\\n").replace('"','\\"'),
 149         UserPostAnalysisTemplates.getdoc(k, "fr_FR"),
 150         UserPostAnalysisTemplates.getdoc(k, "en_EN"),
 151         )
 152     upa_cont += """            ),\n"""
 153
 154 # Important : validators=[...] pour que les conditions soient traitées simultanément, en "ET", et pas en "OU" (choisi dans le cas du tuple a la place de la liste)
 155 # validators=[OnlyStr(), FileExtVal('py'), FunctionVal(fv)]
 156 data_method = """
 157 def F_{data_name}(statut, fv=NoCheckInNS) : return FACT(
 158     statut = statut,
 159     FROM = SIMP(statut = "o", typ = "TXM", into=({data_into}), defaut={data_default}),
 160     SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 161         SCRIPT_FILE = SIMP(statut = "o", typ = ("FichierNoAbs",'Python Files (*.py)',), validators=[OnlyStr(), FileExtVal('py'), FunctionVal(fv)], fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant si nécessaire 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 if necessary the definition of an internal variable of the same name as the parent concept"),
 162         ),
 163     DATA_DATA = BLOC ( condition = " FROM in ( 'DataFile', ) ",
 164         DATA_FILE = SIMP(statut = "o", typ = ("FichierNoAbs",'CSV Text Files (*.csv);;TSV Text Files (*.tsv);;TXT Text Files (*.txt);;NPY Binary Numpy Files (*.npy);;NPZ Binary Numpy Files (*.npz);;All Files (*)", ',), validators=[OnlyStr(), FunctionVal(ColDataFileExtVal)], fr="En attente d'un nom de fichier de données, avec ou sans le chemin complet pour le trouver, contenant ou plusieurs colonnes pour définir un unique vecteur continu", ang="Waiting for a data file name, with or without the full path to find it, containing one or more columns to define a unique continuous vector"),
 165         ColMajor = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0, fr="Variables en colonnes acquises ligne par ligne (0) ou colonne par colonne (1)", ang="Variables in columns acquired line by line (0) or column by column (1)"),
 166         ),
 167     STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 168         STRING = SIMP(statut = "o", typ = "TXM",{ms_default} fr="En attente d'une chaîne de caractères entre guillemets. Pour construire un vecteur ou une matrice, 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 or a matrix, 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"),
 169         ),
 170     SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 171         SCRIPTWITHFUNCTIONS_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py'), FunctionVal(DirectOperatorInNS), FunctionVal(TangentOperatorInNS), FunctionVal(AdjointOperatorInNS)], 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"),
 172         ),
 173     SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 174         SCRIPTWITHONEFUNCTION_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py'), FunctionVal(DirectOperatorInNS)], 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"),
 175         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"),
 176         CenteredFiniteDifference = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0, fr="Formulation centrée (1) ou décentrée (0) pour la méthode des différences finies", ang="Centered (1) or uncentered (0) formulation for the finite differences method"),
 177         EnableMultiProcessing = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0, fr="Calculs élémentaires effectués en séquentiel (0) ou en parallèle (1) dans la méthode des différences finies", ang="Elementary calculations done sequentially (0) or in parallel (1) in the finite differences method"),
 178         NumberOfProcesses = SIMP(statut="f", typ = "I", val_min=0, defaut=0, fr="Nombre de processus parallèles, 0 pour un contrôle automatique", ang="Number of parallel processes, 0 for automatic control"),
 179         ),
 180     SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 181         SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')], 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"),
 182         ),
 183 """+\
 184 """    TEMPLATE_DATA =  BLOC (condition = " FROM in ( 'Template', ) ",
 185         Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "AnalysisPrinter", into=(%s)),
 186 """%(upa_list,)+\
 187 upa_cont+\
 188 """        ),
 189     )
 190 """
 191
 192 # --------------------------------------
 193
 194 init_method = """
 195 def F_InitChoice() : return  ("Background",
 196                               "BackgroundError",
 197                               "Observation",
 198                               "ObservationError",
 199                               "ObservationOperator",
 200                               "EvolutionModel",
 201                               "EvolutionError",
 202                               "AlgorithmParameters",
 203                               "UserPostAnalysis",
 204                              )
 205
 206 def F_Init(statut) : return FACT(statut = statut,
 207     INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')]),
 208     TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
 209     )
 210 """
 211
 212 assim_data_method = """
 213 def {assim_name}InNS(filename):
 214     if os.path.isfile(filename):
 215         fc = open(filename, 'r').readlines()
 216         cr = re.compile("^{assim_name}[\s]*=")
 217         for ln in fc:
 218             if cr.match(ln): return 1
 219     return 0
 220 {assim_name}InNS.info = u"The Python file has to contain explicitly a \\"{assim_name}\\" variable."
 221 def F_{assim_name}(statut, fv=NoCheckInNS) : return FACT(
 222     statut=statut,
 223 {storage}
 224     INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=({choices}), defaut={default_choice}),{decl_choices}
 225     )
 226 """
 227
 228 assim_data_choice = """
 229     {choice_name} = BLOC ( condition = " INPUT_TYPE in ( '{choice_name}', ) ",
 230         data = F_{choice_name}("o", fv),
 231         ),"""
 232
 233 observers_choice = """
 234     {var_name} = BLOC (condition=" '{var_name}' in set(SELECTION) ",
 235         {var_name}_data = FACT(statut = "o",
 236             Scheduler    = SIMP(statut = "f", typ = "TXM"),
 237             Info         = SIMP(statut = "o", typ = "TXM", defaut = "{var_name}"),
 238             NodeType     = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "Template", into=("String", "Script", "Template")),
 239             PythonScript = BLOC (condition = " NodeType == 'String' ",
 240                 Value = SIMP(statut = "o", typ = "TXM")
 241                 ),
 242             UserFile = BLOC (condition = " NodeType == 'Script' ",
 243                 Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')])
 244                 ),
 245             ObserverTemplate = F_ObserverTemplate(),
 246             ),
 247         ),"""
 248
 249 # --------------------------------------
 250
 251 from daCore.Templates import ObserverTemplates
 252 observers_list = ObserverTemplates.keys_in_presentation_order()
 253 observers_list = '"%s"'%str('", "'.join(observers_list))
 254 observers_cont = ""
 255 for k in ObserverTemplates.keys_in_presentation_order():
 256     observers_cont += """                %s = BLOC (condition = " Template == '%s' ",\n"""%(k,k)
 257     observers_cont += """                    ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "%s", fr="%s", ang="%s" ),\n"""%(
 258         ObserverTemplates[k].replace("\n","\\n").replace('"','\\"'),
 259         ObserverTemplates.getdoc(k, "fr_FR"),
 260         ObserverTemplates.getdoc(k, "en_EN"),
 261         )
 262     observers_cont += """                    ),\n"""
 263
 264 observers_method = """
 265 def F_ObserverTemplate() : return BLOC(condition = " NodeType == 'Template' ",
 266                 Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "ValuePrinter", into=(%s)),
 267 %s                )
 268
 269 def F_Observers(statut) : return FACT(
 270     statut=statut,
 271     SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", homo="SansOrdreNiDoublon", validators=NoRepeat(), into=({choices})),{decl_choices}
 272     )
 273 """%(observers_list,observers_cont)
 274
 275 # --------------------------------------
 276
 277 algo_choices = """
 278 def AlgorithmParametersInNS(filename):
 279     if os.path.isfile(filename):
 280         fc = open(filename, 'r').readlines()
 281         cr = re.compile("^AlgorithmParameters[\s]*=")
 282         for ln in fc:
 283             if cr.match(ln): return 1
 284     return 0
 285 AlgorithmParametersInNS.info = u"The Python file has to contain explicitly an \\"AlgorithmParameters\\" variable."
 286 def F_AlgorithmParameters(statut, algos_names, fv=NoCheckInNS) : return FACT(
 287     statut = statut,
 288     Algorithm = SIMP(statut="o", typ = "TXM", into = algos_names ),
 289     Parameters = SIMP(statut="f", typ = "TXM", into=("Defaults", "Dict"), defaut="Defaults"),
 290     Dict = BLOC ( condition = " Parameters == 'Dict' ",
 291         statut="f",
 292         data = F_Dict("o", fv),
 293         ),{all_algo_defaults}
 294     )
 295 """
 296 one_algo_choices = """
 297     Parameters{algo_name} = BLOC (condition = " (Parameters == 'Defaults') and (Algorithm == '{algo_name}') ",
 298         statut="f",
 299 {algo_parameters}        ),"""
 300
 301 # --------------------------------------
 302
 303 assim_study = """
 304 def F_variables(statut) : return FACT(
 305     statut=statut,
 306     regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 307     NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 308     SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 309     )
 310 def ChDir(dirname):
 311     os.chdir(os.path.abspath(dirname))
 312     return 1
 313 ChDir.info = u"This has to be a regular directory path."
 314
 315 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 316     op=None,
 317     repetable           = "n",
 318     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 319     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 320     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 321     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 322     AlgorithmParameters = F_AlgorithmParameters("o",({algos_names}), AlgorithmParametersInNS),
 323     Background          = F_Background("o", BackgroundInNS),
 324     BackgroundError     = F_BackgroundError("o", BackgroundErrorInNS),
 325     Observation         = F_Observation("o", ObservationInNS),
 326     ObservationError    = F_ObservationError("o", ObservationErrorInNS),
 327     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 328     EvolutionModel      = F_EvolutionModel("f", EvolutionModelInNS),
 329     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 330     ControlInput        = F_ControlInput("f"),
 331     UserDataInit        = F_Init("f"),
 332     UserPostAnalysis    = F_UserPostAnalysis("o"),
 333     InputVariables      = F_variables("f"),
 334     OutputVariables     = F_variables("f"),
 335     Observers           = F_Observers("f")
 336     )
 337
 338 OPTIMIZATION_STUDY = PROC(nom="OPTIMIZATION_STUDY",
 339     op=None,
 340     repetable           = "n",
 341     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 342     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 343     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 344     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 345     AlgorithmParameters = F_AlgorithmParameters("o",({optim_names}), AlgorithmParametersInNS),
 346     Background          = F_Background("o", BackgroundInNS),
 347     BackgroundError     = F_BackgroundError("f", BackgroundErrorInNS),
 348     Observation         = F_Observation("o", ObservationInNS),
 349     ObservationError    = F_ObservationError("f", ObservationErrorInNS),
 350     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 351     EvolutionModel      = F_EvolutionModel("f", EvolutionModelInNS),
 352     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 353     ControlInput        = F_ControlInput("f"),
 354     UserDataInit        = F_Init("f"),
 355     UserPostAnalysis    = F_UserPostAnalysis("o"),
 356     InputVariables      = F_variables("f"),
 357     OutputVariables     = F_variables("f"),
 358     Observers           = F_Observers("f")
 359     )
 360
 361 REDUCTION_STUDY = PROC(nom="REDUCTION_STUDY",
 362     op=None,
 363     repetable           = "n",
 364     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 365     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 366     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 367     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 368     AlgorithmParameters = F_AlgorithmParameters("o",({reduc_names}), AlgorithmParametersInNS),
 369     Background          = F_Background("o", BackgroundInNS),
 370     BackgroundError     = F_BackgroundError("o", BackgroundErrorInNS),
 371     Observation         = F_Observation("o", ObservationInNS),
 372     ObservationError    = F_ObservationError("o", ObservationErrorInNS),
 373     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 374     EvolutionModel      = F_EvolutionModel("f", EvolutionModelInNS),
 375     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 376     ControlInput        = F_ControlInput("f"),
 377     UserDataInit        = F_Init("f"),
 378     UserPostAnalysis    = F_UserPostAnalysis("o"),
 379     InputVariables      = F_variables("f"),
 380     OutputVariables     = F_variables("f"),
 381     Observers           = F_Observers("f")
 382     )
 383
 384 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 385     op=None,
 386     repetable           = "n",
 387     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Checking Case"),
 388     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 389     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 390     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 391     AlgorithmParameters = F_AlgorithmParameters("o", ({check_names}), AlgorithmParametersInNS),
 392     CheckingPoint       = F_CheckingPoint("o", CheckingPointInNS),
 393     Background          = F_Background("f", BackgroundInNS),
 394     BackgroundError     = F_BackgroundError("f", BackgroundErrorInNS),
 395     Observation         = F_Observation("f", ObservationInNS),
 396     ObservationError    = F_ObservationError("f", ObservationErrorInNS),
 397     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 398     UserDataInit        = F_Init("f"),
 399     Observers           = F_Observers("f")
 400     )
 401 """
 402
 403 #----------- End of Templates Part ---------------#
 404
 405 #===============================================================================
 406
 407 #----------- Begin generation script -----------#
 408
 409 # Parse arguments
 410 from argparse import ArgumentParser
 411 usage = "usage: %(prog)s [options] catalog_path catalog_name"
 412 version="%(prog)s 0.1"
 413 my_parser = ArgumentParser(usage=usage)
 414 my_parser.add_argument('-v', '--version', action='version', version=version)
 415 my_parser.add_argument('catalog_path')
 416 my_parser.add_argument('catalog_name')
 417 args = my_parser.parse_args()
 418
 419 # Generates into a string
 420 mem_file = io.StringIO()
 421
 422 # Initial step: On ouvre le fichier
 423 from time import strftime
 424 mem_file.write(unicode(begin_catalog_file, 'utf-8').format(**{'date':strftime("%Y-%m-%d %H:%M:%S")}))
 425
 426 # Step 0: on obtient la liste des algos
 427 algos_names = ""
 428 optim_names = ""
 429 reduc_names = ""
 430 check_names = ""
 431 decl_algos  = ""
 432 adao_all_names = ""
 433 assim_study_object = daCore.Aidsm.Aidsm()
 434 algos_list = assim_study_object.get_available_algorithms()
 435 del assim_study_object
 436 for algo_name in algos_list:
 437   if algo_name in infos.AssimAlgos:
 438     logging.debug("An assimilation algorithm is found: " + algo_name)
 439     algos_names += "\"" + algo_name + "\", "
 440   if algo_name in infos.OptimizationAlgos:
 441     logging.debug("An optimization algorithm is found: " + algo_name)
 442     optim_names += "\"" + algo_name + "\", "
 443   if algo_name in infos.ReductionAlgos:
 444     logging.debug("A reduction algorithm is found: " + algo_name)
 445     reduc_names += "\"" + algo_name + "\", "
 446   if algo_name in infos.CheckAlgos:
 447     logging.debug("A checking algorithm is found: " + algo_name)
 448     check_names += "\"" + algo_name + "\", "
 449   if algo_name in infos.AssimAlgos+infos.OptimizationAlgos+infos.ReductionAlgos+infos.CheckAlgos:
 450     # Pour filtrer sur les algorithmes vraiment interfacés, car il peut y en avoir moins que "algos_list"
 451     adao_all_names += "\"" + algo_name + "\", "
 452
 453 # Step 1: A partir des infos, on crée les fonctions qui vont permettre
 454 # d'entrer les données utilisateur
 455 for data_input_name in infos.DataTypeDict:
 456   logging.debug('A data input Type is found: ' + data_input_name)
 457   data_name = data_input_name
 458   data_into = ""
 459   data_default = ""
 460   ms_default = ""
 461
 462   # On récupère les différentes façon d'entrer les données
 463   for basic_type in infos.DataTypeDict[data_input_name]:
 464     data_into += "\"" + basic_type + "\", "
 465
 466   # On choisit le défaut
 467   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 468   if data_input_name in infos.DataSValueDefaultDict:
 469     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[data_input_name] + "\","
 470
 471   mem_file.write(unicode(data_method, 'utf-8').format(**{
 472     'data_name'    : data_name,
 473     'data_into'    : data_into,
 474     'data_default' : data_default,
 475     'ms_default'   : ms_default,
 476     }))
 477
 478 # Step 2: On crée les fonctions qui permettent de rentrer les données des algorithmes
 479 for assim_data_input_name in infos.AssimDataDict:
 480   logging.debug("An input function data input is found: " + assim_data_input_name)
 481   # assim_name = assim_data_input_name
 482   storage = ""
 483   choices = ""
 484   default_choice = ""
 485   decl_choices = ""
 486   decl_opts = ""
 487   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 488     storage = "    Stored = SIMP(statut=\"f\", 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\"),"
 489   for choice in infos.AssimDataDict[assim_data_input_name]:
 490     choices += "\"" + choice + "\", "
 491     decl_choices += assim_data_choice.format(**{'choice_name' : choice})
 492     if choice in infos.StoredAssimData:
 493       storage = "    Stored = SIMP(statut=\"f\", 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\"),"
 494   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 495
 496   mem_file.write(unicode(assim_data_method, 'utf-8').format(**{
 497     'assim_name'     : assim_data_input_name,
 498     'storage'        : storage,
 499     'choices'        : choices,
 500     'decl_choices'   : decl_choices,
 501     'default_choice' : default_choice,
 502     }))
 503
 504 # Step 3: On ajoute les fonctions représentant les options possibles
 505 for opt_name in infos.OptDict:
 506   logging.debug("An optional node is found: " + opt_name)
 507   data_name = opt_name
 508   data_into = ""
 509   data_default = ""
 510   ms_default = ""
 511
 512   for choice in infos.OptDict[opt_name]:
 513     data_into += "\"" + choice + "\", "
 514
 515   # On choisit le default
 516   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 517   if opt_name in infos.DataSValueDefaultDict:
 518     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[opt_name] + "\","
 519
 520   mem_file.write(unicode(data_method, 'utf-8').format(**{
 521     'data_name'    : data_name,
 522     'data_into'    : data_into,
 523     'data_default' : data_default,
 524     'ms_default'   : ms_default,
 525     }))
 526
 527 # Step 3bis: On ajoute la méthode optionnelle init
 528 #            TODO si possible uniformiser avec le step 3
 529 mem_file.write(unicode(init_method, 'utf-8'))
 530
 531 # Step 4: On ajoute les observers
 532 decl_choices = ""
 533 for obs_var in infos.ObserversList:
 534   decl_choices += observers_choice.format(**{'var_name':obs_var})
 535 mem_file.write(unicode(observers_method, 'utf-8').format(**{
 536   'choices' : infos.ObserversList,
 537   'decl_choices' : decl_choices,
 538   }))
 539
 540 # Step 5: On ajoute les choix algorithmiques
 541 all_names = eval((adao_all_names))
 542 all_algo_defaults = ""
 543 for algo in all_names:
 544     assim_study_object = daCore.Aidsm.Aidsm()
 545     assim_study_object.setAlgorithmParameters(Algorithm=algo)
 546     par_dict = assim_study_object.get("AlgorithmRequiredParameters",False)
 547     par_keys = sorted(par_dict.keys())
 548     algo_parameters = ""
 549     for pn in par_keys:
 550         if pn in ("StoreInternalVariables", "PlotAndSave", "ResultFile", "ResultTitle", "ResultLabel"): continue # Cles a supprimer
 551         pt = par_dict[pn]["typecast"] # Pointeur de type
 552         pd = par_dict[pn]["default"]
 553         pm = par_dict[pn]["message"]
 554         if "minval" in par_dict[pn] and par_dict[pn]["minval"] is not None:
 555             vi = ", val_min=%s"%par_dict[pn]["minval"]
 556         else:
 557             vi = ""
 558         if "minval" in par_dict[pn] and par_dict[pn]["maxval"] is not None:
 559             vs = ", val_max=%s"%par_dict[pn]["maxval"]
 560         else:
 561             vs = ""
 562         if   pt is int:
 563             algo_parameters += """        %s = SIMP(statut="f", typ="I"%s%s, min=1, max=1, defaut=%s, fr="%s"),\n"""%(pn,vi,vs,int(pd),pm)
 564         elif pt is float:
 565             algo_parameters += """        %s = SIMP(statut="f", typ="R"%s%s, min=1, max=1, defaut=%s, fr="%s"),\n"""%(pn,vi,vs,float(pd),pm)
 566         elif pt is bool:
 567             algo_parameters += """        %s = SIMP(statut="f", typ="I", into=(0, 1), min=1, max=1, defaut=%s, fr="%s"),\n"""%(pn,int(pd),pm)
 568         elif pt is str and "listval" in par_dict[pn]:
 569             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", min=1, max=1, defaut="%s", into=%s, fr="%s"),\n"""%(pn,pd,par_dict[pn]["listval"],pm)
 570         elif pt is tuple and "listval" in par_dict[pn]:
 571             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", max="**", into=%s, fr="%s"),\n"""%(pn,par_dict[pn]["listval"],pm)
 572         else:
 573             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", fr="%s"),\n"""%(pn,pm)
 574     del assim_study_object
 575     if algo_parameters != "":
 576         all_algo_defaults += one_algo_choices.format(**{
 577             'algo_name':algo,
 578             'algo_parameters':algo_parameters,
 579             })
 580 mem_file.write(unicode(algo_choices, 'utf-8').format(**{'all_algo_defaults':unicode(all_algo_defaults, 'utf-8')}))
 581
 582 # Step 6: On ajoute l'algorithme et le assim_study
 583 mem_file.write(unicode(assim_study, 'utf-8').format(**{
 584   'algos_names':algos_names,
 585   'optim_names':optim_names,
 586   'reduc_names':reduc_names,
 587   'check_names':check_names,
 588   'decl_algos':decl_algos,
 589   }))
 590
 591 # Final step: On écrit le fichier
 592 if sys.version_info.major > 2:
 593     with open(os.path.join(args.catalog_path, args.catalog_name), "w", encoding='utf8') as final_file:
 594         final_file.write(mem_file.getvalue())
 595 else:
 596     with open(os.path.join(args.catalog_path, args.catalog_name), "wr") as final_file:
 597         final_file.write(mem_file.getvalue().encode('utf-8'))
 598 mem_file.close()
 599
 600 #----------- End generation script -----------#
 601
 602 #===============================================================================