bin/AdaoCatalogGenerator.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 # Copyright (C) 2008-2015 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 string
  29 import StringIO
  30
  31 import module_version
  32
  33 logging.basicConfig(level=logging.WARNING)
  34
  35 #----------- Templates Part ---------------#
  36 begin_catalog_file = """#-*-coding:iso-8859-1-*-
  37 #
  38 # Copyright (C) 2008-2015 EDF R&D
  39 #
  40 # This file is part of SALOME ADAO module
  41 #
  42 # This library is free software; you can redistribute it and/or
  43 # modify it under the terms of the GNU Lesser General Public
  44 # License as published by the Free Software Foundation; either
  45 # version 2.1 of the License.
  46 #
  47 # This library is distributed in the hope that it will be useful,
  48 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  49 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  50 # Lesser General Public License for more details.
  51 #
  52 # You should have received a copy of the GNU Lesser General Public
  53 # License along with this library; if not, write to the Free Software
  54 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  55 #
  56 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  57 #
  58 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  59
  60 # --------------------------------------------------------
  61 # Generated by AdaoCatalogGenerator on ${date}
  62 # --------------------------------------------------------
  63
  64 import os, re
  65 import Accas
  66 from Accas import *
  67
  68 JdC = JDC_CATA (
  69     code = '%s',
  70     execmodul = None,
  71     regles = ( AU_MOINS_UN ('ASSIMILATION_STUDY','CHECKING_STUDY'), AU_PLUS_UN ('ASSIMILATION_STUDY','CHECKING_STUDY')),
  72     )
  73 VERSION_CATALOGUE='%s'
  74
  75 def NoCheckInNS(filename):
  76     return 1
  77 NoCheckInNS.info = ""
  78 def DirectOperatorInNS(filename):
  79     if os.path.exists(filename):
  80         fc = open(filename, 'r').readlines()
  81         cr = re.compile("^def[\s]*DirectOperator[\s]*\(")
  82         for ln in fc:
  83             if cr.match(ln): return 1
  84     return 0
  85 DirectOperatorInNS.info = u"The Python file has to contain explicitly a \\"DirectOperator\\" function definition with only one vector as argument."
  86 def TangentOperatorInNS(filename):
  87     if os.path.exists(filename):
  88         fc = open(filename, 'r').readlines()
  89         cr = re.compile("^def[\s]*TangentOperator[\s]*\(")
  90         for ln in fc:
  91             if cr.match(ln): return 1
  92     return 0
  93 TangentOperatorInNS.info = u"The Python file has to contain explicitly a \\"TangentOperator\\" function definition with only one pair of vectors as argument."
  94 def AdjointOperatorInNS(filename):
  95     if os.path.exists(filename):
  96         fc = open(filename, 'r').readlines()
  97         cr = re.compile("^def[\s]*AdjointOperator[\s]*\(")
  98         for ln in fc:
  99             if cr.match(ln): return 1
 100     return 0
 101 AdjointOperatorInNS.info = u"The Python file has to contain explicitly an \\"AdjointOperator\\" function definition with only one pair of vectors as argument."
 102 """%(module_version.name,module_version.version)
 103
 104 # Important : validators=[...] pour que les conditions soient traitées simultanément, en "ET", et pas en "OU" (choisi dans le cas du tuple à la place de la liste)
 105 # validators=[OnlyStr(), FileExtVal('py'), FunctionVal(fv)]
 106 data_method = """
 107 def F_${data_name}(statut, fv=NoCheckInNS) : return FACT(
 108     statut = statut,
 109     FROM = SIMP(statut = "o", typ = "TXM", into=(${data_into}), defaut=${data_default}),
 110     SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 111         SCRIPT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", 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"),
 112         ),
 113     STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 114         STRING = SIMP(statut = "o", typ = "TXM",${ms_default} 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"),
 115         ),
 116     SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 117         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"),
 118         ),
 119     SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 120         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"),
 121         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"),
 122         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"),
 123         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"),
 124         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"),
 125         ),
 126     SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 127         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"),
 128         ),
 129     TEMPLATE_DATA =  BLOC (condition = " FROM in ( 'Template', ) ",
 130         Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "AnalysisPrinter", into=("AnalysisPrinter", "AnalysisSaver", "AnalysisPrinterAndSaver")),
 131         AnalysisPrinter = BLOC (condition = " Template == 'AnalysisPrinter' ",
 132             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nxa=numpy.ravel(ADD.get('Analysis')[-1])\\nprint 'Analysis:',xa" ),
 133             ),
 134         AnalysisSaver = BLOC (condition = " Template == 'AnalysisSaver' ",
 135             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nxa=numpy.ravel(ADD.get('Analysis')[-1])\\nf='/tmp/analysis.txt'\\nprint 'Analysis saved in \\"%s\\"'%f\\nnumpy.savetxt(f,xa)" ),
 136             ),
 137         AnalysisPrinterAndSaver = BLOC (condition = " Template == 'AnalysisPrinterAndSaver' ",
 138             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nxa=numpy.ravel(ADD.get('Analysis')[-1])\\nprint 'Analysis:',xa\\nf='/tmp/analysis.txt'\\nprint 'Analysis saved in \\"%s\\"'%f\\nnumpy.savetxt(f,xa)" ),
 139             ),
 140         ),
 141     )
 142 """
 143
 144 init_method = """
 145 def F_InitChoice() : return  ("Background",
 146                               "BackgroundError",
 147                               "Observation",
 148                               "ObservationError",
 149                               "ObservationOperator",
 150                               "EvolutionModel",
 151                               "EvolutionError",
 152                               "AlgorithmParameters",
 153                               "UserPostAnalysis",
 154                              )
 155
 156 def F_Init(statut) : return FACT(statut = statut,
 157     INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')]),
 158     TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
 159     )
 160 """
 161
 162 assim_data_method = """
 163 def ${assim_name}InNS(filename):
 164     if os.path.exists(filename):
 165         fc = open(filename, 'r').readlines()
 166         cr = re.compile("^${assim_name}[\s]*=")
 167         for ln in fc:
 168             if cr.match(ln): return 1
 169     return 0
 170 ${assim_name}InNS.info = u"The Python file has to contain explicitly a \\"${assim_name}\\" variable."
 171 def F_${assim_name}(statut, fv=NoCheckInNS) : return FACT(
 172     statut=statut,
 173 ${storage}
 174     INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=(${choices}), defaut=${default_choice}),${decl_choices}
 175     )
 176 """
 177
 178 assim_data_choice = """
 179     ${choice_name} = BLOC ( condition = " INPUT_TYPE in ( '${choice_name}', ) ",
 180         data = F_${choice_name}("o", fv),
 181         ),"""
 182
 183 observers_choice = """
 184     ${var_name} = BLOC (condition=" '${var_name}' in set(SELECTION) ",
 185         ${var_name}_data = FACT(statut = "o",
 186             Scheduler    = SIMP(statut = "f", typ = "TXM"),
 187             Info         = SIMP(statut = "o", typ = "TXM", defaut = "${var_name}"),
 188             NodeType     = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "Template", into=("String", "Script", "Template")),
 189             PythonScript = BLOC (condition = " NodeType == 'String' ",
 190                 Value = SIMP(statut = "o", typ = "TXM")
 191                 ),
 192             UserFile = BLOC (condition = " NodeType == 'Script' ",
 193                 Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')])
 194                 ),
 195             ObserverTemplate = F_ObserverTemplate(),
 196             ),
 197         ),"""
 198
 199 observers_method = """
 200 def F_ObserverTemplate() : return BLOC(condition = " NodeType == 'Template' ",
 201                 Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "ValuePrinter", into=("ValuePrinter", "ValueSeriePrinter", "ValueSaver", "ValueSerieSaver", "ValuePrinterAndSaver", "ValueSeriePrinterAndSaver", "ValueGnuPlotter", "ValueSerieGnuPlotter", "ValuePrinterAndGnuPlotter", "ValueSeriePrinterAndGnuPlotter", "ValuePrinterSaverAndGnuPlotter", "ValueSeriePrinterSaverAndGnuPlotter")),
 202                 ValuePrinter = BLOC (condition = " Template == 'ValuePrinter' ",
 203                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[-1]" ),
 204                     ),
 205                 ValueSeriePrinter = BLOC (condition = " Template == 'ValueSeriePrinter' ",
 206                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[:] " ),
 207                     ),
 208                 ValueSaver = BLOC (condition = " Template == 'ValueSaver' ",
 209                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy, re\\nv=numpy.array(var[-1], ndmin=1)\\nglobal istep\\ntry:\\n    istep += 1\\nexcept:\\n    istep = 0\\nf='/tmp/value_%s_%05i.txt'%(info,istep)\\nf=re.sub('\s','_',f)\\nprint 'Value saved in \\"%s\\"'%f\\nnumpy.savetxt(f,v)" ),
 210                     ),
 211                 ValueSerieSaver = BLOC (condition = " Template == 'ValueSerieSaver' ",
 212                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy, re\\nv=numpy.array(var[:],  ndmin=1)\\nglobal istep\\ntry:\\n    istep += 1\\nexcept:\\n    istep = 0\\nf='/tmp/value_%s_%05i.txt'%(info,istep)\\nf=re.sub('\s','_',f)\\nprint 'Value saved in \\"%s\\"'%f\\nnumpy.savetxt(f,v)" ),
 213                     ),
 214                 ValuePrinterAndSaver = BLOC (condition = " Template == 'ValuePrinterAndSaver' ",
 215                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy, re\\nv=numpy.array(var[-1], ndmin=1)\\nprint info,v\\nglobal istep\\ntry:\\n    istep += 1\\nexcept:\\n    istep = 0\\nf='/tmp/value_%s_%05i.txt'%(info,istep)\\nf=re.sub('\s','_',f)\\nprint 'Value saved in \\"%s\\"'%f\\nnumpy.savetxt(f,v)" ),
 216                     ),
 217                 ValueSeriePrinterAndSaver = BLOC (condition = " Template == 'ValueSeriePrinterAndSaver' ",
 218                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy, re\\nv=numpy.array(var[:],  ndmin=1)\\nprint info,v\\nglobal istep\\ntry:\\n    istep += 1\\nexcept:\\n    istep = 0\\nf='/tmp/value_%s_%05i.txt'%(info,istep)\\nf=re.sub('\s','_',f)\\nprint 'Value saved in \\"%s\\"'%f\\nnumpy.savetxt(f,v)" ),
 219                     ),
 220                 ValueGnuPlotter = BLOC (condition = " Template == 'ValueGnuPlotter' ",
 221                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy, Gnuplot\\nv=numpy.array(var[-1], ndmin=1)\\nglobal ifig, gp\\ntry:\\n    ifig += 1\\n    gp('set style data lines')\\nexcept:\\n    ifig = 0\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"%s (Figure %i)\\"'%(info,ifig))\\ngp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )" ),
 222                     ),
 223                 ValueSerieGnuPlotter = BLOC (condition = " Template == 'ValueSerieGnuPlotter' ",
 224                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy, Gnuplot\\nv=numpy.array(var[:],  ndmin=1)\\nglobal ifig, gp\\ntry:\\n    ifig += 1\\n    gp('set style data lines')\\nexcept:\\n    ifig = 0\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"%s (Figure %i)\\"'%(info,ifig))\\ngp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )" ),
 225                     ),
 226                 ValuePrinterAndGnuPlotter = BLOC (condition = " Template == 'ValuePrinterAndGnuPlotter' ",
 227                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[-1]\\nimport numpy, Gnuplot\\nv=numpy.array(var[-1], ndmin=1)\\nglobal ifig,gp\\ntry:\\n    ifig += 1\\n    gp('set style data lines')\\nexcept:\\n    ifig = 0\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"%s (Figure %i)\\"'%(info,ifig))\\ngp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )" ),
 228                     ),
 229                 ValueSeriePrinterAndGnuPlotter = BLOC (condition = " Template == 'ValueSeriePrinterAndGnuPlotter' ",
 230                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[:] \\nimport numpy, Gnuplot\\nv=numpy.array(var[:],  ndmin=1)\\nglobal ifig,gp\\ntry:\\n    ifig += 1\\n    gp('set style data lines')\\nexcept:\\n    ifig = 0\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"%s (Figure %i)\\"'%(info,ifig))\\ngp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )" ),
 231                     ),
 232                 ValuePrinterSaverAndGnuPlotter = BLOC (condition = " Template == 'ValuePrinterSaverAndGnuPlotter' ",
 233                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[-1]\\nimport numpy, re\\nv=numpy.array(var[-1], ndmin=1)\\nglobal istep\\ntry:\\n    istep += 1\\nexcept:\\n    istep = 0\\nf='/tmp/value_%s_%05i.txt'%(info,istep)\\nf=re.sub('\s','_',f)\\nprint 'Value saved in \\"%s\\"'%f\\nnumpy.savetxt(f,v)\\nimport Gnuplot\\nglobal ifig,gp\\ntry:\\n    ifig += 1\\n    gp('set style data lines')\\nexcept:\\n    ifig = 0\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"%s (Figure %i)\\"'%(info,ifig))\\ngp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )" ),
 234                     ),
 235                 ValueSeriePrinterSaverAndGnuPlotter = BLOC (condition = " Template == 'ValueSeriePrinterSaverAndGnuPlotter' ",
 236                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[:] \\nimport numpy, re\\nv=numpy.array(var[:],  ndmin=1)\\nglobal istep\\ntry:\\n    istep += 1\\nexcept:\\n    istep = 0\\nf='/tmp/value_%s_%05i.txt'%(info,istep)\\nf=re.sub('\s','_',f)\\nprint 'Value saved in \\"%s\\"'%f\\nnumpy.savetxt(f,v)\\nimport Gnuplot\\nglobal ifig,gp\\ntry:\\n    ifig += 1\\n    gp('set style data lines')\\nexcept:\\n    ifig = 0\\n    gp = Gnuplot.Gnuplot(persist=1)\\n    gp('set style data lines')\\ngp('set title  \\"%s (Figure %i)\\"'%(info,ifig))\\ngp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )" ),
 237                     ),
 238                 )
 239
 240 def F_Observers(statut) : return FACT(
 241     statut=statut,
 242     SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", validators=NoRepeat(), into=(${choices})),${decl_choices}
 243     )
 244 """
 245
 246 algo_choices = """
 247 def AlgorithmParametersInNS(filename):
 248     if os.path.exists(filename):
 249         fc = open(filename, 'r').readlines()
 250         cr = re.compile("^AlgorithmParameters[\s]*=")
 251         for ln in fc:
 252             if cr.match(ln): return 1
 253     return 0
 254 AlgorithmParametersInNS.info = u"The Python file has to contain explicitly an \\"AlgorithmParameters\\" variable."
 255 def F_AlgorithmParameters(statut, algos_names, fv=NoCheckInNS) : return FACT(
 256     statut = statut,
 257     Algorithm = SIMP(statut="o", typ = "TXM", into = algos_names ),
 258     Parameters = SIMP(statut="f", typ = "TXM", into=("Defaults", "Dict") ),
 259     Dict = BLOC ( condition = " Parameters == 'Dict' ",
 260         statut="f",
 261         data = F_Dict("o", fv),
 262         ),${all_algo_defaults}
 263     )
 264 """
 265 one_algo_choices = """
 266     Parameters${algo_name} = BLOC (condition = " (Parameters == 'Defaults') and (Algorithm == '${algo_name}') ",
 267         statut="f",
 268 ${algo_parameters}        ),"""
 269
 270 assim_study = """
 271 def F_variables(statut) : return FACT(
 272     statut=statut,
 273     regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 274     NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 275     SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 276     )
 277 def ChDir(dirname):
 278     os.chdir(os.path.abspath(dirname))
 279     return 1
 280 ChDir.info = u"This has to be a regular directory path."
 281
 282 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 283     op=None,
 284     repetable           = "n",
 285     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 286     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 287     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 288     AlgorithmParameters = F_AlgorithmParameters("o",(${algos_names}), AlgorithmParametersInNS),
 289     Background          = F_Background("o", BackgroundInNS),
 290     BackgroundError     = F_BackgroundError("o", BackgroundErrorInNS),
 291     Observation         = F_Observation("o", ObservationInNS),
 292     ObservationError    = F_ObservationError("o", ObservationErrorInNS),
 293     ObservationOperator = F_ObservationOperator("o"),
 294     EvolutionModel      = F_EvolutionModel("f"),
 295     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 296     ControlInput        = F_ControlInput("f"),
 297     UserDataInit        = F_Init("f"),
 298     UserPostAnalysis    = F_UserPostAnalysis("o"),
 299     InputVariables      = F_variables("f"),
 300     OutputVariables     = F_variables("f"),
 301     Observers           = F_Observers("f")
 302     )
 303
 304 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 305     op=None,
 306     repetable           = "n",
 307     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Checking Case"),
 308     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 309     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 310     AlgorithmParameters = F_AlgorithmParameters("o", (${check_names}), AlgorithmParametersInNS),
 311     CheckingPoint       = F_CheckingPoint("o", CheckingPointInNS),
 312     BackgroundError     = F_BackgroundError("f", BackgroundErrorInNS),
 313     Observation         = F_Observation("f", ObservationInNS),
 314     ObservationError    = F_ObservationError("f", ObservationErrorInNS),
 315     ObservationOperator = F_ObservationOperator("o"),
 316     UserDataInit        = F_Init("f"),
 317     Observers           = F_Observers("f")
 318     )
 319 """
 320
 321 begin_catalog_file = string.Template(begin_catalog_file)
 322 data_method = string.Template(data_method)
 323 assim_data_method = string.Template(assim_data_method)
 324 assim_data_choice = string.Template(assim_data_choice)
 325 assim_study = string.Template(assim_study)
 326 observers_method = string.Template(observers_method)
 327 observers_choice = string.Template(observers_choice)
 328 algo_choices = string.Template(algo_choices)
 329 one_algo_choices = string.Template(one_algo_choices)
 330
 331 #----------- End of Templates Part ---------------#
 332
 333
 334
 335 #----------- Begin generation script -----------#
 336 print "-- Starting AdaoCalatogGenerator.py --"
 337
 338 try:
 339   import daEficas
 340   import daYacsSchemaCreator
 341   import daCore.AssimilationStudy
 342   import daYacsSchemaCreator.infos_daComposant as infos
 343 except:
 344   logging.fatal("Import of ADAO python modules failed !" +
 345                 "\n add ADAO python installation directory in your PYTHONPATH")
 346   traceback.print_exc()
 347   sys.exit(1)
 348
 349 def check_args(args):
 350   logging.debug("Arguments are :" + str(args))
 351   if len(args) != 2:
 352     logging.fatal("Bad number of arguments: you have to provide two arguments (%d given)" % (len(args)))
 353     sys.exit(1)
 354
 355 # Parse arguments
 356 from optparse import OptionParser
 357 usage = "usage: %prog [options] catalog_path catalog_name"
 358 version="%prog 0.1"
 359 my_parser = OptionParser(usage=usage, version=version)
 360 (options, args) = my_parser.parse_args()
 361 check_args(args)
 362
 363 catalog_path =  args[0]
 364 catalog_name =  args[1]
 365
 366 # Generates into a string
 367 mem_file = StringIO.StringIO()
 368
 369 # Start file
 370 from time import strftime
 371 mem_file.write(begin_catalog_file.substitute(date=strftime("%Y-%m-%d %H:%M:%S")))
 372
 373 # Step initial: on obtient la liste des algos
 374 algos_names = ""
 375 check_names = ""
 376 decl_algos  = ""
 377 assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 378 algos_list = assim_study_object.get_available_algorithms()
 379 del assim_study_object
 380 for algo_name in algos_list:
 381   if algo_name in infos.AssimAlgos:
 382     logging.debug("An assimilation algorithm is found: " + algo_name)
 383     algos_names += "\"" + algo_name + "\", "
 384   elif algo_name in infos.CheckAlgos:
 385     logging.debug("A checking algorithm is found: " + algo_name)
 386     check_names += "\"" + algo_name + "\", "
 387   else:
 388     logging.debug("This algorithm is not considered: " + algo_name)
 389
 390 # Step 1: A partir des infos, on cree les fonctions qui vont permettre
 391 # d'entrer les donnees utilisateur
 392 for data_input_name in infos.DataTypeDict.keys():
 393   logging.debug('A data input Type is found: ' + data_input_name)
 394   data_name = data_input_name
 395   data_into = ""
 396   data_default = ""
 397   ms_default = ""
 398
 399   # On recupere les differentes facon d'entrer les donnees
 400   for basic_type in infos.DataTypeDict[data_input_name]:
 401     data_into += "\"" + basic_type + "\", "
 402
 403   # On choisit le default
 404   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 405   if infos.DataSValueDefaultDict.has_key(data_input_name):
 406     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[data_input_name] + "\","
 407
 408   mem_file.write(data_method.substitute(data_name    = data_name,
 409                                         data_into    = data_into,
 410                                         data_default = data_default,
 411                                         ms_default   = ms_default,
 412                                         algos_names  = algos_names+check_names))
 413
 414 # Step 2: On cree les fonctions qui permettent de rentrer les donnees des algorithmes
 415 for assim_data_input_name in infos.AssimDataDict.keys():
 416   logging.debug("An input function data input is found: " + assim_data_input_name)
 417   # assim_name = assim_data_input_name
 418   storage = ""
 419   choices = ""
 420   default_choice = ""
 421   decl_choices = ""
 422   decl_opts = ""
 423   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 424     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\"),"
 425   for choice in infos.AssimDataDict[assim_data_input_name]:
 426     choices += "\"" + choice + "\", "
 427     decl_choices += assim_data_choice.substitute(choice_name = choice)
 428     if choice in infos.StoredAssimData:
 429       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\"),"
 430   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 431
 432   mem_file.write(assim_data_method.substitute(assim_name = assim_data_input_name,
 433                                               storage        = storage,
 434                                               choices        = choices,
 435                                               decl_choices   = decl_choices,
 436                                               default_choice = default_choice))
 437
 438 # Step 3: On ajoute les fonctions representant les options possibles
 439 for opt_name in infos.OptDict.keys():
 440   logging.debug("An optional node is found: " + opt_name)
 441   data_name = opt_name
 442   data_into = ""
 443   data_default = ""
 444   ms_default = ""
 445
 446   for choice in infos.OptDict[opt_name]:
 447     data_into += "\"" + choice + "\", "
 448
 449   # On choisit le default
 450   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 451   if infos.DataSValueDefaultDict.has_key(opt_name):
 452     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[opt_name] + "\","
 453
 454   mem_file.write(data_method.substitute(data_name    = data_name,
 455                                         data_into    = data_into,
 456                                         data_default = data_default,
 457                                         ms_default   = ms_default,
 458                                         algos_names  = algos_names+check_names))
 459
 460 # Step 4: On ajoute la methode optionnelle init
 461 # TODO uniformiser avec le step 3
 462 mem_file.write(init_method)
 463
 464 # Step 5: Add observers
 465 decl_choices = ""
 466 for obs_var in infos.ObserversList:
 467   decl_choices += observers_choice.substitute(var_name=obs_var)
 468 mem_file.write(observers_method.substitute(choices = infos.ObserversList,
 469                                            decl_choices = decl_choices))
 470
 471 # Step 5: Add algorithmic choices
 472
 473 all_names = eval((algos_names+check_names))
 474 all_algo_defaults = ""
 475 for algo in all_names:
 476     assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 477     assim_study_object.setAlgorithm(choice=algo)
 478     par_dict = assim_study_object.getAlgorithmParameters(False)
 479     par_keys = par_dict.keys()
 480     par_keys.sort()
 481     algo_parameters = ""
 482     for pn in par_keys:
 483         if pn in ("StoreInternalVariables",): continue # Cles a supprimer
 484         pt = par_dict[pn]["typecast"]
 485         pd = par_dict[pn]["default"]
 486         pm = par_dict[pn]["message"]
 487         if par_dict[pn].has_key("minval") and par_dict[pn]["minval"] is not None:
 488             vi = ", val_min=%s"%par_dict[pn]["minval"]
 489         else:
 490             vi = ""
 491         if par_dict[pn].has_key("minval") and par_dict[pn]["maxval"] is not None:
 492             vs = ", val_max=%s"%par_dict[pn]["maxval"]
 493         else:
 494             vs = ""
 495         if   pt is int:
 496             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)
 497         elif pt is float:
 498             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)
 499         elif pt is bool:
 500             algo_parameters += """        %s = SIMP(statut="f", typ="I", min=1, max=1, defaut=%s, fr="%s"),\n"""%(pn,int(pd),pm)
 501         elif pt is str and par_dict[pn].has_key("listval"):
 502             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", min=1, max=1, defaut="%s", into=%s, fr="%s"),\n"""%(pn,str(pd),par_dict[pn]["listval"],pm)
 503         elif pt is tuple and par_dict[pn].has_key("listval"):
 504             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", max="**", into=%s, fr="%s"),\n"""%(pn,par_dict[pn]["listval"],pm)
 505         else:
 506             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", fr="%s"),\n"""%(pn,pm)
 507     del assim_study_object
 508     if algo_parameters != "":
 509         all_algo_defaults += one_algo_choices.substitute(
 510             algo_name=algo,
 511             algo_parameters=algo_parameters,
 512             )
 513
 514 mem_file.write(algo_choices.substitute(all_algo_defaults=all_algo_defaults))
 515
 516 # Final step: Add algorithm and assim_study
 517 mem_file.write(assim_study.substitute(algos_names=algos_names,
 518                                       check_names=check_names,
 519                                       decl_algos=decl_algos))
 520 # Write file
 521 final_file = open(catalog_path + "/" + catalog_name, "wr")
 522 final_file.write(mem_file.getvalue())
 523 mem_file.close()
 524 final_file.close()
 525