src/daSalome/daYacsSchemaCreator/methods.py

   1 #-*- coding: utf-8 -*-
   2 #  Copyright (C) 2010 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 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 # --
  19 # Author : André RIBES (EDF R&D)
  20 # --
  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   except:
  44     logging.fatal("Exception in loading DataAssim YACS catalog")
  45     traceback.print_exc()
  46     sys.exit(1)
  47
  48   # Starting creating proc
  49   proc = runtime.createProc("proc")
  50   proc.setTypeCode("pyobj", runtime.getTypeCode("pyobj"))
  51   t_pyobj  = proc.getTypeCode("pyobj")
  52   t_string = proc.getTypeCode("string")
  53
  54   # Step 0: create AssimilationStudyObject
  55   factory_CAS_node = catalogAd._nodeMap["CreateAssimilationStudy"]
  56   CAS_node = factory_CAS_node.cloneNode("CreateAssimilationStudy")
  57   CAS_node.getInputPort("Name").edInitPy(study_config["Name"])
  58   CAS_node.getInputPort("Algorithm").edInitPy(study_config["Algorithm"])
  59   proc.edAddChild(CAS_node)
  60
  61   # Step 0.5: Find if there is a user init node
  62   init_config = {}
  63   init_config["Target"] = []
  64   if "Init" in study_config.keys():
  65     init_config = study_config["Init"]
  66     factory_init_node = catalogAd._nodeMap["InitUserDataFromScript"]
  67     init_node = factory_init_node.cloneNode("InitUserData")
  68     init_node.getInputPort("script").edInitPy(init_config["Data"])
  69     proc.edAddChild(init_node)
  70
  71   # Step 1: get input data from user configuration
  72
  73   for key in study_config.keys():
  74     if key in AssimData:
  75       data_config = study_config[key]
  76
  77       key_type = key + "Type"
  78
  79       if data_config["Type"] == "Dict" and data_config["From"] == "Script":
  80         # Create node
  81         factory_back_node = catalogAd._nodeMap["CreateDictFromScript"]
  82         back_node = factory_back_node.cloneNode("Get" + key)
  83         back_node.getInputPort("script").edInitPy(data_config["Data"])
  84         back_node.edAddOutputPort(key, t_pyobj)
  85         proc.edAddChild(back_node)
  86         # Connect node with CreateAssimilationStudy
  87         CAS_node.edAddInputPort(key, t_pyobj)
  88         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
  89         # Connect node with InitUserData
  90         if key in init_config["Target"]:
  91           back_node.edAddInputPort("init_data", t_pyobj)
  92           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
  93
  94       if data_config["Type"] == "Vector" and data_config["From"] == "String":
  95         # Create node
  96         factory_back_node = catalogAd._nodeMap["CreateNumpyVectorFromString"]
  97         back_node = factory_back_node.cloneNode("Get" + key)
  98         back_node.getInputPort("vector_in_string").edInitPy(data_config["Data"])
  99         proc.edAddChild(back_node)
 100         # Connect node with CreateAssimilationStudy
 101         CAS_node.edAddInputPort(key, t_pyobj)
 102         CAS_node.edAddInputPort(key_type, t_string)
 103         proc.edAddDFLink(back_node.getOutputPort("vector"), CAS_node.getInputPort(key))
 104         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 105         # Connect node with InitUserData
 106         if key in init_config["Target"]:
 107           back_node.edAddInputPort("init_data", t_pyobj)
 108           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 109
 110       if data_config["Type"] == "Vector" and data_config["From"] == "Script":
 111         # Create node
 112         factory_back_node = catalogAd._nodeMap["CreateNumpyVectorFromScript"]
 113         back_node = factory_back_node.cloneNode("Get" + key)
 114         back_node.getInputPort("script").edInitPy(data_config["Data"])
 115         back_node.edAddOutputPort(key, t_pyobj)
 116         proc.edAddChild(back_node)
 117         # Connect node with CreateAssimilationStudy
 118         CAS_node.edAddInputPort(key, t_pyobj)
 119         CAS_node.edAddInputPort(key_type, t_string)
 120         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 121         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 122         # Connect node with InitUserData
 123         if key in init_config["Target"]:
 124           back_node.edAddInputPort("init_data", t_pyobj)
 125           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 126
 127       if data_config["Type"] == "Matrix" and data_config["From"] == "String":
 128         # Create node
 129         factory_back_node = catalogAd._nodeMap["CreateNumpyMatrixFromString"]
 130         back_node = factory_back_node.cloneNode("Get" + key)
 131         back_node.getInputPort("matrix_in_string").edInitPy(data_config["Data"])
 132         proc.edAddChild(back_node)
 133         # Connect node with CreateAssimilationStudy
 134         CAS_node.edAddInputPort(key, t_pyobj)
 135         CAS_node.edAddInputPort(key_type, t_string)
 136         proc.edAddDFLink(back_node.getOutputPort("matrix"), CAS_node.getInputPort(key))
 137         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 138         # Connect node with InitUserData
 139         if key in init_config["Target"]:
 140           back_node.edAddInputPort("init_data", t_pyobj)
 141           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 142
 143       if data_config["Type"] == "Matrix" and data_config["From"] == "Script":
 144         # Create node
 145         factory_back_node = catalogAd._nodeMap["CreateNumpyMatrixFromScript"]
 146         back_node = factory_back_node.cloneNode("Get" + key)
 147         back_node.getInputPort("script").edInitPy(data_config["Data"])
 148         back_node.edAddOutputPort(key, t_pyobj)
 149         proc.edAddChild(back_node)
 150         # Connect node with CreateAssimilationStudy
 151         CAS_node.edAddInputPort(key, t_pyobj)
 152         CAS_node.edAddInputPort(key_type, t_string)
 153         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 154         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 155         # Connect node with InitUserData
 156         if key in init_config["Target"]:
 157           back_node.edAddInputPort("init_data", t_pyobj)
 158           proc.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 159
 160       if data_config["Type"] == "Function" and data_config["From"] == "FunctionDict" and key == "ObservationOperator":
 161          FunctionDict = data_config["Data"]
 162          for FunctionName in FunctionDict["Function"]:
 163            port_name = "ObservationOperator" + FunctionName
 164            CAS_node.edAddInputPort(port_name, t_string)
 165            CAS_node.getInputPort(port_name).edInitPy(FunctionDict["Script"][FunctionName])
 166
 167   # Step 3: create compute bloc
 168   compute_bloc = runtime.createBloc("compute_bloc")
 169   proc.edAddChild(compute_bloc)
 170   proc.edAddCFLink(CAS_node, compute_bloc)
 171
 172   if AlgoType[study_config["Algorithm"]] == "Direct":
 173     # We don't need to use an optimizer loop
 174     factory_execute_node = catalogAd._nodeMap["SimpleExecuteDirectAlgorithm"]
 175     execute_node = factory_execute_node.cloneNode("Execute" + study_config["Algorithm"])
 176     compute_bloc.edAddChild(execute_node)
 177     proc.edAddDFLink(CAS_node.getOutputPort("Study"), execute_node.getInputPort("Study"))
 178
 179   if AlgoType[study_config["Algorithm"]] == "Optim":
 180     # We use an optimizer loop
 181     name = "Execute" + study_config["Algorithm"]
 182     algLib = "daYacsIntegration.py"
 183     factoryName = "AssimilationAlgorithm_asynch"
 184     optimizer_node = runtime.createOptimizerLoop(name, algLib, factoryName, "")
 185     compute_bloc.edAddChild(optimizer_node)
 186     proc.edAddDFLink(CAS_node.getOutputPort("Study"), optimizer_node.edGetAlgoInitPort())
 187
 188     # Check if we have a python script for OptimizerLoopNode
 189     data_config = study_config["ObservationOperator"]
 190     if data_config["Type"] == "Function" and data_config["From"] == "FunctionDict":
 191       # Get script
 192       FunctionDict = data_config["Data"]
 193       script_filename = ""
 194       for FunctionName in FunctionDict["Function"]:
 195         # We currently support only one file
 196         script_filename = FunctionDict["Script"][FunctionName]
 197         break
 198
 199       # We create a new pyscript node
 200       opt_script_node = runtime.createScriptNode("", "FunctionNode")
 201       if not os.path.exists(script_filename):
 202         logging.fatal("Function script source file does not exists ! :" + script_filename)
 203         sys.exit(1)
 204       try:
 205         script_str= open(script_filename, 'r')
 206       except:
 207         logging.fatal("Exception in opening function script file : " + script_filename)
 208         traceback.print_exc()
 209         sys.exit(1)
 210       opt_script_node.setScript(script_str.read())
 211       opt_script_node.edAddInputPort("computation", t_pyobj)
 212       opt_script_node.edAddOutputPort("result", t_pyobj)
 213
 214       # Add it
 215       computation_bloc = runtime.createBloc("computation_bloc")
 216       optimizer_node.edSetNode(computation_bloc)
 217       computation_bloc.edAddChild(opt_script_node)
 218
 219       # We connect Optimizer with the script
 220       proc.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 221       proc.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 222
 223       # Connect node with InitUserData
 224       if "ObservationOperator" in init_config["Target"]:
 225         opt_script_node.edAddInputPort("init_data", t_pyobj)
 226         proc.edAddDFLink(init_node.getOutputPort("init_data"), opt_script_node.getInputPort("init_data"))
 227
 228     else:
 229       factory_opt_script_node = catalogAd._nodeMap["FakeOptimizerLoopNode"]
 230       opt_script_node = factory_opt_script_node.cloneNode("FakeFunctionNode")
 231
 232       # Add it
 233       computation_bloc = runtime.createBloc("computation_bloc")
 234       optimizer_node.edSetNode(computation_bloc)
 235       computation_bloc.edAddChild(opt_script_node)
 236
 237       # We connect Optimizer with the script
 238       proc.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 239       proc.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 240
 241   # Step 4: create post-processing from user configuration
 242   if "Analysis" in study_config.keys():
 243     analysis_config = study_config["Analysis"]
 244     if analysis_config["From"] == "String":
 245       factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
 246       analysis_node = factory_analysis_node.cloneNode("User Analysis")
 247       default_script = analysis_node.getScript()
 248       final_script = default_script + analysis_config["Data"]
 249       analysis_node.setScript(final_script)
 250       proc.edAddChild(analysis_node)
 251       proc.edAddCFLink(compute_bloc, analysis_node)
 252       if AlgoType[study_config["Algorithm"]] == "Optim":
 253         proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 254       else:
 255         proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 256
 257       # Connect node with InitUserData
 258       if "Analysis" in init_config["Target"]:
 259         analysis_node.edAddInputPort("init_data", t_pyobj)
 260         proc.edAddDFLink(init_node.getOutputPort("init_data"), analysis_node.getInputPort("init_data"))
 261
 262     elif analysis_config["From"] == "Script":
 263       factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
 264       analysis_node = factory_analysis_node.cloneNode("User Analysis")
 265       default_script = analysis_node.getScript()
 266       if not os.path.exists(analysis_config["Data"]):
 267         logging.fatal("Analysis source file does not exists ! :" + str(analysis_config["Data"]))
 268         sys.exit(1)
 269       try:
 270         analysis_file = open(analysis_config["Data"], 'r')
 271       except:
 272         logging.fatal("Exception in opening analysis file : " + str(analysis_config["Data"]))
 273         traceback.print_exc()
 274         sys.exit(1)
 275       file_text = analysis_file.read()
 276       final_script = default_script + file_text
 277       analysis_node.setScript(final_script)
 278       proc.edAddChild(analysis_node)
 279       proc.edAddCFLink(compute_bloc, analysis_node)
 280       if AlgoType[study_config["Algorithm"]] == "Optim":
 281         proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 282       else:
 283         proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 284       # Connect node with InitUserData
 285       if "Analysis" in init_config["Target"]:
 286         analysis_node.edAddInputPort("init_data", t_pyobj)
 287         proc.edAddDFLink(init_node.getOutputPort("init_data"), analysis_node.getInputPort("init_data"))
 288
 289       pass
 290
 291   return proc
 292
 293 def write_yacs_proc(proc, yacs_schema_filename):
 294
 295   proc.saveSchema(yacs_schema_filename)
 296