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")),
 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                                                                       ),
 122                                                           ),
 123 """
 124
 125 observers_method = """
 126 def F_Observers(statut) : return FACT(statut=statut,
 127                                       SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", validators=NoRepeat(), into=(${choices})),
 128 ${decl_choices}
 129                                      )
 130 """
 131
 132 assim_study = """
 133
 134 def F_variables(statut) : return FACT(statut=statut,
 135                                       regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 136                                       NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 137                                       SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 138                                       )
 139
 140 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 141                           op=None,
 142                           repetable           = "n",
 143                           Study_name          = SIMP(statut="o", typ = "TXM"),
 144                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 145                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 146                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${algos_names})),
 147                           Background          = F_Background("o"),
 148                           BackgroundError     = F_BackgroundError("o"),
 149                           Observation         = F_Observation("o"),
 150                           ObservationError    = F_ObservationError("o"),
 151                           ObservationOperator = F_ObservationOperator("o"),
 152                           EvolutionModel      = F_EvolutionModel("f"),
 153                           EvolutionError      = F_EvolutionError("f"),
 154                           ControlInput        = F_ControlInput("f"),
 155                           AlgorithmParameters = F_AlgorithmParameters("f"),
 156                           UserDataInit        = F_Init("f"),
 157                           UserPostAnalysis    = F_UserPostAnalysis("f"),
 158                           InputVariables      = F_variables("f"),
 159                           OutputVariables     = F_variables("f"),
 160                           Observers           = F_Observers("f")
 161                          )
 162
 163 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 164                           op=None,
 165                           repetable           = "n",
 166                           Study_name          = SIMP(statut="o", typ = "TXM"),
 167                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 168                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 169                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${check_names})),
 170                           CheckingPoint       = F_CheckingPoint("o"),
 171                           ObservationOperator = F_ObservationOperator("o"),
 172                           AlgorithmParameters = F_AlgorithmParameters("f"),
 173                           UserDataInit        = F_Init("f"),
 174                          )
 175 """
 176
 177 begin_catalog_file = string.Template(begin_catalog_file)
 178 data_method = string.Template(data_method)
 179 assim_data_method = string.Template(assim_data_method)
 180 assim_data_choice = string.Template(assim_data_choice)
 181 assim_study = string.Template(assim_study)
 182 observers_method = string.Template(observers_method)
 183 observers_choice = string.Template(observers_choice)
 184
 185 #----------- End of Templates Part ---------------#
 186
 187
 188
 189 #----------- Begin generation script -----------#
 190 print "-- Starting AdaoCalatogGenerator.py --"
 191
 192 try:
 193   import daEficas
 194   import daYacsSchemaCreator
 195   import daCore.AssimilationStudy
 196   import daYacsSchemaCreator.infos_daComposant as infos
 197 except:
 198   logging.fatal("Import of ADAO python modules failed !" +
 199                 "\n add ADAO python installation directory in your PYTHONPATH")
 200   traceback.print_exc()
 201   sys.exit(1)
 202
 203 def check_args(args):
 204   logging.debug("Arguments are :" + str(args))
 205   if len(args) != 2:
 206     logging.fatal("Bad number of arguments: you have to provide two arguments (%d given)" % (len(args)))
 207     sys.exit(1)
 208
 209 # Parse arguments
 210 from optparse import OptionParser
 211 usage = "usage: %prog [options] catalog_path catalog_name"
 212 version="%prog 0.1"
 213 my_parser = OptionParser(usage=usage, version=version)
 214 (options, args) = my_parser.parse_args()
 215 check_args(args)
 216
 217 catalog_path =  args[0]
 218 catalog_name =  args[1]
 219
 220 # Generates into a string
 221 mem_file = StringIO.StringIO()
 222
 223 # Start file
 224 from time import strftime
 225 mem_file.write(begin_catalog_file.substitute(date=strftime("%Y-%m-%d %H:%M:%S")))
 226
 227 # Step 1: A partir des infos, on cree les fonctions qui vont permettre
 228 # d'entrer les donnees utilisateur
 229 for data_input_name in infos.DataTypeDict.keys():
 230   logging.debug('A data input Type is found: ' + data_input_name)
 231   data_name = data_input_name
 232   data_into = ""
 233   data_default = ""
 234
 235   # On recupere les differentes facon d'entrer les donnees
 236   for basic_type in infos.DataTypeDict[data_input_name]:
 237     data_into += "\"" + basic_type + "\", "
 238
 239   # On choisit le default
 240   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 241
 242   mem_file.write(data_method.substitute(data_name    = data_name,
 243                                         data_into    = data_into,
 244                                         data_default = data_default))
 245
 246 # Step 2: On cree les fonctions qui permettent de rentrer les donnees des algorithmes
 247 for assim_data_input_name in infos.AssimDataDict.keys():
 248   logging.debug("An assimilation algorithm data input is found: " + assim_data_input_name)
 249   assim_name = assim_data_input_name
 250   storage = ""
 251   choices = ""
 252   default_choice = ""
 253   decl_choices = ""
 254   decl_opts = ""
 255   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 256     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\"),"
 257   for choice in infos.AssimDataDict[assim_data_input_name]:
 258     choices += "\"" + choice + "\", "
 259     decl_choices += assim_data_choice.substitute(choice_name = choice)
 260     if choice in infos.StoredAssimData:
 261       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\"),"
 262   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 263
 264   mem_file.write(assim_data_method.substitute(assim_name = assim_name,
 265                                               storage = storage,
 266                                               choices = choices,
 267                                               decl_choices = decl_choices,
 268                                               default_choice=default_choice))
 269
 270 # Step 3: On ajoute les fonctions representant les options possibles
 271 for opt_name in infos.OptDict.keys():
 272   logging.debug("An optional node is found: " + opt_name)
 273   data_name = opt_name
 274   data_into = ""
 275   data_default = ""
 276
 277   for choice in infos.OptDict[opt_name]:
 278     data_into += "\"" + choice + "\", "
 279   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 280
 281   mem_file.write(data_method.substitute(data_name = data_name,
 282                                         data_into = data_into,
 283                                         data_default = data_default))
 284
 285 # Step 4: On ajoute la methode optionnelle init
 286 # TODO uniformiser avec le step 3
 287 mem_file.write(init_method)
 288
 289 # Step 5: Add observers
 290 decl_choices = ""
 291 for obs_var in infos.ObserversList:
 292   decl_choices += observers_choice.substitute(var_name=obs_var)
 293 mem_file.write(observers_method.substitute(choices = infos.ObserversList,
 294                                            decl_choices = decl_choices))
 295
 296 # Final step: Add algorithm and assim_study
 297 algos_names = ""
 298 check_names = ""
 299 decl_algos  = ""
 300
 301 assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 302 algos_list = assim_study_object.get_available_algorithms()
 303 for algo_name in algos_list:
 304   if algo_name in infos.AssimAlgos:
 305     logging.debug("An assimilation algorithm is found: " + algo_name)
 306     algos_names += "\"" + algo_name + "\", "
 307   elif algo_name in infos.CheckAlgos:
 308     logging.debug("A checking algorithm is found: " + algo_name)
 309     check_names += "\"" + algo_name + "\", "
 310   else:
 311     logging.debug("This algorithm is not considered: " + algo_name)
 312
 313 mem_file.write(assim_study.substitute(algos_names=algos_names,
 314                                       check_names=check_names,
 315                                       decl_algos=decl_algos))
 316 # Write file
 317 final_file = open(catalog_path + "/" + catalog_name, "wr")
 318 final_file.write(mem_file.getvalue())
 319 mem_file.close()
 320 final_file.close()
 321