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 0.5: Find if there is a user init node
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)
71 # Step 1: get input data from user configuration
73 for key in study_config.keys():
75 data_config = study_config[key]
77 key_type = key + "Type"
79 if data_config["Type"] == "Dict" and data_config["From"] == "Script":
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"))
94 if data_config["Type"] == "Vector" and data_config["From"] == "String":
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"))
110 if data_config["Type"] == "Vector" and data_config["From"] == "Script":
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"))
127 if data_config["Type"] == "Matrix" and data_config["From"] == "String":
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"))
143 if data_config["Type"] == "Matrix" and data_config["From"] == "Script":
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"))
160 if data_config["Type"] == "Function" and data_config["From"] == "Dict" 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])
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)
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"))
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())
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"] == "Dict":
192 FunctionDict = data_config["Data"]
194 for FunctionName in FunctionDict["Function"]:
195 # We currently support only one file
196 script_filename = FunctionDict["Script"][FunctionName]
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)
205 script_str= open(script_filename, 'r')
207 logging.fatal("Exception in opening function script file : " + script_filename)
208 traceback.print_exc()
210 opt_script_node.setScript(script_str.read())
211 opt_script_node.edAddInputPort("computation", t_pyobj)
212 opt_script_node.edAddOutputPort("result", t_pyobj)
215 computation_bloc = runtime.createBloc("computation_bloc")
216 optimizer_node.edSetNode(computation_bloc)
217 computation_bloc.edAddChild(opt_script_node)
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())
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"))
229 factory_opt_script_node = catalogAd._nodeMap["FakeOptimizerLoopNode"]
230 opt_script_node = factory_opt_script_node.cloneNode("FakeFunctionNode")
233 computation_bloc = runtime.createBloc("computation_bloc")
234 optimizer_node.edSetNode(computation_bloc)
235 computation_bloc.edAddChild(opt_script_node)
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())
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"))
255 proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
257 elif analysis_config["From"] == "File":
258 factory_analysis_node = catalogAd._nodeMap["SimpleUserAnalysis"]
259 analysis_node = factory_analysis_node.cloneNode("User Analysis")
260 default_script = analysis_node.getScript()
261 if not os.path.exists(analysis_config["Data"]):
262 logging.fatal("Analysis source file does not exists ! :" + str(analysis_config["Data"]))
265 analysis_file = open(analysis_config["Data"], 'r')
267 logging.fatal("Exception in opening analysis file : " + str(analysis_config["Data"]))
268 traceback.print_exc()
270 file_text = analysis_file.read()
271 final_script = default_script + file_text
272 analysis_node.setScript(final_script)
273 proc.edAddChild(analysis_node)
274 proc.edAddCFLink(compute_bloc, analysis_node)
275 if AlgoType[study_config["Algorithm"]] == "Optim":
276 proc.edAddDFLink(optimizer_node.edGetAlgoResultPort(), analysis_node.getInputPort("Study"))
278 proc.edAddDFLink(execute_node.getOutputPort("Study"), analysis_node.getInputPort("Study"))
284 def write_yacs_proc(proc, yacs_schema_filename):
286 proc.saveSchema(yacs_schema_filename)