bin/AdaoCatalogGenerator.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 # Copyright (C) 2008-2012  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.INFO)
  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                                                      ),
  65                                          SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
  66
  67                                                       SCRIPTWITHSWITCH_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="En attente d'un nom de fichier script, avec ou sans le chemin complet pour le trouver, contenant un switch pour les calculs direct, tangent et adjoint", ang="Waiting for a script file name, with or without the full path to find it, containing a switch for direct, tangent and adjoint computations"),
  68                                                      ),
  69                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
  70
  71                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()), fr="OBSOLETE : conservé pour compatibilité avec la version 6.5, sera supprimé dans le futur", ang="OBSOLETE: keeped for compatibility with the 6.5 version, will be removed in the future"),
  72                                                      ),
  73                                     )
  74 """
  75
  76 init_method = """
  77 def F_InitChoice() : return  ("Background",
  78                               "BackgroundError",
  79                               "Observation",
  80                               "ObservationError",
  81                               "ObservationOperator",
  82                               "EvolutionModel",
  83                               "EvolutionError",
  84                               "AlgorithmParameters",
  85                               "UserPostAnalysis",
  86                              )
  87
  88 def F_Init(statut) : return FACT(statut = statut,
  89                                  INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr())),
  90                                  TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
  91                                 )
  92 """
  93
  94 assim_data_method = """
  95 def F_${assim_name}(statut) : return FACT(statut=statut,
  96 ${storage}
  97                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=(${choices}), defaut=${default_choice}),
  98 ${decl_choices}
  99                                                 )
 100 """
 101
 102 assim_data_choice = """
 103                                                  ${choice_name} = BLOC ( condition = " INPUT_TYPE in ( '${choice_name}', ) ",
 104                                                  data = F_${choice_name}("o"),
 105                                                  ),
 106 """
 107
 108 observers_choice = """
 109                                        ${var_name} = BLOC (condition=" '${var_name}' in set(SELECTION) ",
 110                                                   ${var_name}_data = FACT(statut = "o",
 111                                                              Scheduler = SIMP(statut = "f", typ = "TXM"),
 112                                                              Info      = SIMP(statut = "f", typ = "TXM"),
 113                                                              NodeType  = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "", into=("String", "Script")),
 114                                                              PythonScript = BLOC (condition = " NodeType == 'String' ",
 115                                                                                   Value = SIMP(statut = "o", typ = "TXM")
 116                                                                                  ),
 117                                                              UserFile = BLOC (condition = " NodeType == 'Script' ",
 118                                                                               Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=(OnlyStr()))
 119                                                                              )
 120                                                                       ),
 121                                                           ),
 122 """
 123
 124 observers_method = """
 125 def F_Observers(statut) : return FACT(statut=statut,
 126                                       SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", validators=NoRepeat(), into=(${choices})),
 127 ${decl_choices}
 128                                      )
 129 """
 130
 131 assim_study = """
 132
 133 def F_variables(statut) : return FACT(statut=statut,
 134                                       regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 135                                       NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 136                                       SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 137                                       )
 138
 139 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 140                           op=None,
 141                           repetable           = "n",
 142                           Study_name          = SIMP(statut="o", typ = "TXM"),
 143                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 144                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 145                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${algos_names})),
 146                           Background          = F_Background("o"),
 147                           BackgroundError     = F_BackgroundError("o"),
 148                           Observation         = F_Observation("o"),
 149                           ObservationError    = F_ObservationError("o"),
 150                           ObservationOperator = F_ObservationOperator("o"),
 151                           EvolutionModel      = F_EvolutionModel("f"),
 152                           EvolutionError      = F_EvolutionError("f"),
 153                           AlgorithmParameters = F_AlgorithmParameters("f"),
 154                           UserDataInit        = F_Init("f"),
 155                           UserPostAnalysis    = F_UserPostAnalysis("f"),
 156                           InputVariables      = F_variables("f"),
 157                           OutputVariables     = F_variables("f"),
 158                           Observers           = F_Observers("f")
 159                          )
 160
 161 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 162                           op=None,
 163                           repetable           = "n",
 164                           Study_name          = SIMP(statut="o", typ = "TXM"),
 165                           Study_repertory     = SIMP(statut="f", typ = "Repertoire", min=1, max=1),
 166                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 167                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${check_names})),
 168                           CheckingPoint       = F_CheckingPoint("o"),
 169                           ObservationOperator = F_ObservationOperator("o"),
 170                           AlgorithmParameters = F_AlgorithmParameters("f"),
 171                           UserDataInit        = F_Init("f"),
 172                          )
 173 """
 174
 175 begin_catalog_file = string.Template(begin_catalog_file)
 176 data_method = string.Template(data_method)
 177 assim_data_method = string.Template(assim_data_method)
 178 assim_data_choice = string.Template(assim_data_choice)
 179 assim_study = string.Template(assim_study)
 180 observers_method = string.Template(observers_method)
 181 observers_choice = string.Template(observers_choice)
 182
 183 #----------- End of Templates Part ---------------#
 184
 185
 186
 187 #----------- Begin generation script -----------#
 188 print "-- Starting AdaoCalatogGenerator.py --"
 189
 190 try:
 191   import daEficas
 192   import daYacsSchemaCreator
 193   import daCore.AssimilationStudy
 194   import daYacsSchemaCreator.infos_daComposant as infos
 195 except:
 196   logging.fatal("Import of ADAO python modules failed !" +
 197                 "\n add ADAO python installation directory in your PYTHONPATH")
 198   traceback.print_exc()
 199   sys.exit(1)
 200
 201 def check_args(args):
 202   logging.debug("Arguments are :" + str(args))
 203   if len(args) != 2:
 204     logging.fatal("Bad number of arguments: you have to provide two arguments (%d given)" % (len(args)))
 205     sys.exit(1)
 206
 207 # Parse arguments
 208 from optparse import OptionParser
 209 usage = "usage: %prog [options] catalog_path catalog_name"
 210 version="%prog 0.1"
 211 my_parser = OptionParser(usage=usage, version=version)
 212 (options, args) = my_parser.parse_args()
 213 check_args(args)
 214
 215 catalog_path =  args[0]
 216 catalog_name =  args[1]
 217
 218 # Generates into a string
 219 mem_file = StringIO.StringIO()
 220
 221 # Start file
 222 from time import strftime
 223 mem_file.write(begin_catalog_file.substitute(date=strftime("%Y-%m-%d %H:%M:%S")))
 224
 225 # Step 1: A partir des infos, on cree les fonctions qui vont permettre
 226 # d'entrer les donnees utilisateur
 227 for data_input_name in infos.DataTypeDict.keys():
 228   logging.debug('A data input Type is found: ' + data_input_name)
 229   data_name = data_input_name
 230   data_into = ""
 231   data_default = ""
 232
 233   # On recupere les differentes facon d'entrer les donnees
 234   for basic_type in infos.DataTypeDict[data_input_name]:
 235     data_into += "\"" + basic_type + "\", "
 236
 237   # On choisit le default
 238   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 239
 240   mem_file.write(data_method.substitute(data_name    = data_name,
 241                                         data_into    = data_into,
 242                                         data_default = data_default))
 243
 244 # Step 2: On cree les fonctions qui permettent de rentrer les donnees des algorithmes
 245 for assim_data_input_name in infos.AssimDataDict.keys():
 246   logging.debug("An assimilation algorithm data input is found: " + assim_data_input_name)
 247   assim_name = assim_data_input_name
 248   storage = ""
 249   choices = ""
 250   default_choice = ""
 251   decl_choices = ""
 252   decl_opts = ""
 253   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 254     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\"),"
 255   for choice in infos.AssimDataDict[assim_data_input_name]:
 256     choices += "\"" + choice + "\", "
 257     decl_choices += assim_data_choice.substitute(choice_name = choice)
 258     if choice in infos.StoredAssimData:
 259       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\"),"
 260   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 261
 262   mem_file.write(assim_data_method.substitute(assim_name = assim_name,
 263                                               storage = storage,
 264                                               choices = choices,
 265                                               decl_choices = decl_choices,
 266                                               default_choice=default_choice))
 267
 268 # Step 3: On ajoute les fonctions representant les options possibles
 269 for opt_name in infos.OptDict.keys():
 270   logging.debug("An optional node is found: " + opt_name)
 271   data_name = opt_name
 272   data_into = ""
 273   data_default = ""
 274
 275   for choice in infos.OptDict[opt_name]:
 276     data_into += "\"" + choice + "\", "
 277   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 278
 279   mem_file.write(data_method.substitute(data_name = data_name,
 280                                         data_into = data_into,
 281                                         data_default = data_default))
 282
 283 # Step 4: On ajoute la methode optionnelle init
 284 # TODO uniformiser avec le step 3
 285 mem_file.write(init_method)
 286
 287 # Step 5: Add observers
 288 decl_choices = ""
 289 for obs_var in infos.ObserversList:
 290   decl_choices += observers_choice.substitute(var_name=obs_var)
 291 mem_file.write(observers_method.substitute(choices = infos.ObserversList,
 292                                            decl_choices = decl_choices))
 293
 294 # Final step: Add algorithm and assim_study
 295 algos_names = ""
 296 check_names = ""
 297 decl_algos  = ""
 298
 299 assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 300 algos_list = assim_study_object.get_available_algorithms()
 301 for algo_name in algos_list:
 302   if algo_name in infos.AssimAlgos:
 303     logging.debug("An assimilation algorithm is found: " + algo_name)
 304     algos_names += "\"" + algo_name + "\", "
 305   elif algo_name in infos.CheckAlgos:
 306     logging.debug("A checking algorithm is found: " + algo_name)
 307     check_names += "\"" + algo_name + "\", "
 308   else:
 309     logging.debug("This algorithm is not considered: " + algo_name)
 310
 311 mem_file.write(assim_study.substitute(algos_names=algos_names,
 312                                       check_names=check_names,
 313                                       decl_algos=decl_algos))
 314 # Write file
 315 final_file = open(catalog_path + "/" + catalog_name, "wr")
 316 final_file.write(mem_file.getvalue())
 317 mem_file.close()
 318 final_file.close()
 319