bin/AdaoCatalogGenerator.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 # Copyright (C) 2008-2013 EDF R&D
   4 #
   5 # This library is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public
   7 # License as published by the Free Software Foundation; either
   8 # version 2.1 of the License.
   9 #
  10 # This library is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 # Lesser General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with this library; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  20
  21 import logging
  22 import traceback
  23 import sys
  24 import string
  25 import StringIO
  26
  27 logging.basicConfig(level=logging.WARNING)
  28
  29 #----------- Templates Part ---------------#
  30 begin_catalog_file = """# -*- coding: utf-8 -*-
  31
  32 # --------------------------------------------------------
  33 # generated by AdaoCatalogGenerator at ${date}
  34 # --------------------------------------------------------
  35
  36 import Accas
  37 from Accas import *
  38
  39 JdC = JDC_CATA (code = 'ADAO',
  40                 execmodul = None,
  41                 regles = ( AU_MOINS_UN ('ASSIMILATION_STUDY','CHECKING_STUDY'), AU_PLUS_UN ('ASSIMILATION_STUDY','CHECKING_STUDY')),
  42                )
  43 """
  44
  45 data_method = """
  46 def F_${data_name}(statut) : return FACT(statut = statut,
  47                                          FROM = SIMP(statut = "o", typ = "TXM", into=(${data_into}), defaut=${data_default}),
  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 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"),
  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 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"),
  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                                                       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 difference method"),
  65                                                      ),
  66                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
  67
  68                                                       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"),
  69                                                      ),
  70                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
  71
  72                                                       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"),
  73                                                      ),
  74                                     )
  75 """
  76
  77 init_method = """
  78 def F_InitChoice() : return  ("Background",
  79                               "BackgroundError",
  80                               "Observation",
  81                               "ObservationError",
  82                               "ObservationOperator",
  83                               "EvolutionModel",
  84                               "EvolutionError",
  85                               "AlgorithmParameters",
  86                               "UserPostAnalysis",
  87                              )
  88
  89 def F_Init(statut) : return FACT(statut = statut,
  90                                  INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr())),
  91                                  TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
  92                                 )
  93 """
  94
  95 assim_data_method = """
  96 def F_${assim_name}(statut) : return FACT(statut=statut,
  97 ${storage}
  98                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=(${choices}), defaut=${default_choice}),
  99 ${decl_choices}
 100                                                 )
 101 """
 102
 103 assim_data_choice = """
 104                                                  ${choice_name} = BLOC ( condition = " INPUT_TYPE in ( '${choice_name}', ) ",
 105                                                  data = F_${choice_name}("o"),
 106                                                  ),
 107 """
 108
 109 observers_choice = """
 110                                        ${var_name} = BLOC (condition=" '${var_name}' in set(SELECTION) ",
 111                                            ${var_name}_data = FACT(statut = "o",
 112                                                Scheduler    = SIMP(statut = "f", typ = "TXM"),
 113                                                Info         = SIMP(statut = "f", typ = "TXM"),
 114                                                NodeType     = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script", "Template")),
 115                                                PythonScript = BLOC (condition = " NodeType == 'String' ",
 116                                                    Value = SIMP(statut = "o", typ = "TXM")
 117                                                ),
 118                                                UserFile = BLOC (condition = " NodeType == 'Script' ",
 119                                                    Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 120                                                ),
 121                                                ObserverTemplate =  BLOC (condition = " NodeType == 'Template' ",
 122                                                    Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("ValuePrinter", "ValueGnuPlotter", "ValueSerieGnuPlotter")),
 123                                                    ValuePrinter = BLOC (condition = " Template == 'ValuePrinter' ",
 124                                                        ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info,var[-1]" ),
 125                                                    ),
 126                                                    ValueGnuPlotter = BLOC (condition = " Template == 'ValueGnuPlotter' ",
 127                                                        ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import Gnuplot\\nglobal gp\\ntry:\\n    gp('set style data lines')\\nexcept:\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"'+str(info)+'\\"')\\ngp.plot( Gnuplot.Data( var[-1], with_='lines lw 2' ) )" ),
 128                                                    ),
 129                                                    ValueSerieGnuPlotter = BLOC (condition = " Template == 'ValueSerieGnuPlotter' ",
 130                                                        ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import Gnuplot\\nglobal gp\\ntry:\\n    gp('set style data lines')\\nexcept:\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"'+str(info)+'\\"')\\ngp.plot( Gnuplot.Data( var[:], with_='lines lw 2' ) )" ),
 131                                                    ),
 132                                                ),
 133                                            ),
 134                                        ),
 135 """
 136
 137 observers_method = """
 138 def F_Observers(statut) : return FACT(statut=statut,
 139                                       SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", validators=NoRepeat(), into=(${choices})),
 140 ${decl_choices}
 141                                      )
 142 """
 143
 144 assim_study = """
 145
 146 def F_variables(statut) : return FACT(statut=statut,
 147                                       regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 148                                       NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 149                                       SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 150                                       )
 151
 152 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 153                           op=None,
 154                           repetable           = "n",
 155                           Study_name          = SIMP(statut="o", typ = "TXM"),
 156                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 157                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 158                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${algos_names})),
 159                           Background          = F_Background("o"),
 160                           BackgroundError     = F_BackgroundError("o"),
 161                           Observation         = F_Observation("o"),
 162                           ObservationError    = F_ObservationError("o"),
 163                           ObservationOperator = F_ObservationOperator("o"),
 164                           EvolutionModel      = F_EvolutionModel("f"),
 165                           EvolutionError      = F_EvolutionError("f"),
 166                           ControlInput        = F_ControlInput("f"),
 167                           AlgorithmParameters = F_AlgorithmParameters("f"),
 168                           UserDataInit        = F_Init("f"),
 169                           UserPostAnalysis    = F_UserPostAnalysis("f"),
 170                           InputVariables      = F_variables("f"),
 171                           OutputVariables     = F_variables("f"),
 172                           Observers           = F_Observers("f")
 173                          )
 174
 175 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 176                           op=None,
 177                           repetable           = "n",
 178                           Study_name          = SIMP(statut="o", typ = "TXM"),
 179                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 180                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 181                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${check_names})),
 182                           CheckingPoint       = F_CheckingPoint("o"),
 183                           ObservationOperator = F_ObservationOperator("o"),
 184                           AlgorithmParameters = F_AlgorithmParameters("f"),
 185                           UserDataInit        = F_Init("f"),
 186                          )
 187 """
 188
 189 begin_catalog_file = string.Template(begin_catalog_file)
 190 data_method = string.Template(data_method)
 191 assim_data_method = string.Template(assim_data_method)
 192 assim_data_choice = string.Template(assim_data_choice)
 193 assim_study = string.Template(assim_study)
 194 observers_method = string.Template(observers_method)
 195 observers_choice = string.Template(observers_choice)
 196
 197 #----------- End of Templates Part ---------------#
 198
 199
 200
 201 #----------- Begin generation script -----------#
 202 print "-- Starting AdaoCalatogGenerator.py --"
 203
 204 try:
 205   import daEficas
 206   import daYacsSchemaCreator
 207   import daCore.AssimilationStudy
 208   import daYacsSchemaCreator.infos_daComposant as infos
 209 except:
 210   logging.fatal("Import of ADAO python modules failed !" +
 211                 "\n add ADAO python installation directory in your PYTHONPATH")
 212   traceback.print_exc()
 213   sys.exit(1)
 214
 215 def check_args(args):
 216   logging.debug("Arguments are :" + str(args))
 217   if len(args) != 2:
 218     logging.fatal("Bad number of arguments: you have to provide two arguments (%d given)" % (len(args)))
 219     sys.exit(1)
 220
 221 # Parse arguments
 222 from optparse import OptionParser
 223 usage = "usage: %prog [options] catalog_path catalog_name"
 224 version="%prog 0.1"
 225 my_parser = OptionParser(usage=usage, version=version)
 226 (options, args) = my_parser.parse_args()
 227 check_args(args)
 228
 229 catalog_path =  args[0]
 230 catalog_name =  args[1]
 231
 232 # Generates into a string
 233 mem_file = StringIO.StringIO()
 234
 235 # Start file
 236 from time import strftime
 237 mem_file.write(begin_catalog_file.substitute(date=strftime("%Y-%m-%d %H:%M:%S")))
 238
 239 # Step 1: A partir des infos, on cree les fonctions qui vont permettre
 240 # d'entrer les donnees utilisateur
 241 for data_input_name in infos.DataTypeDict.keys():
 242   logging.debug('A data input Type is found: ' + data_input_name)
 243   data_name = data_input_name
 244   data_into = ""
 245   data_default = ""
 246
 247   # On recupere les differentes facon d'entrer les donnees
 248   for basic_type in infos.DataTypeDict[data_input_name]:
 249     data_into += "\"" + basic_type + "\", "
 250
 251   # On choisit le default
 252   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 253
 254   mem_file.write(data_method.substitute(data_name    = data_name,
 255                                         data_into    = data_into,
 256                                         data_default = data_default))
 257
 258 # Step 2: On cree les fonctions qui permettent de rentrer les donnees des algorithmes
 259 for assim_data_input_name in infos.AssimDataDict.keys():
 260   logging.debug("An assimilation algorithm data input is found: " + assim_data_input_name)
 261   assim_name = assim_data_input_name
 262   storage = ""
 263   choices = ""
 264   default_choice = ""
 265   decl_choices = ""
 266   decl_opts = ""
 267   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 268     storage = "                                          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\"),"
 269   for choice in infos.AssimDataDict[assim_data_input_name]:
 270     choices += "\"" + choice + "\", "
 271     decl_choices += assim_data_choice.substitute(choice_name = choice)
 272     if choice in infos.StoredAssimData:
 273       storage = "                                          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\"),"
 274   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 275
 276   mem_file.write(assim_data_method.substitute(assim_name = assim_name,
 277                                               storage = storage,
 278                                               choices = choices,
 279                                               decl_choices = decl_choices,
 280                                               default_choice=default_choice))
 281
 282 # Step 3: On ajoute les fonctions representant les options possibles
 283 for opt_name in infos.OptDict.keys():
 284   logging.debug("An optional node is found: " + opt_name)
 285   data_name = opt_name
 286   data_into = ""
 287   data_default = ""
 288
 289   for choice in infos.OptDict[opt_name]:
 290     data_into += "\"" + choice + "\", "
 291   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 292
 293   mem_file.write(data_method.substitute(data_name = data_name,
 294                                         data_into = data_into,
 295                                         data_default = data_default))
 296
 297 # Step 4: On ajoute la methode optionnelle init
 298 # TODO uniformiser avec le step 3
 299 mem_file.write(init_method)
 300
 301 # Step 5: Add observers
 302 decl_choices = ""
 303 for obs_var in infos.ObserversList:
 304   decl_choices += observers_choice.substitute(var_name=obs_var)
 305 mem_file.write(observers_method.substitute(choices = infos.ObserversList,
 306                                            decl_choices = decl_choices))
 307
 308 # Final step: Add algorithm and assim_study
 309 algos_names = ""
 310 check_names = ""
 311 decl_algos  = ""
 312
 313 assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 314 algos_list = assim_study_object.get_available_algorithms()
 315 for algo_name in algos_list:
 316   if algo_name in infos.AssimAlgos:
 317     logging.debug("An assimilation algorithm is found: " + algo_name)
 318     algos_names += "\"" + algo_name + "\", "
 319   elif algo_name in infos.CheckAlgos:
 320     logging.debug("A checking algorithm is found: " + algo_name)
 321     check_names += "\"" + algo_name + "\", "
 322   else:
 323     logging.debug("This algorithm is not considered: " + algo_name)
 324
 325 mem_file.write(assim_study.substitute(algos_names=algos_names,
 326                                       check_names=check_names,
 327                                       decl_algos=decl_algos))
 328 # Write file
 329 final_file = open(catalog_path + "/" + catalog_name, "wr")
 330 final_file.write(mem_file.getvalue())
 331 mem_file.close()
 332 final_file.close()
 333