bin/AdaoCatalogGenerator.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # Copyright (C) 2008-2021 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-2021 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 # 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)
 140 # validators=[OnlyStr(), FileExtVal('py'), FunctionVal(fv)]
 141 data_method = """
 142 def F_{data_name}(statut, fv=NoCheckInNS) : return FACT(
 143     statut = statut,
 144     FROM = SIMP(statut = "o", typ = "TXM", into=({data_into}), defaut={data_default}),
 145     SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 146         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"),
 147         ),
 148     DATA_DATA = BLOC ( condition = " FROM in ( 'DataFile', ) ",
 149         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"),
 150         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)"),
 151         ),
 152     STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 153         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"),
 154         ),
 155     SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 156         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"),
 157         ),
 158     SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 159         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"),
 160         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"),
 161         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"),
 162         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"),
 163         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"),
 164         ),
 165     SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 166         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"),
 167         ),
 168     TEMPLATE_DATA =  BLOC (condition = " FROM in ( 'Template', ) ",
 169         Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "AnalysisPrinter", into=("AnalysisPrinter", "AnalysisSaver", "AnalysisPrinterAndSaver", "AnalysisSeriePrinter", "AnalysisSerieSaver", "AnalysisSeriePrinterAndSaver")),
 170         AnalysisPrinter = BLOC (condition = " Template == 'AnalysisPrinter' ",
 171             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print('# Post-analysis')\\nimport numpy\\nxa=ADD.get('Analysis')[-1]\\nprint('Analysis:',xa)" ),
 172             ),
 173         AnalysisSaver = BLOC (condition = " Template == 'AnalysisSaver' ",
 174             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print('# Post-analysis')\\nimport numpy\\nxa=ADD.get('Analysis')[-1]\\nf='/tmp/analysis.txt'\\nprint('Analysis saved in \\"%s\\"'%f)\\nnumpy.savetxt(f,xa)" ),
 175             ),
 176         AnalysisPrinterAndSaver = BLOC (condition = " Template == 'AnalysisPrinterAndSaver' ",
 177             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print('# Post-analysis')\\nimport numpy\\nxa=ADD.get('Analysis')[-1]\\nprint('Analysis:',xa)\\nf='/tmp/analysis.txt'\\nprint('Analysis saved in \\"%s\\"'%f)\\nnumpy.savetxt(f,xa)" ),
 178             ),
 179         AnalysisSeriePrinter = BLOC (condition = " Template == 'AnalysisSeriePrinter' ",
 180             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print('# Post-analysis')\\nimport numpy\\nxa=ADD.get('Analysis')\\nprint('Analysis:',xa)" ),
 181             ),
 182         AnalysisSerieSaver = BLOC (condition = " Template == 'AnalysisSerieSaver' ",
 183             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print('# Post-analysis')\\nimport numpy\\nxa=ADD.get('Analysis')\\nf='/tmp/analysis.txt'\\nprint('Analysis saved in \\"%s\\"'%f)\\nnumpy.savetxt(f,xa)" ),
 184             ),
 185         AnalysisSeriePrinterAndSaver = BLOC (condition = " Template == 'AnalysisSeriePrinterAndSaver' ",
 186             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print('# Post-analysis')\\nimport numpy\\nxa=ADD.get('Analysis')\\nprint('Analysis:',xa)\\nf='/tmp/analysis.txt'\\nprint('Analysis saved in \\"%s\\"'%f)\\nnumpy.savetxt(f,xa)" ),
 187             ),
 188         ),
 189     )
 190 """
 191
 192 init_method = """
 193 def F_InitChoice() : return  ("Background",
 194                               "BackgroundError",
 195                               "Observation",
 196                               "ObservationError",
 197                               "ObservationOperator",
 198                               "EvolutionModel",
 199                               "EvolutionError",
 200                               "AlgorithmParameters",
 201                               "UserPostAnalysis",
 202                              )
 203
 204 def F_Init(statut) : return FACT(statut = statut,
 205     INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')]),
 206     TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
 207     )
 208 """
 209
 210 assim_data_method = """
 211 def {assim_name}InNS(filename):
 212     if os.path.isfile(filename):
 213         fc = open(filename, 'r').readlines()
 214         cr = re.compile("^{assim_name}[\s]*=")
 215         for ln in fc:
 216             if cr.match(ln): return 1
 217     return 0
 218 {assim_name}InNS.info = u"The Python file has to contain explicitly a \\"{assim_name}\\" variable."
 219 def F_{assim_name}(statut, fv=NoCheckInNS) : return FACT(
 220     statut=statut,
 221 {storage}
 222     INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=({choices}), defaut={default_choice}),{decl_choices}
 223     )
 224 """
 225
 226 assim_data_choice = """
 227     {choice_name} = BLOC ( condition = " INPUT_TYPE in ( '{choice_name}', ) ",
 228         data = F_{choice_name}("o", fv),
 229         ),"""
 230
 231 observers_choice = """
 232     {var_name} = BLOC (condition=" '{var_name}' in set(SELECTION) ",
 233         {var_name}_data = FACT(statut = "o",
 234             Scheduler    = SIMP(statut = "f", typ = "TXM"),
 235             Info         = SIMP(statut = "o", typ = "TXM", defaut = "{var_name}"),
 236             NodeType     = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "Template", into=("String", "Script", "Template")),
 237             PythonScript = BLOC (condition = " NodeType == 'String' ",
 238                 Value = SIMP(statut = "o", typ = "TXM")
 239                 ),
 240             UserFile = BLOC (condition = " NodeType == 'Script' ",
 241                 Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')])
 242                 ),
 243             ObserverTemplate = F_ObserverTemplate(),
 244             ),
 245         ),"""
 246
 247 from daCore.Templates import ObserverTemplates
 248 observers_list = ObserverTemplates.keys_in_presentation_order()
 249 observers_list = '"%s"'%str('", "'.join(observers_list))
 250 observers_cont = ""
 251 for k in ObserverTemplates.keys_in_presentation_order():
 252     observers_cont += """                %s = BLOC (condition = " Template == '%s' ",\n"""%(k,k)
 253     observers_cont += """                    ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "%s", fr="%s", ang="%s" ),\n"""%(
 254         ObserverTemplates[k].replace("\n","\\n").replace('"','\\"'),
 255         ObserverTemplates.getdoc(k, "fr_FR"),
 256         ObserverTemplates.getdoc(k, "en_EN"),
 257         )
 258     observers_cont += """                    ),\n"""
 259 observers_method = """
 260 def F_ObserverTemplate() : return BLOC(condition = " NodeType == 'Template' ",
 261                 Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "ValuePrinter", into=(%s)),
 262 %s                )
 263
 264 def F_Observers(statut) : return FACT(
 265     statut=statut,
 266     SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", homo="SansOrdreNiDoublon", validators=NoRepeat(), into=({choices})),{decl_choices}
 267     )
 268 """%(observers_list,observers_cont)
 269
 270 algo_choices = """
 271 def AlgorithmParametersInNS(filename):
 272     if os.path.isfile(filename):
 273         fc = open(filename, 'r').readlines()
 274         cr = re.compile("^AlgorithmParameters[\s]*=")
 275         for ln in fc:
 276             if cr.match(ln): return 1
 277     return 0
 278 AlgorithmParametersInNS.info = u"The Python file has to contain explicitly an \\"AlgorithmParameters\\" variable."
 279 def F_AlgorithmParameters(statut, algos_names, fv=NoCheckInNS) : return FACT(
 280     statut = statut,
 281     Algorithm = SIMP(statut="o", typ = "TXM", into = algos_names ),
 282     Parameters = SIMP(statut="f", typ = "TXM", into=("Defaults", "Dict"), defaut="Defaults"),
 283     Dict = BLOC ( condition = " Parameters == 'Dict' ",
 284         statut="f",
 285         data = F_Dict("o", fv),
 286         ),{all_algo_defaults}
 287     )
 288 """
 289 one_algo_choices = """
 290     Parameters{algo_name} = BLOC (condition = " (Parameters == 'Defaults') and (Algorithm == '{algo_name}') ",
 291         statut="f",
 292 {algo_parameters}        ),"""
 293
 294 assim_study = """
 295 def F_variables(statut) : return FACT(
 296     statut=statut,
 297     regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 298     NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 299     SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 300     )
 301 def ChDir(dirname):
 302     os.chdir(os.path.abspath(dirname))
 303     return 1
 304 ChDir.info = u"This has to be a regular directory path."
 305
 306 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 307     op=None,
 308     repetable           = "n",
 309     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 310     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 311     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 312     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 313     AlgorithmParameters = F_AlgorithmParameters("o",({algos_names}), AlgorithmParametersInNS),
 314     Background          = F_Background("o", BackgroundInNS),
 315     BackgroundError     = F_BackgroundError("o", BackgroundErrorInNS),
 316     Observation         = F_Observation("o", ObservationInNS),
 317     ObservationError    = F_ObservationError("o", ObservationErrorInNS),
 318     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 319     EvolutionModel      = F_EvolutionModel("f", EvolutionModelInNS),
 320     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 321     ControlInput        = F_ControlInput("f"),
 322     UserDataInit        = F_Init("f"),
 323     UserPostAnalysis    = F_UserPostAnalysis("o"),
 324     InputVariables      = F_variables("f"),
 325     OutputVariables     = F_variables("f"),
 326     Observers           = F_Observers("f")
 327     )
 328
 329 OPTIMIZATION_STUDY = PROC(nom="OPTIMIZATION_STUDY",
 330     op=None,
 331     repetable           = "n",
 332     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 333     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 334     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 335     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 336     AlgorithmParameters = F_AlgorithmParameters("o",({optim_names}), AlgorithmParametersInNS),
 337     Background          = F_Background("o", BackgroundInNS),
 338     BackgroundError     = F_BackgroundError("f", BackgroundErrorInNS),
 339     Observation         = F_Observation("o", ObservationInNS),
 340     ObservationError    = F_ObservationError("f", ObservationErrorInNS),
 341     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 342     EvolutionModel      = F_EvolutionModel("f", EvolutionModelInNS),
 343     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 344     ControlInput        = F_ControlInput("f"),
 345     UserDataInit        = F_Init("f"),
 346     UserPostAnalysis    = F_UserPostAnalysis("o"),
 347     InputVariables      = F_variables("f"),
 348     OutputVariables     = F_variables("f"),
 349     Observers           = F_Observers("f")
 350     )
 351
 352 REDUCTION_STUDY = PROC(nom="REDUCTION_STUDY",
 353     op=None,
 354     repetable           = "n",
 355     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 356     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 357     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 358     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 359     AlgorithmParameters = F_AlgorithmParameters("o",({reduc_names}), AlgorithmParametersInNS),
 360     Background          = F_Background("o", BackgroundInNS),
 361     BackgroundError     = F_BackgroundError("o", BackgroundErrorInNS),
 362     Observation         = F_Observation("o", ObservationInNS),
 363     ObservationError    = F_ObservationError("o", ObservationErrorInNS),
 364     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 365     EvolutionModel      = F_EvolutionModel("f", EvolutionModelInNS),
 366     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 367     ControlInput        = F_ControlInput("f"),
 368     UserDataInit        = F_Init("f"),
 369     UserPostAnalysis    = F_UserPostAnalysis("o"),
 370     InputVariables      = F_variables("f"),
 371     OutputVariables     = F_variables("f"),
 372     Observers           = F_Observers("f")
 373     )
 374
 375 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 376     op=None,
 377     repetable           = "n",
 378     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Checking Case"),
 379     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 380     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 381     ExecuteInContainer  = SIMP(statut="f", typ = "TXM", min=1, max=1, defaut = "No", into=("No", "Mono", "Multi")),
 382     AlgorithmParameters = F_AlgorithmParameters("o", ({check_names}), AlgorithmParametersInNS),
 383     CheckingPoint       = F_CheckingPoint("o", CheckingPointInNS),
 384     Background          = F_Background("f", BackgroundInNS),
 385     BackgroundError     = F_BackgroundError("f", BackgroundErrorInNS),
 386     Observation         = F_Observation("f", ObservationInNS),
 387     ObservationError    = F_ObservationError("f", ObservationErrorInNS),
 388     ObservationOperator = F_ObservationOperator("o", ObservationOperatorInNS),
 389     UserDataInit        = F_Init("f"),
 390     Observers           = F_Observers("f")
 391     )
 392 """
 393
 394 #----------- End of Templates Part ---------------#
 395
 396 #===============================================================================
 397
 398 #----------- Begin generation script -----------#
 399
 400 # Parse arguments
 401 from argparse import ArgumentParser
 402 usage = "usage: %(prog)s [options] catalog_path catalog_name"
 403 version="%(prog)s 0.1"
 404 my_parser = ArgumentParser(usage=usage)
 405 my_parser.add_argument('-v', '--version', action='version', version=version)
 406 my_parser.add_argument('catalog_path')
 407 my_parser.add_argument('catalog_name')
 408 args = my_parser.parse_args()
 409
 410 # Generates into a string
 411 mem_file = io.StringIO()
 412
 413 # Initial step: On ouvre le fichier
 414 from time import strftime
 415 mem_file.write(unicode(begin_catalog_file, 'utf-8').format(**{'date':strftime("%Y-%m-%d %H:%M:%S")}))
 416
 417 # Step 0: on obtient la liste des algos
 418 algos_names = ""
 419 optim_names = ""
 420 reduc_names = ""
 421 check_names = ""
 422 decl_algos  = ""
 423 adao_all_names = ""
 424 assim_study_object = daCore.Aidsm.Aidsm()
 425 algos_list = assim_study_object.get_available_algorithms()
 426 del assim_study_object
 427 for algo_name in algos_list:
 428   if algo_name in infos.AssimAlgos:
 429     logging.debug("An assimilation algorithm is found: " + algo_name)
 430     algos_names += "\"" + algo_name + "\", "
 431   if algo_name in infos.OptimizationAlgos:
 432     logging.debug("An optimization algorithm is found: " + algo_name)
 433     optim_names += "\"" + algo_name + "\", "
 434   if algo_name in infos.ReductionAlgos:
 435     logging.debug("A reduction algorithm is found: " + algo_name)
 436     reduc_names += "\"" + algo_name + "\", "
 437   if algo_name in infos.CheckAlgos:
 438     logging.debug("A checking algorithm is found: " + algo_name)
 439     check_names += "\"" + algo_name + "\", "
 440   if algo_name in infos.AssimAlgos+infos.OptimizationAlgos+infos.ReductionAlgos+infos.CheckAlgos:
 441     # Pour filtrer sur les algorithmes vraiment interfacés, car il peut y en avoir moins que "algos_list"
 442     adao_all_names += "\"" + algo_name + "\", "
 443
 444 # Step 1: A partir des infos, on crée les fonctions qui vont permettre
 445 # d'entrer les données utilisateur
 446 for data_input_name in infos.DataTypeDict:
 447   logging.debug('A data input Type is found: ' + data_input_name)
 448   data_name = data_input_name
 449   data_into = ""
 450   data_default = ""
 451   ms_default = ""
 452
 453   # On récupère les différentes façon d'entrer les données
 454   for basic_type in infos.DataTypeDict[data_input_name]:
 455     data_into += "\"" + basic_type + "\", "
 456
 457   # On choisit le défaut
 458   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 459   if data_input_name in infos.DataSValueDefaultDict:
 460     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[data_input_name] + "\","
 461
 462   mem_file.write(unicode(data_method, 'utf-8').format(**{
 463     'data_name'    : data_name,
 464     'data_into'    : data_into,
 465     'data_default' : data_default,
 466     'ms_default'   : ms_default,
 467     }))
 468
 469 # Step 2: On crée les fonctions qui permettent de rentrer les données des algorithmes
 470 for assim_data_input_name in infos.AssimDataDict:
 471   logging.debug("An input function data input is found: " + assim_data_input_name)
 472   # assim_name = assim_data_input_name
 473   storage = ""
 474   choices = ""
 475   default_choice = ""
 476   decl_choices = ""
 477   decl_opts = ""
 478   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 479     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\"),"
 480   for choice in infos.AssimDataDict[assim_data_input_name]:
 481     choices += "\"" + choice + "\", "
 482     decl_choices += assim_data_choice.format(**{'choice_name' : choice})
 483     if choice in infos.StoredAssimData:
 484       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\"),"
 485   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 486
 487   mem_file.write(unicode(assim_data_method, 'utf-8').format(**{
 488     'assim_name'     : assim_data_input_name,
 489     'storage'        : storage,
 490     'choices'        : choices,
 491     'decl_choices'   : decl_choices,
 492     'default_choice' : default_choice,
 493     }))
 494
 495 # Step 3: On ajoute les fonctions représentant les options possibles
 496 for opt_name in infos.OptDict:
 497   logging.debug("An optional node is found: " + opt_name)
 498   data_name = opt_name
 499   data_into = ""
 500   data_default = ""
 501   ms_default = ""
 502
 503   for choice in infos.OptDict[opt_name]:
 504     data_into += "\"" + choice + "\", "
 505
 506   # On choisit le default
 507   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 508   if opt_name in infos.DataSValueDefaultDict:
 509     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[opt_name] + "\","
 510
 511   mem_file.write(unicode(data_method, 'utf-8').format(**{
 512     'data_name'    : data_name,
 513     'data_into'    : data_into,
 514     'data_default' : data_default,
 515     'ms_default'   : ms_default,
 516     }))
 517
 518 # Step 3bis: On ajoute la méthode optionnelle init
 519 #            TODO si possible uniformiser avec le step 3
 520 mem_file.write(unicode(init_method, 'utf-8'))
 521
 522 # Step 4: On ajoute les observers
 523 decl_choices = ""
 524 for obs_var in infos.ObserversList:
 525   decl_choices += observers_choice.format(**{'var_name':obs_var})
 526 mem_file.write(unicode(observers_method, 'utf-8').format(**{
 527   'choices' : infos.ObserversList,
 528   'decl_choices' : decl_choices,
 529   }))
 530
 531 # Step 5: On ajoute les choix algorithmiques
 532 all_names = eval((adao_all_names))
 533 all_algo_defaults = ""
 534 for algo in all_names:
 535     assim_study_object = daCore.Aidsm.Aidsm()
 536     assim_study_object.setAlgorithmParameters(Algorithm=algo)
 537     par_dict = assim_study_object.get("AlgorithmRequiredParameters",False)
 538     par_keys = sorted(par_dict.keys())
 539     algo_parameters = ""
 540     for pn in par_keys:
 541         if pn in ("StoreInternalVariables", "PlotAndSave", "ResultFile", "ResultTitle", "ResultLabel"): continue # Cles a supprimer
 542         pt = par_dict[pn]["typecast"] # Pointeur de type
 543         pd = par_dict[pn]["default"]
 544         pm = par_dict[pn]["message"]
 545         if "minval" in par_dict[pn] and par_dict[pn]["minval"] is not None:
 546             vi = ", val_min=%s"%par_dict[pn]["minval"]
 547         else:
 548             vi = ""
 549         if "minval" in par_dict[pn] and par_dict[pn]["maxval"] is not None:
 550             vs = ", val_max=%s"%par_dict[pn]["maxval"]
 551         else:
 552             vs = ""
 553         if   pt is int:
 554             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)
 555         elif pt is float:
 556             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)
 557         elif pt is bool:
 558             algo_parameters += """        %s = SIMP(statut="f", typ="I", into=(0, 1), min=1, max=1, defaut=%s, fr="%s"),\n"""%(pn,int(pd),pm)
 559         elif pt is str and "listval" in par_dict[pn]:
 560             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)
 561         elif pt is tuple and "listval" in par_dict[pn]:
 562             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", max="**", into=%s, fr="%s"),\n"""%(pn,par_dict[pn]["listval"],pm)
 563         else:
 564             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", fr="%s"),\n"""%(pn,pm)
 565     del assim_study_object
 566     if algo_parameters != "":
 567         all_algo_defaults += one_algo_choices.format(**{
 568             'algo_name':algo,
 569             'algo_parameters':algo_parameters,
 570             })
 571 mem_file.write(unicode(algo_choices, 'utf-8').format(**{'all_algo_defaults':unicode(all_algo_defaults, 'utf-8')}))
 572
 573 # Step 6: On ajoute l'algorithme et le assim_study
 574 mem_file.write(unicode(assim_study, 'utf-8').format(**{
 575   'algos_names':algos_names,
 576   'optim_names':optim_names,
 577   'reduc_names':reduc_names,
 578   'check_names':check_names,
 579   'decl_algos':decl_algos,
 580   }))
 581
 582 # Final step: On écrit le fichier
 583 if sys.version_info.major > 2:
 584     with open(os.path.join(args.catalog_path, args.catalog_name), "w", encoding='utf8') as final_file:
 585         final_file.write(mem_file.getvalue())
 586 else:
 587     with open(os.path.join(args.catalog_path, args.catalog_name), "wr") as final_file:
 588         final_file.write(mem_file.getvalue().encode('utf-8'))
 589 mem_file.close()
 590
 591 #----------- End generation script -----------#
 592
 593 #===============================================================================