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         cr = re.compile("^DirectOperator[\s]*=")
  85         for ln in fc:
  86             if cr.match(ln): return 1
  87     return 0
  88 DirectOperatorInNS.info = u"The Python file has to contain explicitly a \\"DirectOperator\\" function definition with only one vector as argument."
  89 def TangentOperatorInNS(filename):
  90     if os.path.exists(filename):
  91         fc = open(filename, 'r').readlines()
  92         cr = re.compile("^def[\s]*TangentOperator[\s]*\(")
  93         for ln in fc:
  94             if cr.match(ln): return 1
  95         cr = re.compile("^TangentOperator[\s]*=")
  96         for ln in fc:
  97             if cr.match(ln): return 1
  98     return 0
  99 TangentOperatorInNS.info = u"The Python file has to contain explicitly a \\"TangentOperator\\" function definition with only one pair of vectors as argument."
 100 def AdjointOperatorInNS(filename):
 101     if os.path.exists(filename):
 102         fc = open(filename, 'r').readlines()
 103         cr = re.compile("^def[\s]*AdjointOperator[\s]*\(")
 104         for ln in fc:
 105             if cr.match(ln): return 1
 106         cr = re.compile("^AdjointOperator[\s]*=")
 107         for ln in fc:
 108             if cr.match(ln): return 1
 109     return 0
 110 AdjointOperatorInNS.info = u"The Python file has to contain explicitly an \\"AdjointOperator\\" function definition with only one pair of vectors as argument."
 111 """%(module_version.name,module_version.version)
 112
 113 # 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)
 114 # validators=[OnlyStr(), FileExtVal('py'), FunctionVal(fv)]
 115 data_method = """
 116 def F_${data_name}(statut, fv=NoCheckInNS) : return FACT(
 117     statut = statut,
 118     FROM = SIMP(statut = "o", typ = "TXM", into=(${data_into}), defaut=${data_default}),
 119     SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
 120         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"),
 121         ),
 122     STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
 123         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"),
 124         ),
 125     SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ",
 126         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"),
 127         ),
 128     SCRIPTWITHONEFUNCTION_DATA = BLOC ( condition = " FROM in ( 'ScriptWithOneFunction', ) ",
 129         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"),
 130         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"),
 131         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"),
 132         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"),
 133         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"),
 134         ),
 135     SCRIPTWITHSWITCH_DATA = BLOC ( condition = " FROM in ( 'ScriptWithSwitch', ) ",
 136         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"),
 137         ),
 138     TEMPLATE_DATA =  BLOC (condition = " FROM in ( 'Template', ) ",
 139         Template = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "AnalysisPrinter", into=("AnalysisPrinter", "AnalysisSaver", "AnalysisPrinterAndSaver")),
 140         AnalysisPrinter = BLOC (condition = " Template == 'AnalysisPrinter' ",
 141             ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nxa=numpy.ravel(ADD.get('Analysis')[-1])\\nprint 'Analysis:',xa" ),
 142             ),
 143         AnalysisSaver = BLOC (condition = " Template == 'AnalysisSaver' ",
 144             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)" ),
 145             ),
 146         AnalysisPrinterAndSaver = BLOC (condition = " Template == 'AnalysisPrinterAndSaver' ",
 147             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)" ),
 148             ),
 149         ),
 150     )
 151 """
 152
 153 init_method = """
 154 def F_InitChoice() : return  ("Background",
 155                               "BackgroundError",
 156                               "Observation",
 157                               "ObservationError",
 158                               "ObservationOperator",
 159                               "EvolutionModel",
 160                               "EvolutionError",
 161                               "AlgorithmParameters",
 162                               "UserPostAnalysis",
 163                              )
 164
 165 def F_Init(statut) : return FACT(statut = statut,
 166     INIT_FILE = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')]),
 167     TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
 168     )
 169 """
 170
 171 assim_data_method = """
 172 def ${assim_name}InNS(filename):
 173     if os.path.exists(filename):
 174         fc = open(filename, 'r').readlines()
 175         cr = re.compile("^${assim_name}[\s]*=")
 176         for ln in fc:
 177             if cr.match(ln): return 1
 178     return 0
 179 ${assim_name}InNS.info = u"The Python file has to contain explicitly a \\"${assim_name}\\" variable."
 180 def F_${assim_name}(statut, fv=NoCheckInNS) : return FACT(
 181     statut=statut,
 182 ${storage}
 183     INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=(${choices}), defaut=${default_choice}),${decl_choices}
 184     )
 185 """
 186
 187 assim_data_choice = """
 188     ${choice_name} = BLOC ( condition = " INPUT_TYPE in ( '${choice_name}', ) ",
 189         data = F_${choice_name}("o", fv),
 190         ),"""
 191
 192 observers_choice = """
 193     ${var_name} = BLOC (condition=" '${var_name}' in set(SELECTION) ",
 194         ${var_name}_data = FACT(statut = "o",
 195             Scheduler    = SIMP(statut = "f", typ = "TXM"),
 196             Info         = SIMP(statut = "o", typ = "TXM", defaut = "${var_name}"),
 197             NodeType     = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "Template", into=("String", "Script", "Template")),
 198             PythonScript = BLOC (condition = " NodeType == 'String' ",
 199                 Value = SIMP(statut = "o", typ = "TXM")
 200                 ),
 201             UserFile = BLOC (condition = " NodeType == 'Script' ",
 202                 Value = SIMP(statut = "o", typ = "FichierNoAbs", validators=[OnlyStr(), FileExtVal('py')])
 203                 ),
 204             ObserverTemplate = F_ObserverTemplate(),
 205             ),
 206         ),"""
 207
 208 observers_method = """
 209 def F_ObserverTemplate() : return BLOC(condition = " NodeType == 'Template' ",
 210                 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", "ValueMean", "ValueStandardError", "ValueVariance", "ValueRMS")),
 211                 ValuePrinter = BLOC (condition = " Template == 'ValuePrinter' ",
 212                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[-1]" ),
 213                     ),
 214                 ValueSeriePrinter = BLOC (condition = " Template == 'ValueSeriePrinter' ",
 215                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "print info, var[:] " ),
 216                     ),
 217                 ValueSaver = BLOC (condition = " Template == 'ValueSaver' ",
 218                     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)" ),
 219                     ),
 220                 ValueSerieSaver = BLOC (condition = " Template == 'ValueSerieSaver' ",
 221                     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)" ),
 222                     ),
 223                 ValuePrinterAndSaver = BLOC (condition = " Template == 'ValuePrinterAndSaver' ",
 224                     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)" ),
 225                     ),
 226                 ValueSeriePrinterAndSaver = BLOC (condition = " Template == 'ValueSeriePrinterAndSaver' ",
 227                     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)" ),
 228                     ),
 229                 ValueGnuPlotter = BLOC (condition = " Template == 'ValueGnuPlotter' ",
 230                     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' ) )" ),
 231                     ),
 232                 ValueSerieGnuPlotter = BLOC (condition = " Template == 'ValueSerieGnuPlotter' ",
 233                     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' ) )" ),
 234                     ),
 235                 ValuePrinterAndGnuPlotter = BLOC (condition = " Template == 'ValuePrinterAndGnuPlotter' ",
 236                     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' ) )" ),
 237                     ),
 238                 ValueSeriePrinterAndGnuPlotter = BLOC (condition = " Template == 'ValueSeriePrinterAndGnuPlotter' ",
 239                     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' ) )" ),
 240                     ),
 241                 ValuePrinterSaverAndGnuPlotter = BLOC (condition = " Template == 'ValuePrinterSaverAndGnuPlotter' ",
 242                     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' ) )" ),
 243                     ),
 244                 ValueSeriePrinterSaverAndGnuPlotter = BLOC (condition = " Template == 'ValueSeriePrinterSaverAndGnuPlotter' ",
 245                     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' ) )" ),
 246                     ),
 247                 ValuePrinter = BLOC (condition = " Template == 'ValueMean' ",
 248                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nprint info, numpy.nanmean(var[-1])" ),
 249                     ),
 250                 ValuePrinter = BLOC (condition = " Template == 'ValueStandardError' ",
 251                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nprint info, numpy.nanstd(var[-1])" ),
 252                     ),
 253                 ValuePrinter = BLOC (condition = " Template == 'ValueVariance' ",
 254                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nprint info, numpy.nanvar(var[-1])" ),
 255                     ),
 256                 ValuePrinter = BLOC (condition = " Template == 'ValueRMS' ",
 257                     ValueTemplate = SIMP(statut = "o", typ = "TXM", min=1, max=1, defaut = "import numpy\\nv = numpy.matrix( numpy.ravel( var[-1] ) )\\nprint info, float( numpy.sqrt((1./v.size)*(v*v.T)) )" ),
 258                     ),
 259                 )
 260
 261 def F_Observers(statut) : return FACT(
 262     statut=statut,
 263     SELECTION = SIMP(statut="o", defaut=[], typ="TXM", min=0, max="**", validators=NoRepeat(), into=(${choices})),${decl_choices}
 264     )
 265 """
 266
 267 algo_choices = """
 268 def AlgorithmParametersInNS(filename):
 269     if os.path.exists(filename):
 270         fc = open(filename, 'r').readlines()
 271         cr = re.compile("^AlgorithmParameters[\s]*=")
 272         for ln in fc:
 273             if cr.match(ln): return 1
 274     return 0
 275 AlgorithmParametersInNS.info = u"The Python file has to contain explicitly an \\"AlgorithmParameters\\" variable."
 276 def F_AlgorithmParameters(statut, algos_names, fv=NoCheckInNS) : return FACT(
 277     statut = statut,
 278     Algorithm = SIMP(statut="o", typ = "TXM", into = algos_names ),
 279     Parameters = SIMP(statut="f", typ = "TXM", into=("Defaults", "Dict") ),
 280     Dict = BLOC ( condition = " Parameters == 'Dict' ",
 281         statut="f",
 282         data = F_Dict("o", fv),
 283         ),${all_algo_defaults}
 284     )
 285 """
 286 one_algo_choices = """
 287     Parameters${algo_name} = BLOC (condition = " (Parameters == 'Defaults') and (Algorithm == '${algo_name}') ",
 288         statut="f",
 289 ${algo_parameters}        ),"""
 290
 291 assim_study = """
 292 def F_variables(statut) : return FACT(
 293     statut=statut,
 294     regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
 295     NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
 296     SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 297     )
 298 def ChDir(dirname):
 299     os.chdir(os.path.abspath(dirname))
 300     return 1
 301 ChDir.info = u"This has to be a regular directory path."
 302
 303 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 304     op=None,
 305     repetable           = "n",
 306     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"),
 307     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 308     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 309     AlgorithmParameters = F_AlgorithmParameters("o",(${algos_names}), AlgorithmParametersInNS),
 310     Background          = F_Background("o", BackgroundInNS),
 311     BackgroundError     = F_BackgroundError("o", BackgroundErrorInNS),
 312     Observation         = F_Observation("o", ObservationInNS),
 313     ObservationError    = F_ObservationError("o", ObservationErrorInNS),
 314     ObservationOperator = F_ObservationOperator("o"),
 315     EvolutionModel      = F_EvolutionModel("f"),
 316     EvolutionError      = F_EvolutionError("f", EvolutionErrorInNS),
 317     ControlInput        = F_ControlInput("f"),
 318     UserDataInit        = F_Init("f"),
 319     UserPostAnalysis    = F_UserPostAnalysis("o"),
 320     InputVariables      = F_variables("f"),
 321     OutputVariables     = F_variables("f"),
 322     Observers           = F_Observers("f")
 323     )
 324
 325 CHECKING_STUDY = PROC(nom="CHECKING_STUDY",
 326     op=None,
 327     repetable           = "n",
 328     StudyName           = SIMP(statut="o", typ = "TXM", defaut="ADAO Checking Case"),
 329     StudyRepertory      = SIMP(statut="f", typ = "Repertoire", validators=FunctionVal(ChDir), min=1, max=1),
 330     Debug               = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
 331     AlgorithmParameters = F_AlgorithmParameters("o", (${check_names}), AlgorithmParametersInNS),
 332     CheckingPoint       = F_CheckingPoint("o", CheckingPointInNS),
 333     BackgroundError     = F_BackgroundError("f", BackgroundErrorInNS),
 334     Observation         = F_Observation("f", ObservationInNS),
 335     ObservationError    = F_ObservationError("f", ObservationErrorInNS),
 336     ObservationOperator = F_ObservationOperator("o"),
 337     UserDataInit        = F_Init("f"),
 338     Observers           = F_Observers("f")
 339     )
 340 """
 341
 342 begin_catalog_file = string.Template(begin_catalog_file)
 343 data_method = string.Template(data_method)
 344 assim_data_method = string.Template(assim_data_method)
 345 assim_data_choice = string.Template(assim_data_choice)
 346 assim_study = string.Template(assim_study)
 347 observers_method = string.Template(observers_method)
 348 observers_choice = string.Template(observers_choice)
 349 algo_choices = string.Template(algo_choices)
 350 one_algo_choices = string.Template(one_algo_choices)
 351
 352 #----------- End of Templates Part ---------------#
 353
 354
 355
 356 #----------- Begin generation script -----------#
 357 print "-- Starting AdaoCalatogGenerator.py --"
 358
 359 try:
 360   import daEficas
 361   import daYacsSchemaCreator
 362   import daCore.AssimilationStudy
 363   import daYacsSchemaCreator.infos_daComposant as infos
 364 except:
 365   logging.fatal("Import of ADAO python modules failed !" +
 366                 "\n add ADAO python installation directory in your PYTHONPATH")
 367   traceback.print_exc()
 368   sys.exit(1)
 369
 370 def check_args(args):
 371   logging.debug("Arguments are :" + str(args))
 372   if len(args) != 2:
 373     logging.fatal("Bad number of arguments: you have to provide two arguments (%d given)" % (len(args)))
 374     sys.exit(1)
 375
 376 # Parse arguments
 377 from optparse import OptionParser
 378 usage = "usage: %prog [options] catalog_path catalog_name"
 379 version="%prog 0.1"
 380 my_parser = OptionParser(usage=usage, version=version)
 381 (options, args) = my_parser.parse_args()
 382 check_args(args)
 383
 384 catalog_path =  args[0]
 385 catalog_name =  args[1]
 386
 387 # Generates into a string
 388 mem_file = StringIO.StringIO()
 389
 390 # Start file
 391 from time import strftime
 392 mem_file.write(begin_catalog_file.substitute(date=strftime("%Y-%m-%d %H:%M:%S")))
 393
 394 # Step initial: on obtient la liste des algos
 395 algos_names = ""
 396 check_names = ""
 397 decl_algos  = ""
 398 assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 399 algos_list = assim_study_object.get_available_algorithms()
 400 del assim_study_object
 401 for algo_name in algos_list:
 402   if algo_name in infos.AssimAlgos:
 403     logging.debug("An assimilation algorithm is found: " + algo_name)
 404     algos_names += "\"" + algo_name + "\", "
 405   elif algo_name in infos.CheckAlgos:
 406     logging.debug("A checking algorithm is found: " + algo_name)
 407     check_names += "\"" + algo_name + "\", "
 408   else:
 409     logging.debug("This algorithm is not considered: " + algo_name)
 410
 411 # Step 1: A partir des infos, on cree les fonctions qui vont permettre
 412 # d'entrer les donnees utilisateur
 413 for data_input_name in infos.DataTypeDict.keys():
 414   logging.debug('A data input Type is found: ' + data_input_name)
 415   data_name = data_input_name
 416   data_into = ""
 417   data_default = ""
 418   ms_default = ""
 419
 420   # On recupere les differentes facon d'entrer les donnees
 421   for basic_type in infos.DataTypeDict[data_input_name]:
 422     data_into += "\"" + basic_type + "\", "
 423
 424   # On choisit le default
 425   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 426   if infos.DataSValueDefaultDict.has_key(data_input_name):
 427     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[data_input_name] + "\","
 428
 429   mem_file.write(data_method.substitute(data_name    = data_name,
 430                                         data_into    = data_into,
 431                                         data_default = data_default,
 432                                         ms_default   = ms_default,
 433                                         algos_names  = algos_names+check_names))
 434
 435 # Step 2: On cree les fonctions qui permettent de rentrer les donnees des algorithmes
 436 for assim_data_input_name in infos.AssimDataDict.keys():
 437   logging.debug("An input function data input is found: " + assim_data_input_name)
 438   # assim_name = assim_data_input_name
 439   storage = ""
 440   choices = ""
 441   default_choice = ""
 442   decl_choices = ""
 443   decl_opts = ""
 444   if infos.AssimDataDefaultDict[assim_data_input_name] in infos.StoredAssimData:
 445     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\"),"
 446   for choice in infos.AssimDataDict[assim_data_input_name]:
 447     choices += "\"" + choice + "\", "
 448     decl_choices += assim_data_choice.substitute(choice_name = choice)
 449     if choice in infos.StoredAssimData:
 450       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\"),"
 451   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 452
 453   mem_file.write(assim_data_method.substitute(assim_name = assim_data_input_name,
 454                                               storage        = storage,
 455                                               choices        = choices,
 456                                               decl_choices   = decl_choices,
 457                                               default_choice = default_choice))
 458
 459 # Step 3: On ajoute les fonctions representant les options possibles
 460 for opt_name in infos.OptDict.keys():
 461   logging.debug("An optional node is found: " + opt_name)
 462   data_name = opt_name
 463   data_into = ""
 464   data_default = ""
 465   ms_default = ""
 466
 467   for choice in infos.OptDict[opt_name]:
 468     data_into += "\"" + choice + "\", "
 469
 470   # On choisit le default
 471   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 472   if infos.DataSValueDefaultDict.has_key(opt_name):
 473     ms_default = " defaut=\"" + infos.DataSValueDefaultDict[opt_name] + "\","
 474
 475   mem_file.write(data_method.substitute(data_name    = data_name,
 476                                         data_into    = data_into,
 477                                         data_default = data_default,
 478                                         ms_default   = ms_default,
 479                                         algos_names  = algos_names+check_names))
 480
 481 # Step 4: On ajoute la methode optionnelle init
 482 # TODO uniformiser avec le step 3
 483 mem_file.write(init_method)
 484
 485 # Step 5: Add observers
 486 decl_choices = ""
 487 for obs_var in infos.ObserversList:
 488   decl_choices += observers_choice.substitute(var_name=obs_var)
 489 mem_file.write(observers_method.substitute(choices = infos.ObserversList,
 490                                            decl_choices = decl_choices))
 491
 492 # Step 5: Add algorithmic choices
 493
 494 all_names = eval((algos_names+check_names))
 495 all_algo_defaults = ""
 496 for algo in all_names:
 497     assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 498     assim_study_object.setAlgorithm(choice=algo)
 499     par_dict = assim_study_object.getAlgorithmParameters(False)
 500     par_keys = par_dict.keys()
 501     par_keys.sort()
 502     algo_parameters = ""
 503     for pn in par_keys:
 504         if pn in ("StoreInternalVariables", "PlotAndSave", "ResultFile", "ResultTitle", "ResultLabel"): continue # Cles a supprimer
 505         pt = par_dict[pn]["typecast"]
 506         pd = par_dict[pn]["default"]
 507         pm = par_dict[pn]["message"]
 508         if par_dict[pn].has_key("minval") and par_dict[pn]["minval"] is not None:
 509             vi = ", val_min=%s"%par_dict[pn]["minval"]
 510         else:
 511             vi = ""
 512         if par_dict[pn].has_key("minval") and par_dict[pn]["maxval"] is not None:
 513             vs = ", val_max=%s"%par_dict[pn]["maxval"]
 514         else:
 515             vs = ""
 516         if   pt is int:
 517             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)
 518         elif pt is float:
 519             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)
 520         elif pt is bool:
 521             algo_parameters += """        %s = SIMP(statut="f", typ="I", min=1, max=1, defaut=%s, fr="%s"),\n"""%(pn,int(pd),pm)
 522         elif pt is str and par_dict[pn].has_key("listval"):
 523             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)
 524         elif pt is tuple and par_dict[pn].has_key("listval"):
 525             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", max="**", into=%s, fr="%s"),\n"""%(pn,par_dict[pn]["listval"],pm)
 526         else:
 527             algo_parameters += """        %s = SIMP(statut="f", typ="TXM", fr="%s"),\n"""%(pn,pm)
 528     del assim_study_object
 529     if algo_parameters != "":
 530         all_algo_defaults += one_algo_choices.substitute(
 531             algo_name=algo,
 532             algo_parameters=algo_parameters,
 533             )
 534
 535 mem_file.write(algo_choices.substitute(all_algo_defaults=all_algo_defaults))
 536
 537 # Final step: Add algorithm and assim_study
 538 mem_file.write(assim_study.substitute(algos_names=algos_names,
 539                                       check_names=check_names,
 540                                       decl_algos=decl_algos))
 541 # Write file
 542 final_file = open(catalog_path + "/" + catalog_name, "wr")
 543 final_file.write(mem_file.getvalue())
 544 mem_file.close()
 545 final_file.close()
 546