src/daSalome/daYacsSchemaCreator/methods.py

   1 #-*- coding: utf-8 -*-
   2 # Copyright (C) 2010-2011 EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 # Author: André Ribes, andre.ribes@edf.fr, EDF R&D
  21
  22 import sys
  23 import traceback
  24 import logging
  25 import pilot
  26 import loader
  27 import SALOMERuntime
  28 import os
  29
  30 from daYacsSchemaCreator.infos_daComposant import *
  31
  32 def create_yacs_proc(study_config):
  33
  34   logging.debug("[create_yacs_proc]")
  35
  36   # Init part
  37   SALOMERuntime.RuntimeSALOME_setRuntime()
  38   l = loader.YACSLoader()
  39   l.registerProcCataLoader()
  40   runtime = pilot.getRuntime()
  41   try:
  42     catalogAd = runtime.loadCatalog("proc", os.environ["ADAO_ROOT_DIR"] + "/share/salome/resources/adao/ADAOSchemaCatalog.xml")
  43     runtime.addCatalog(catalogAd)
  44   except:
  45     logging.fatal("Exception in loading DataAssim YACS catalog")
  46     traceback.print_exc()
  47     sys.exit(1)
  48
  49   # Starting creating proc
  50   proc = runtime.createProc("proc")
  51   proc.setTypeCode("pyobj", runtime.getTypeCode("pyobj"))
  52   proc.setTypeCode("SALOME_TYPES/ParametricInput", catalogAd._typeMap["SALOME_TYPES/ParametricInput"])
  53   proc.setTypeCode("SALOME_TYPES/ParametricOutput", catalogAd._typeMap["SALOME_TYPES/ParametricOutput"])
  54   t_pyobj  = proc.getTypeCode("pyobj")
  55   t_string = proc.getTypeCode("string")
  56   t_param_input  = proc.getTypeCode("SALOME_TYPES/ParametricInput")
  57   t_param_output = proc.getTypeCode("SALOME_TYPES/ParametricOutput")
  58   repertory = False
  59   base_repertory = ""
  60   if "Repertory" in study_config.keys():
  61     base_repertory = study_config["Repertory"]
  62     repertory = True
  63
  64   # Step 0: create AssimilationStudyObject
  65   factory_CAS_node = catalogAd.getNodeFromNodeMap("CreateAssimilationStudy")
  66   CAS_node = factory_CAS_node.cloneNode("CreateAssimilationStudy")
  67   CAS_node.getInputPort("Name").edInitPy(study_config["Name"])
  68   CAS_node.getInputPort("Algorithm").edInitPy(study_config["Algorithm"])
  69   if study_config["Debug"] == "0":
  70     CAS_node.getInputPort("Debug").edInitPy(False)
  71   else:
  72     CAS_node.getInputPort("Debug").edInitPy(True)
  73
  74   # Ajout des Variables
  75   InputVariablesNames = []
  76   InputVariablesSizes = []
  77   for var in study_config["InputVariables"]["Order"]:
  78     InputVariablesNames.append(var)
  79     InputVariablesSizes.append(int(study_config["InputVariables"][var]))
  80   CAS_node.getInputPort("InputVariablesNames").edInitPy(InputVariablesNames)
  81   CAS_node.getInputPort("InputVariablesSizes").edInitPy(InputVariablesSizes)
  82   OutputVariablesNames = []
  83   OutputVariablesSizes = []
  84   for var in study_config["OutputVariables"]["Order"]:
  85     OutputVariablesNames.append(var)
  86     OutputVariablesSizes.append(int(study_config["OutputVariables"][var]))
  87   CAS_node.getInputPort("OutputVariablesNames").edInitPy(OutputVariablesNames)
  88   CAS_node.getInputPort("OutputVariablesSizes").edInitPy(OutputVariablesSizes)
  89
  90   proc.edAddChild(CAS_node)
  91
  92   # Step 0.5: Find if there is a user init node
  93   init_config = {}
  94   init_config["Target"] = []
  95   if "UserDataInit" in study_config.keys():
  96     init_config = study_config["UserDataInit"]
  97     factory_init_node = catalogAd.getNodeFromNodeMap("UserDataInitFromScript")
  98     init_node = factory_init_node.cloneNode("UserDataInit")
  99     if repertory:
 100       init_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(init_config["Data"])))
 101     else:
 102       init_node.getInputPort("script").edInitPy(init_config["Data"])
 103     init_node_script = init_node.getScript()
 104     init_node_script += "init_data = user_script_module.init_data\n"
 105     init_node.setScript(init_node_script)
 106     proc.edAddChild(init_node)
 107
 108   # Step 1: get input data from user configuration
 109
 110   for key in study_config.keys():
 111     if key in AssimData:
 112       data_config = study_config[key]
 113
 114       key_type = key + "Type"
 115
 116       if data_config["Type"] == "Dict" and data_config["From"] == "Script":
 117         # Create node
 118         factory_back_node = catalogAd.getNodeFromNodeMap("CreateDictFromScript")
 119         back_node = factory_back_node.cloneNode("Get" + key)
 120         if repertory:
 121           back_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(data_config["Data"])))
 122         else:
 123           back_node.getInputPort("script").edInitPy(data_config["Data"])
 124         back_node.edAddOutputPort(key, t_pyobj)
 125         back_node_script = back_node.getScript()
 126         back_node_script += key + " = user_script_module." + key + "\n"
 127         back_node.setScript(back_node_script)
 128         proc.edAddChild(back_node)
 129         # Connect node with CreateAssimilationStudy
 130         CAS_node.edAddInputPort(key, t_pyobj)
 131         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 132         # Connect node with InitUserData
 133         if key in init_config["Target"]:
 134           back_node_script = back_node.getScript()
 135           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 136           back_node.setScript(back_node_script)
 137           back_node.edAddInputPort("init_data", t_pyobj)
 138           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 139
 140       if data_config["Type"] == "Vector" and data_config["From"] == "String":
 141         # Create node
 142         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyVectorFromString")
 143         back_node = factory_back_node.cloneNode("Get" + key)
 144         back_node.getInputPort("vector_in_string").edInitPy(data_config["Data"])
 145         proc.edAddChild(back_node)
 146         # Connect node with CreateAssimilationStudy
 147         CAS_node.edAddInputPort(key, t_pyobj)
 148         CAS_node.edAddInputPort(key_type, t_string)
 149         proc.edAddDFLink(back_node.getOutputPort("vector"), CAS_node.getInputPort(key))
 150         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 151         # Connect node with InitUserData
 152         if key in init_config["Target"]:
 153           back_node_script = back_node.getScript()
 154           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 155           back_node.setScript(back_node_script)
 156           back_node.edAddInputPort("init_data", t_pyobj)
 157           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 158
 159       if data_config["Type"] == "Vector" and data_config["From"] == "Script":
 160         # Create node
 161         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyVectorFromScript")
 162         back_node = factory_back_node.cloneNode("Get" + key)
 163         if repertory:
 164           back_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(data_config["Data"])))
 165         else:
 166           back_node.getInputPort("script").edInitPy(data_config["Data"])
 167         back_node.edAddOutputPort(key, t_pyobj)
 168         back_node_script = back_node.getScript()
 169         back_node_script += key + " = user_script_module." + key + "\n"
 170         back_node.setScript(back_node_script)
 171         proc.edAddChild(back_node)
 172         # Connect node with CreateAssimilationStudy
 173         CAS_node.edAddInputPort(key, t_pyobj)
 174         CAS_node.edAddInputPort(key_type, t_string)
 175         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 176         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 177         # Connect node with InitUserData
 178         if key in init_config["Target"]:
 179           back_node_script = back_node.getScript()
 180           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 181           back_node.setScript(back_node_script)
 182           back_node.edAddInputPort("init_data", t_pyobj)
 183           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 184
 185       if data_config["Type"] == "Matrix" and data_config["From"] == "String":
 186         # Create node
 187         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyMatrixFromString")
 188         back_node = factory_back_node.cloneNode("Get" + key)
 189         back_node.getInputPort("matrix_in_string").edInitPy(data_config["Data"])
 190         proc.edAddChild(back_node)
 191         # Connect node with CreateAssimilationStudy
 192         CAS_node.edAddInputPort(key, t_pyobj)
 193         CAS_node.edAddInputPort(key_type, t_string)
 194         proc.edAddDFLink(back_node.getOutputPort("matrix"), CAS_node.getInputPort(key))
 195         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 196         # Connect node with InitUserData
 197         if key in init_config["Target"]:
 198           back_node_script = back_node.getScript()
 199           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 200           back_node.setScript(back_node_script)
 201           back_node.edAddInputPort("init_data", t_pyobj)
 202           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 203
 204       if data_config["Type"] == "Matrix" and data_config["From"] == "Script":
 205         # Create node
 206         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyMatrixFromScript")
 207         back_node = factory_back_node.cloneNode("Get" + key)
 208         if repertory:
 209           back_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(data_config["Data"])))
 210         else:
 211           back_node.getInputPort("script").edInitPy(data_config["Data"])
 212         back_node.edAddOutputPort(key, t_pyobj)
 213         back_node_script = back_node.getScript()
 214         back_node_script += key + " = user_script_module." + key + "\n"
 215         back_node.setScript(back_node_script)
 216         proc.edAddChild(back_node)
 217         # Connect node with CreateAssimilationStudy
 218         CAS_node.edAddInputPort(key, t_pyobj)
 219         CAS_node.edAddInputPort(key_type, t_string)
 220         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 221         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 222         # Connect node with InitUserData
 223         if key in init_config["Target"]:
 224           back_node_script = back_node.getScript()
 225           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 226           back_node.setScript(back_node_script)
 227           back_node.edAddInputPort("init_data", t_pyobj)
 228           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 229
 230       if data_config["Type"] == "Function" and data_config["From"] == "FunctionDict" and key == "ObservationOperator":
 231          FunctionDict = data_config["Data"]
 232          for FunctionName in FunctionDict["Function"]:
 233            port_name = "ObservationOperator" + FunctionName
 234            CAS_node.edAddInputPort(port_name, t_string)
 235            if repertory:
 236              CAS_node.getInputPort(port_name).edInitPy(os.path.join(base_repertory, os.path.basename(FunctionDict["Script"][FunctionName])))
 237            else:
 238              CAS_node.getInputPort(port_name).edInitPy(FunctionDict["Script"][FunctionName])
 239
 240   # Step 3: create compute bloc
 241   if "Observers" in study_config.keys():
 242     # Todo
 243   else:
 244     compute_bloc = runtime.createBloc("compute_bloc")
 245     proc.edAddChild(compute_bloc)
 246     proc.edAddCFLink(CAS_node, compute_bloc)
 247
 248     if AlgoType[study_config["Algorithm"]] == "Optim":
 249       # We use an optimizer loop
 250       name = "Execute" + study_config["Algorithm"]
 251       algLib = "daYacsIntegration.py"
 252       factoryName = "AssimilationAlgorithm_asynch"
 253       optimizer_node = runtime.createOptimizerLoop(name, algLib, factoryName, "")
 254       compute_bloc.edAddChild(optimizer_node)
 255       proc.edAddDFLink(CAS_node.getOutputPort("Study"), optimizer_node.edGetAlgoInitPort())
 256
 257       # Check if we have a python script for OptimizerLoopNode
 258       data_config = study_config["ObservationOperator"]
 259       if data_config["Type"] == "Function" and data_config["From"] == "FunctionDict":
 260         # Get script
 261         FunctionDict = data_config["Data"]
 262         script_filename = ""
 263         for FunctionName in FunctionDict["Function"]:
 264           # We currently support only one file
 265           script_filename = FunctionDict["Script"][FunctionName]
 266           break
 267
 268         # We create a new pyscript node
 269         opt_script_node = runtime.createScriptNode("", "FunctionNode")
 270         if repertory:
 271           script_filename = os.path.join(base_repertory, os.path.basename(script_filename))
 272         try:
 273           script_str= open(script_filename, 'r')
 274         except:
 275           logging.fatal("Exception in opening function script file : " + script_filename)
 276           traceback.print_exc()
 277           sys.exit(1)
 278         node_script  = "#-*-coding:iso-8859-1-*-\n"
 279         node_script += "import sys, os \n"
 280         if base_repertory != "":
 281           node_script += "filepath = \"" + base_repertory + "\"\n"
 282         else:
 283           node_script += "filepath = \"" + os.path.dirname(script_filename) + "\"\n"
 284         node_script += "sys.path.insert(0,os.path.dirname(filepath))\n"
 285         node_script += script_str.read()
 286         opt_script_node.setScript(node_script)
 287         opt_script_node.edAddInputPort("computation", t_param_input)
 288         opt_script_node.edAddOutputPort("result", t_param_output)
 289
 290         # Add it
 291         computation_bloc = runtime.createBloc("computation_bloc")
 292         optimizer_node.edSetNode(computation_bloc)
 293         computation_bloc.edAddChild(opt_script_node)
 294
 295         # We connect Optimizer with the script
 296         proc.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 297         proc.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 298
 299         # Connect node with InitUserData
 300         if "ObservationOperator" in init_config["Target"]:
 301           opt_node_script = opt_script_node.getScript()
 302           opt_node_script = "__builtins__[\"init_data\"] = init_data\n" + opt_node_script
 303           opt_script_node.setScript(opt_node_script)
 304           opt_script_node.edAddInputPort("init_data", t_pyobj)
 305           proc.edAddDFLink(init_node.getOutputPort("init_data"), opt_script_node.getInputPort("init_data"))
 306       else:
 307         factory_opt_script_node = catalogAd.getNodeFromNodeMap("FakeOptimizerLoopNode")
 308         opt_script_node = factory_opt_script_node.cloneNode("FakeFunctionNode")
 309
 310         # Add it
 311         computation_bloc = runtime.createBloc("computation_bloc")
 312         optimizer_node.edSetNode(computation_bloc)
 313         computation_bloc.edAddChild(opt_script_node)
 314
 315         # We connect Optimizer with the script
 316         proc.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 317         proc.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 318
 319   # Step 4: create post-processing from user configuration
 320   if "UserPostAnalysis" in study_config.keys():
 321     analysis_config = study_config["UserPostAnalysis"]
 322     if analysis_config["From"] == "String":
 323       factory_analysis_node = catalogAd.getNodeFromNodeMap("SimpleUserAnalysis")
 324       analysis_node = factory_analysis_node.cloneNode("UsePostAnalysis")
 325       default_script = analysis_node.getScript()
 326       final_script = default_script + analysis_config["Data"]
 327       analysis_node.setScript(final_script)
 328       proc.edAddChild(analysis_node)
 329       proc.edAddCFLink(compute_bloc, analysis_node)
 330       if AlgoType[study_config["Algorithm"]] == "Optim":
 331         proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 332       else:
 333         proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 334
 335       # Connect node with InitUserData
 336       if "UserPostAnalysis" in init_config["Target"]:
 337         node_script = analysis_node.getScript()
 338         node_script = "__builtins__[\"init_data\"] = init_data\n" + node_script
 339         analysis_node.setScript(opt_node_script)
 340         analysis_node.edAddInputPort("init_data", t_pyobj)
 341         proc.edAddDFLink(init_node.getOutputPort("init_data"), analysis_node.getInputPort("init_data"))
 342
 343     elif analysis_config["From"] == "Script":
 344       factory_analysis_node = catalogAd.getNodeFromNodeMap("SimpleUserAnalysis")
 345       analysis_node = factory_analysis_node.cloneNode("UserPostAnalysis")
 346       default_script = analysis_node.getScript()
 347       analysis_file_name = analysis_config["Data"]
 348       if repertory:
 349         analysis_file_name = os.path.join(base_repertory, os.path.basename(analysis_file_name))
 350       try:
 351         analysis_file = open(analysis_file_name, 'r')
 352       except:
 353         logging.fatal("Exception in opening analysis file : " + str(analysis_config["Data"]))
 354         traceback.print_exc()
 355         sys.exit(1)
 356       node_script  = "#-*-coding:iso-8859-1-*-\n"
 357       node_script += "import sys, os \n"
 358       if base_repertory != "":
 359         node_script += "filepath = \"" + base_repertory + "\"\n"
 360       else:
 361         node_script += "filepath = \"" + os.path.dirname(script_filename) + "\"\n"
 362       node_script += "sys.path.insert(0,os.path.dirname(filepath))\n"
 363       node_script += default_script
 364       node_script += analysis_file.read()
 365       analysis_node.setScript(node_script)
 366       proc.edAddChild(analysis_node)
 367       proc.edAddCFLink(compute_bloc, analysis_node)
 368       if AlgoType[study_config["Algorithm"]] == "Optim":
 369         proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 370       else:
 371         proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 372       # Connect node with InitUserData
 373       if "UserPostAnalysis" in init_config["Target"]:
 374         node_script = analysis_node.getScript()
 375         node_script = "__builtins__[\"init_data\"] = init_data\n" + node_script
 376         analysis_node.setScript(opt_node_script)
 377         analysis_node.edAddInputPort("init_data", t_pyobj)
 378         proc.edAddDFLink(init_node.getOutputPort("init_data"), analysis_node.getInputPort("init_data"))
 379
 380       pass
 381
 382   return proc
 383
 384 def write_yacs_proc(proc, yacs_schema_filename):
 385
 386   proc.saveSchema(yacs_schema_filename)
 387