src/daSalome/daYacsSchemaCreator/methods.py

   1 #-*-coding:iso-8859-1-*-
   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 1: get input data from user configuration
  62
  63   for key in study_config.keys():
  64     if key in AssimData:
  65       data_config = study_config[key]
  66
  67       key_type = key + "Type"
  68
  69       if data_config["Type"] == "Vector" and data_config["From"] == "String":
  70         # Create node
  71         factory_back_node = catalogAd._nodeMap["CreateNumpyVectorFromString"]
  72         back_node = factory_back_node.cloneNode("Get" + key)
  73         back_node.getInputPort("vector_in_string").edInitPy(data_config["Data"])
  74         proc.edAddChild(back_node)
  75         # Connect node with CreateAssimilationStudy
  76         CAS_node.edAddInputPort(key, t_pyobj)
  77         CAS_node.edAddInputPort(key_type, t_string)
  78         proc.edAddDFLink(back_node.getOutputPort("vector"), CAS_node.getInputPort(key))
  79         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
  80
  81       if data_config["Type"] == "Vector" and data_config["From"] == "Script":
  82         # Create node
  83         factory_back_node = catalogAd._nodeMap["CreateNumpyVectorFromScript"]
  84         back_node = factory_back_node.cloneNode("Get" + key)
  85         back_node.getInputPort("script").edInitPy(data_config["Data"])
  86         back_node.edAddOutputPort(key, t_pyobj)
  87         proc.edAddChild(back_node)
  88         # Connect node with CreateAssimilationStudy
  89         CAS_node.edAddInputPort(key, t_pyobj)
  90         CAS_node.edAddInputPort(key_type, t_string)
  91         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
  92         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
  93
  94       if data_config["Type"] == "Matrix" and data_config["From"] == "String":
  95         # Create node
  96         factory_back_node = catalogAd._nodeMap["CreateNumpyMatrixFromString"]
  97         back_node = factory_back_node.cloneNode("Get" + key)
  98         back_node.getInputPort("matrix_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("matrix"), CAS_node.getInputPort(key))
 104         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 105
 106       if data_config["Type"] == "Matrix" and data_config["From"] == "Script":
 107         # Create node
 108         factory_back_node = catalogAd._nodeMap["CreateNumpyMatrixFromScript"]
 109         back_node = factory_back_node.cloneNode("Get" + key)
 110         back_node.getInputPort("script").edInitPy(data_config["Data"])
 111         back_node.edAddOutputPort(key, t_pyobj)
 112         proc.edAddChild(back_node)
 113         # Connect node with CreateAssimilationStudy
 114         CAS_node.edAddInputPort(key, t_pyobj)
 115         CAS_node.edAddInputPort(key_type, t_string)
 116         proc.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 117         proc.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 118
 119       if data_config["Type"] == "Function" and data_config["From"] == "Dict" and key == "ObservationOperator":
 120          FunctionDict = data_config["Data"]
 121          for FunctionName in FunctionDict["Function"]:
 122            port_name = "ObservationOperator" + FunctionName
 123            CAS_node.edAddInputPort(port_name, t_string)
 124            CAS_node.getInputPort(port_name).edInitPy(FunctionDict["Script"][FunctionName])
 125
 126   # Step 3: create compute bloc
 127   compute_bloc = runtime.createBloc("compute_bloc")
 128   proc.edAddChild(compute_bloc)
 129   proc.edAddCFLink(CAS_node, compute_bloc)
 130
 131   if AlgoType[study_config["Algorithm"]] == "Direct":
 132     # We don't need to use an optimizer loop
 133     factory_execute_node = catalogAd._nodeMap["SimpleExecuteDirectAlgorithm"]
 134     execute_node = factory_execute_node.cloneNode("Execute" + study_config["Algorithm"])
 135     compute_bloc.edAddChild(execute_node)
 136     proc.edAddDFLink(CAS_node.getOutputPort("Study"), execute_node.getInputPort("Study"))
 137
 138   if AlgoType[study_config["Algorithm"]] == "Optim":
 139     # We use an optimizer loop
 140     name = "Execute" + study_config["Algorithm"]
 141     algLib = "daYacsIntegration.py"
 142     factoryName = "AssimilationAlgorithm_asynch"
 143     optimizer_node = runtime.createOptimizerLoop(name, algLib, factoryName, "")
 144     compute_bloc.edAddChild(optimizer_node)
 145     proc.edAddDFLink(CAS_node.getOutputPort("Study"), optimizer_node.edGetAlgoInitPort())
 146
 147     # Check if we have a python script for OptimizerLoopNode
 148     data_config = study_config["ObservationOperator"]
 149     if data_config["Type"] == "Function" and data_config["From"] == "Dict":
 150       # Get script
 151       FunctionDict = data_config["Data"]
 152       script_filename = ""
 153       for FunctionName in FunctionDict["Function"]:
 154         # We currently support only one file
 155         script_filename = FunctionDict["Script"][FunctionName]
 156         break
 157
 158       # We create a new pyscript node
 159       opt_script_node = runtime.createScriptNode("", "FunctionNode")
 160       if not os.path.exists(script_filename):
 161         logging.fatal("Function script source file does not exists ! :" + script_filename)
 162         sys.exit(1)
 163       try:
 164         script_str= open(script_filename, 'r')
 165       except:
 166         logging.fatal("Exception in opening function script file : " + script_filename)
 167         traceback.print_exc()
 168         sys.exit(1)
 169       opt_script_node.setScript(script_str.read())
 170       opt_script_node.edAddInputPort("computation", t_pyobj)
 171       opt_script_node.edAddOutputPort("result", t_pyobj)
 172
 173       # Add it
 174       computation_bloc = runtime.createBloc("computation_bloc")
 175       optimizer_node.edSetNode(computation_bloc)
 176       computation_bloc.edAddChild(opt_script_node)
 177
 178       # We connect Optimizer with the script
 179       proc.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 180       proc.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 181
 182     else:
 183       factory_opt_script_node = catalogAd._nodeMap["FakeOptimizerLoopNode"]
 184       opt_script_node = factory_opt_script_node.cloneNode("FakeFunctionNode")
 185
 186       # Add it
 187       computation_bloc = runtime.createBloc("computation_bloc")
 188       optimizer_node.edSetNode(computation_bloc)
 189       computation_bloc.edAddChild(opt_script_node)
 190
 191       # We connect Optimizer with the script
 192       proc.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 193       proc.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 194
 195   # Step 4: create post-processing from user configuration
 196   if "Analysis" in study_config.keys():
 197     analysis_config = study_config["Analysis"]
 198     if analysis_config["From"] == "String":
 199       factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
 200       analysis_node = factory_analysis_node.cloneNode("User Analysis")
 201       default_script = analysis_node.getScript()
 202       final_script = default_script + analysis_config["Data"]
 203       analysis_node.setScript(final_script)
 204       proc.edAddChild(analysis_node)
 205       proc.edAddCFLink(compute_bloc, analysis_node)
 206       if AlgoType[study_config["Algorithm"]] == "Optim":
 207         proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 208       else:
 209         proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 210
 211     elif analysis_config["From"] == "File":
 212       factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
 213       analysis_node = factory_analysis_node.cloneNode("User Analysis")
 214       default_script = analysis_node.getScript()
 215       if not os.path.exists(analysis_config["Data"]):
 216         logging.fatal("Analysis source file does not exists ! :" + str(analysis_config["Data"]))
 217         sys.exit(1)
 218       try:
 219         analysis_file = open(analysis_config["Data"], 'r')
 220       except:
 221         logging.fatal("Exception in opening analysis file : " + str(analysis_config["Data"]))
 222         traceback.print_exc()
 223         sys.exit(1)
 224       file_text = analysis_file.read()
 225       final_script = default_script + file_text
 226       analysis_node.setScript(final_script)
 227       proc.edAddChild(analysis_node)
 228       proc.edAddCFLink(compute_bloc, analysis_node)
 229       if AlgoType[study_config["Algorithm"]] == "Optim":
 230         proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 231       else:
 232         proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 233
 234       pass
 235
 236   return proc
 237
 238 def write_yacs_proc(proc, yacs_schema_filename):
 239
 240   proc.saveSchema(yacs_schema_filename)
 241