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   # Create ADAO case bloc
  65   ADAO_Case = runtime.createBloc("ADAO_Case_Bloc")
  66   proc.edAddChild(ADAO_Case)
  67
  68   # Step 0: create AssimilationStudyObject
  69   factory_CAS_node = catalogAd.getNodeFromNodeMap("CreateAssimilationStudy")
  70   CAS_node = factory_CAS_node.cloneNode("CreateAssimilationStudy")
  71   CAS_node.getInputPort("Name").edInitPy(study_config["Name"])
  72   CAS_node.getInputPort("Algorithm").edInitPy(study_config["Algorithm"])
  73   if study_config["Debug"] == "0":
  74     CAS_node.getInputPort("Debug").edInitPy(False)
  75   else:
  76     CAS_node.getInputPort("Debug").edInitPy(True)
  77
  78   # Ajout des Variables
  79   InputVariablesNames = []
  80   InputVariablesSizes = []
  81   for var in study_config["InputVariables"]["Order"]:
  82     InputVariablesNames.append(var)
  83     InputVariablesSizes.append(int(study_config["InputVariables"][var]))
  84   CAS_node.getInputPort("InputVariablesNames").edInitPy(InputVariablesNames)
  85   CAS_node.getInputPort("InputVariablesSizes").edInitPy(InputVariablesSizes)
  86   OutputVariablesNames = []
  87   OutputVariablesSizes = []
  88   for var in study_config["OutputVariables"]["Order"]:
  89     OutputVariablesNames.append(var)
  90     OutputVariablesSizes.append(int(study_config["OutputVariables"][var]))
  91   CAS_node.getInputPort("OutputVariablesNames").edInitPy(OutputVariablesNames)
  92   CAS_node.getInputPort("OutputVariablesSizes").edInitPy(OutputVariablesSizes)
  93
  94   ADAO_Case.edAddChild(CAS_node)
  95
  96   # Adding an observer init node if an user defines some
  97   factory_init_observers_node = catalogAd.getNodeFromNodeMap("SetObserversNode")
  98   init_observers_node = factory_init_observers_node.cloneNode("SetObservers")
  99   if "Observers" in study_config.keys():
 100     node_script = init_observers_node.getScript()
 101     node_script += "has_observers = True\n"
 102     node_script += "observers = " + str(study_config["Observers"]) + "\n"
 103     init_observers_node.setScript(node_script)
 104     ADAO_Case.edAddChild(init_observers_node)
 105     ADAO_Case.edAddDFLink(init_observers_node.getOutputPort("has_observers"), CAS_node.getInputPort("has_observers"))
 106     ADAO_Case.edAddDFLink(init_observers_node.getOutputPort("observers"), CAS_node.getInputPort("observers"))
 107   else:
 108     node_script = init_observers_node.getScript()
 109     node_script += "has_observers = False\n"
 110     node_script += "observers = \"\"\n"
 111     init_observers_node.setScript(node_script)
 112     ADAO_Case.edAddChild(init_observers_node)
 113     ADAO_Case.edAddDFLink(init_observers_node.getOutputPort("has_observers"), CAS_node.getInputPort("has_observers"))
 114     ADAO_Case.edAddDFLink(init_observers_node.getOutputPort("observers"), CAS_node.getInputPort("observers"))
 115
 116   # Step 0.5: Find if there is a user init node
 117   init_config = {}
 118   init_config["Target"] = []
 119   if "UserDataInit" in study_config.keys():
 120     init_config = study_config["UserDataInit"]
 121     factory_init_node = catalogAd.getNodeFromNodeMap("UserDataInitFromScript")
 122     init_node = factory_init_node.cloneNode("UserDataInit")
 123     if repertory:
 124       init_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(init_config["Data"])))
 125     else:
 126       init_node.getInputPort("script").edInitPy(init_config["Data"])
 127     init_node_script = init_node.getScript()
 128     init_node_script += "init_data = user_script_module.init_data\n"
 129     init_node.setScript(init_node_script)
 130     ADAO_Case.edAddChild(init_node)
 131
 132   # Step 1: get input data from user configuration
 133
 134   for key in study_config.keys():
 135     if key in AssimData:
 136       data_config = study_config[key]
 137
 138       key_type = key + "Type"
 139
 140       if data_config["Type"] == "Dict" and data_config["From"] == "Script":
 141         # Create node
 142         factory_back_node = catalogAd.getNodeFromNodeMap("CreateDictFromScript")
 143         back_node = factory_back_node.cloneNode("Get" + key)
 144         if repertory:
 145           back_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(data_config["Data"])))
 146         else:
 147           back_node.getInputPort("script").edInitPy(data_config["Data"])
 148         back_node.edAddOutputPort(key, t_pyobj)
 149         back_node_script = back_node.getScript()
 150         back_node_script += key + " = user_script_module." + key + "\n"
 151         back_node.setScript(back_node_script)
 152         ADAO_Case.edAddChild(back_node)
 153         # Connect node with CreateAssimilationStudy
 154         CAS_node.edAddInputPort(key, t_pyobj)
 155         ADAO_Case.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 156         # Connect node with InitUserData
 157         if key in init_config["Target"]:
 158           back_node_script = back_node.getScript()
 159           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 160           back_node.setScript(back_node_script)
 161           back_node.edAddInputPort("init_data", t_pyobj)
 162           ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 163
 164       if data_config["Type"] == "Vector" and data_config["From"] == "String":
 165         # Create node
 166         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyVectorFromString")
 167         back_node = factory_back_node.cloneNode("Get" + key)
 168         back_node.getInputPort("vector_in_string").edInitPy(data_config["Data"])
 169         ADAO_Case.edAddChild(back_node)
 170         # Connect node with CreateAssimilationStudy
 171         CAS_node.edAddInputPort(key, t_pyobj)
 172         CAS_node.edAddInputPort(key_type, t_string)
 173         ADAO_Case.edAddDFLink(back_node.getOutputPort("vector"), CAS_node.getInputPort(key))
 174         ADAO_Case.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 175         # Connect node with InitUserData
 176         if key in init_config["Target"]:
 177           back_node_script = back_node.getScript()
 178           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 179           back_node.setScript(back_node_script)
 180           back_node.edAddInputPort("init_data", t_pyobj)
 181           ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 182
 183       if data_config["Type"] == "Vector" and data_config["From"] == "Script":
 184         # Create node
 185         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyVectorFromScript")
 186         back_node = factory_back_node.cloneNode("Get" + key)
 187         if repertory:
 188           back_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(data_config["Data"])))
 189         else:
 190           back_node.getInputPort("script").edInitPy(data_config["Data"])
 191         back_node.edAddOutputPort(key, t_pyobj)
 192         back_node_script = back_node.getScript()
 193         back_node_script += key + " = user_script_module." + key + "\n"
 194         back_node.setScript(back_node_script)
 195         ADAO_Case.edAddChild(back_node)
 196         # Connect node with CreateAssimilationStudy
 197         CAS_node.edAddInputPort(key, t_pyobj)
 198         CAS_node.edAddInputPort(key_type, t_string)
 199         ADAO_Case.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 200         ADAO_Case.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 201         # Connect node with InitUserData
 202         if key in init_config["Target"]:
 203           back_node_script = back_node.getScript()
 204           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 205           back_node.setScript(back_node_script)
 206           back_node.edAddInputPort("init_data", t_pyobj)
 207           ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 208
 209       if data_config["Type"] == "Matrix" and data_config["From"] == "String":
 210         # Create node
 211         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyMatrixFromString")
 212         back_node = factory_back_node.cloneNode("Get" + key)
 213         back_node.getInputPort("matrix_in_string").edInitPy(data_config["Data"])
 214         ADAO_Case.edAddChild(back_node)
 215         # Connect node with CreateAssimilationStudy
 216         CAS_node.edAddInputPort(key, t_pyobj)
 217         CAS_node.edAddInputPort(key_type, t_string)
 218         ADAO_Case.edAddDFLink(back_node.getOutputPort("matrix"), CAS_node.getInputPort(key))
 219         ADAO_Case.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 220         # Connect node with InitUserData
 221         if key in init_config["Target"]:
 222           back_node_script = back_node.getScript()
 223           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 224           back_node.setScript(back_node_script)
 225           back_node.edAddInputPort("init_data", t_pyobj)
 226           ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 227
 228       if data_config["Type"] == "Matrix" and data_config["From"] == "Script":
 229         # Create node
 230         factory_back_node = catalogAd.getNodeFromNodeMap("CreateNumpyMatrixFromScript")
 231         back_node = factory_back_node.cloneNode("Get" + key)
 232         if repertory:
 233           back_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(data_config["Data"])))
 234         else:
 235           back_node.getInputPort("script").edInitPy(data_config["Data"])
 236         back_node.edAddOutputPort(key, t_pyobj)
 237         back_node_script = back_node.getScript()
 238         back_node_script += key + " = user_script_module." + key + "\n"
 239         back_node.setScript(back_node_script)
 240         ADAO_Case.edAddChild(back_node)
 241         # Connect node with CreateAssimilationStudy
 242         CAS_node.edAddInputPort(key, t_pyobj)
 243         CAS_node.edAddInputPort(key_type, t_string)
 244         ADAO_Case.edAddDFLink(back_node.getOutputPort(key), CAS_node.getInputPort(key))
 245         ADAO_Case.edAddDFLink(back_node.getOutputPort("type"), CAS_node.getInputPort(key_type))
 246         # Connect node with InitUserData
 247         if key in init_config["Target"]:
 248           back_node_script = back_node.getScript()
 249           back_node_script = "__builtins__[\"init_data\"] = init_data\n" + back_node_script
 250           back_node.setScript(back_node_script)
 251           back_node.edAddInputPort("init_data", t_pyobj)
 252           ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), back_node.getInputPort("init_data"))
 253
 254       if data_config["Type"] == "Function" and data_config["From"] == "FunctionDict" and key == "ObservationOperator":
 255          FunctionDict = data_config["Data"]
 256          for FunctionName in FunctionDict["Function"]:
 257            port_name = "ObservationOperator" + FunctionName
 258            CAS_node.edAddInputPort(port_name, t_string)
 259            if repertory:
 260              CAS_node.getInputPort(port_name).edInitPy(os.path.join(base_repertory, os.path.basename(FunctionDict["Script"][FunctionName])))
 261            else:
 262              CAS_node.getInputPort(port_name).edInitPy(FunctionDict["Script"][FunctionName])
 263
 264   # Step 3: create compute bloc
 265   compute_bloc = runtime.createBloc("compute_bloc")
 266   ADAO_Case.edAddChild(compute_bloc)
 267   ADAO_Case.edAddCFLink(CAS_node, compute_bloc)
 268   # We use an optimizer loop
 269   name = "Execute" + study_config["Algorithm"]
 270   algLib = "daYacsIntegration.py"
 271   factoryName = "AssimilationAlgorithm_asynch"
 272   optimizer_node = runtime.createOptimizerLoop(name, algLib, factoryName, "")
 273   compute_bloc.edAddChild(optimizer_node)
 274   ADAO_Case.edAddDFLink(CAS_node.getOutputPort("Study"), optimizer_node.edGetAlgoInitPort())
 275   # Check if we have a python script for OptimizerLoopNode
 276   data_config = study_config["ObservationOperator"]
 277   opt_script_node = None
 278   if data_config["Type"] == "Function" and data_config["From"] == "FunctionDict":
 279     # Get script
 280     FunctionDict = data_config["Data"]
 281     script_filename = ""
 282     for FunctionName in FunctionDict["Function"]:
 283       # We currently support only one file
 284       script_filename = FunctionDict["Script"][FunctionName]
 285       break
 286
 287     # We create a new pyscript node
 288     opt_script_node = runtime.createScriptNode("", "FunctionNode")
 289     if repertory:
 290       script_filename = os.path.join(base_repertory, os.path.basename(script_filename))
 291     try:
 292       script_str= open(script_filename, 'r')
 293     except:
 294       logging.fatal("Exception in opening function script file : " + script_filename)
 295       traceback.print_exc()
 296       sys.exit(1)
 297     node_script  = "#-*-coding:iso-8859-1-*-\n"
 298     node_script += "import sys, os \n"
 299     if base_repertory != "":
 300       node_script += "filepath = \"" + base_repertory + "\"\n"
 301     else:
 302       node_script += "filepath = \"" + os.path.dirname(script_filename) + "\"\n"
 303     node_script += "sys.path.insert(0,os.path.dirname(filepath))\n"
 304     node_script += script_str.read()
 305     opt_script_node.setScript(node_script)
 306     opt_script_node.edAddInputPort("computation", t_param_input)
 307     opt_script_node.edAddOutputPort("result", t_param_output)
 308   else:
 309     factory_opt_script_node = catalogAd.getNodeFromNodeMap("FakeOptimizerLoopNode")
 310     opt_script_node = factory_opt_script_node.cloneNode("FakeFunctionNode")
 311
 312   # Add computation bloc
 313   if "Observers" in study_config.keys():
 314     execution_bloc = runtime.createBloc("Execution Bloc")
 315     optimizer_node.edSetNode(execution_bloc)
 316
 317     # Add a node that permits to configure the switch
 318     factory_read_for_switch_node = catalogAd.getNodeFromNodeMap("ReadForSwitchNode")
 319     read_for_switch_node = factory_read_for_switch_node.cloneNode("ReadForSwitch")
 320     execution_bloc.edAddChild(read_for_switch_node)
 321     ADAO_Case.edAddDFLink(optimizer_node.edGetSamplePort(), read_for_switch_node.getInputPort("data"))
 322
 323     # Add a switch
 324     switch_node = runtime.createSwitch("Execution Switch")
 325     execution_bloc.edAddChild(switch_node)
 326     # Connect switch
 327     ADAO_Case.edAddDFLink(read_for_switch_node.getOutputPort("switch_value"), switch_node.edGetConditionPort())
 328
 329     # First case: always computation bloc
 330     computation_bloc = runtime.createBloc("computation_bloc")
 331     computation_bloc.edAddChild(opt_script_node)
 332     switch_node.edSetNode(1, computation_bloc)
 333
 334     # We connect Optimizer with the script
 335     ADAO_Case.edAddDFLink(read_for_switch_node.getOutputPort("data"), opt_script_node.getInputPort("computation"))
 336     ADAO_Case.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 337
 338
 339     # For each observer add a new bloc in the switch
 340     observer_config = study_config["Observers"]
 341     for observer_name in observer_config:
 342       observer_cfg = observer_config[observer_name]
 343       observer_bloc = runtime.createBloc("Observer %s" % observer_name)
 344       switch_node.edSetNode(observer_cfg["number"], observer_bloc)
 345
 346       factory_extract_data_node = catalogAd.getNodeFromNodeMap("ExtractDataNode")
 347       extract_data_node = factory_extract_data_node.cloneNode("ExtractData")
 348       observer_bloc.edAddChild(extract_data_node)
 349       ADAO_Case.edAddDFLink(read_for_switch_node.getOutputPort("data"), extract_data_node.getInputPort("data"))
 350
 351       observation_node = None
 352       if observer_cfg["nodetype"] == "String":
 353         factory_observation_node = catalogAd.getNodeFromNodeMap("ObservationNodeString")
 354         observation_node = factory_observation_node.cloneNode("Observation")
 355         node_script = observation_node.getScript()
 356         node_script += observer_cfg["String"]
 357         observation_node.setScript(node_script)
 358       else:
 359         factory_observation_node = catalogAd.getNodeFromNodeMap("ObservationNodeFile")
 360         observation_node = factory_observation_node.cloneNode("Observation")
 361         if repertory:
 362           observation_node.getInputPort("script").edInitPy(os.path.join(base_repertory, os.path.basename(observer_cfg["Script"])))
 363         else:
 364           observation_node.getInputPort("script").edInitPy(observer_cfg["Script"])
 365       observer_bloc.edAddChild(observation_node)
 366       ADAO_Case.edAddDFLink(extract_data_node.getOutputPort("var"), observation_node.getInputPort("var"))
 367       ADAO_Case.edAddDFLink(extract_data_node.getOutputPort("info"), observation_node.getInputPort("info"))
 368
 369       factory_end_observation_node = catalogAd.getNodeFromNodeMap("EndObservationNode")
 370       end_observation_node = factory_end_observation_node.cloneNode("EndObservation")
 371       observer_bloc.edAddChild(end_observation_node)
 372       ADAO_Case.edAddCFLink(observation_node, end_observation_node)
 373       ADAO_Case.edAddDFLink(end_observation_node.getOutputPort("output"), optimizer_node.edGetPortForOutPool())
 374   else:
 375     computation_bloc = runtime.createBloc("computation_bloc")
 376     optimizer_node.edSetNode(computation_bloc)
 377     computation_bloc.edAddChild(opt_script_node)
 378
 379     # We connect Optimizer with the script
 380     ADAO_Case.edAddDFLink(optimizer_node.edGetSamplePort(), opt_script_node.getInputPort("computation"))
 381     ADAO_Case.edAddDFLink(opt_script_node.getOutputPort("result"), optimizer_node.edGetPortForOutPool())
 382
 383   # Connect node with InitUserData
 384   if "ObservationOperator" in init_config["Target"]:
 385     opt_node_script = opt_script_node.getScript()
 386     opt_node_script = "__builtins__[\"init_data\"] = init_data\n" + opt_node_script
 387     opt_script_node.setScript(opt_node_script)
 388     opt_script_node.edAddInputPort("init_data", t_pyobj)
 389     ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), opt_script_node.getInputPort("init_data"))
 390
 391   # Step 4: create post-processing from user configuration
 392   if "UserPostAnalysis" in study_config.keys():
 393     analysis_config = study_config["UserPostAnalysis"]
 394     if analysis_config["From"] == "String":
 395       factory_analysis_node = catalogAd.getNodeFromNodeMap("SimpleUserAnalysis")
 396       analysis_node = factory_analysis_node.cloneNode("UsePostAnalysis")
 397       default_script = analysis_node.getScript()
 398       final_script = default_script + analysis_config["Data"]
 399       analysis_node.setScript(final_script)
 400       ADAO_Case.edAddChild(analysis_node)
 401       ADAO_Case.edAddCFLink(compute_bloc, analysis_node)
 402       if AlgoType[study_config["Algorithm"]] == "Optim":
 403         ADAO_Case.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 404       else:
 405         ADAO_Case.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 406
 407       # Connect node with InitUserData
 408       if "UserPostAnalysis" in init_config["Target"]:
 409         node_script = analysis_node.getScript()
 410         node_script = "__builtins__[\"init_data\"] = init_data\n" + node_script
 411         analysis_node.setScript(node_script)
 412         analysis_node.edAddInputPort("init_data", t_pyobj)
 413         ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), analysis_node.getInputPort("init_data"))
 414
 415     elif analysis_config["From"] == "Script":
 416       factory_analysis_node = catalogAd.getNodeFromNodeMap("SimpleUserAnalysis")
 417       analysis_node = factory_analysis_node.cloneNode("UserPostAnalysis")
 418       default_script = analysis_node.getScript()
 419       analysis_file_name = analysis_config["Data"]
 420       if repertory:
 421         analysis_file_name = os.path.join(base_repertory, os.path.basename(analysis_file_name))
 422       try:
 423         analysis_file = open(analysis_file_name, 'r')
 424       except:
 425         logging.fatal("Exception in opening analysis file : " + str(analysis_config["Data"]))
 426         traceback.print_exc()
 427         sys.exit(1)
 428       node_script  = "#-*-coding:iso-8859-1-*-\n"
 429       node_script += "import sys, os \n"
 430       if base_repertory != "":
 431         node_script += "filepath = \"" + base_repertory + "\"\n"
 432       else:
 433         node_script += "filepath = \"" + os.path.dirname(script_filename) + "\"\n"
 434       node_script += "sys.path.insert(0,os.path.dirname(filepath))\n"
 435       node_script += default_script
 436       node_script += analysis_file.read()
 437       analysis_node.setScript(node_script)
 438       ADAO_Case.edAddChild(analysis_node)
 439       ADAO_Case.edAddCFLink(compute_bloc, analysis_node)
 440       if AlgoType[study_config["Algorithm"]] == "Optim":
 441         ADAO_Case.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
 442       else:
 443         ADAO_Case.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
 444       # Connect node with InitUserData
 445       if "UserPostAnalysis" in init_config["Target"]:
 446         node_script = analysis_node.getScript()
 447         node_script = "__builtins__[\"init_data\"] = init_data\n" + node_script
 448         analysis_node.setScript(node_script)
 449         analysis_node.edAddInputPort("init_data", t_pyobj)
 450         ADAO_Case.edAddDFLink(init_node.getOutputPort("init_data"), analysis_node.getInputPort("init_data"))
 451
 452       pass
 453
 454   return proc
 455
 456 def write_yacs_proc(proc, yacs_schema_filename):
 457
 458   proc.saveSchema(yacs_schema_filename)
 459