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