1 #-*-coding:iso-8859-1-*-
2 # Copyright (C) 2010 EDF R&D
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.
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.
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
19 # Author : André RIBES (EDF R&D)
30 from daYacsSchemaCreator.infos_daComposant import *
32 def create_yacs_proc(study_config):
34 logging.debug("[create_yacs_proc]")
37 SALOMERuntime.RuntimeSALOME_setRuntime()
38 l = loader.YACSLoader()
39 l.registerProcCataLoader()
40 runtime = pilot.getRuntime()
42 catalogAd = runtime.loadCatalog("proc", os.environ["ADAO_ROOT_DIR"] + "/share/salome/resources/adao/ADAOSchemaCatalog.xml")
44 logging.fatal("Exception in loading DataAssim YACS catalog")
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")
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)
61 # Step 1: get input data from user configuration
63 for key in study_config.keys():
65 data_config = study_config[key]
67 key_type = key + "Type"
69 if data_config["Type"] == "Vector" and data_config["From"] == "String":
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))
81 if data_config["Type"] == "Vector" and data_config["From"] == "Script":
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))
94 if data_config["Type"] == "Matrix" and data_config["From"] == "String":
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))
106 if data_config["Type"] == "Matrix" and data_config["From"] == "Script":
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))
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])
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)
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"))
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())
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":
151 FunctionDict = data_config["Data"]
153 for FunctionName in FunctionDict["Function"]:
154 # We currently support only one file
155 script_filename = FunctionDict["Script"][FunctionName]
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)
164 script_str= open(script_filename, 'r')
166 logging.fatal("Exception in opening function script file : " + script_filename)
167 traceback.print_exc()
169 opt_script_node.setScript(script_str.read())
170 opt_script_node.edAddInputPort("computation", t_pyobj)
171 opt_script_node.edAddOutputPort("result", t_pyobj)
174 computation_bloc = runtime.createBloc("computation_bloc")
175 optimizer_node.edSetNode(computation_bloc)
176 computation_bloc.edAddChild(opt_script_node)
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())
183 logging.fatal("Fake optim script node currently not implemented")
186 # Step 4: create post-processing from user configuration
187 if "Analysis" in study_config.keys():
188 analysis_config = study_config["Analysis"]
189 if analysis_config["From"] == "String":
190 factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
191 analysis_node = factory_analysis_node.cloneNode("User Analysis")
192 default_script = analysis_node.getScript()
193 final_script = default_script + analysis_config["Data"]
194 analysis_node.setScript(final_script)
195 proc.edAddChild(analysis_node)
196 proc.edAddCFLink(compute_bloc, analysis_node)
197 if AlgoType[study_config["Algorithm"]] == "Optim":
198 proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
200 proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
202 elif analysis_config["From"] == "File":
203 factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
204 analysis_node = factory_analysis_node.cloneNode("User Analysis")
205 default_script = analysis_node.getScript()
206 if not os.path.exists(analysis_config["Data"]):
207 logging.fatal("Analysis source file does not exists ! :" + str(analysis_config["Data"]))
210 analysis_file = open(analysis_config["Data"], 'r')
212 logging.fatal("Exception in opening analysis file : " + str(analysis_config["Data"]))
213 traceback.print_exc()
215 file_text = analysis_file.read()
216 final_script = default_script + file_text
217 analysis_node.setScript(final_script)
218 proc.edAddChild(analysis_node)
219 proc.edAddCFLink(compute_bloc, analysis_node)
220 if AlgoType[study_config["Algorithm"]] == "Optim":
221 proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
223 proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
229 def write_yacs_proc(proc, yacs_schema_filename):
231 proc.saveSchema(yacs_schema_filename)