1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2018 EDF R&D
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU Lesser General Public
7 # License as published by the Free Software Foundation; either
8 # version 2.1 of the License.
10 # This library is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 # Lesser General Public License for more details.
15 # You should have received a copy of the GNU Lesser General Public
16 # License along with this library; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 Définit les outils d'interfaces normalisées de cas.
26 __author__ = "Jean-Philippe ARGAUD"
34 from daCore import Persistence
35 from daCore import PlatformInfo
36 from daCore import Templates
38 # ==============================================================================
39 class GenericCaseViewer(object):
41 Gestion des commandes de creation d'une vue de cas
43 def __init__(self, __name="", __objname="case", __content=None, __object=None):
44 "Initialisation et enregistrement de l'entete"
45 self._name = str(__name)
46 self._objname = str(__objname)
48 self._switchoff = False
49 self._numobservers = 2
50 self._content = __content
51 self._object = __object
52 self._missing = """raise ValueError("This case requires beforehand to import or define the variable named <%s>. When corrected, remove this command, correct and uncomment the following one.")\n# """
53 def _append(self, *args):
54 "Transformation de commande individuelle en enregistrement"
55 raise NotImplementedError()
56 def _extract(self, *args):
57 "Transformation d'enregistrement en commande individuelle"
58 raise NotImplementedError()
59 def _finalize(self, __upa=None):
60 "Enregistrement du final"
61 if __upa is not None and len(__upa)>0:
62 self._lineSerie.append("%s.execute()"%(self._objname,))
63 self._lineSerie.append(__upa)
64 def _addLine(self, line=""):
65 "Ajoute un enregistrement individuel"
66 self._lineSerie.append(line)
67 def _get_objname(self):
69 def dump(self, __filename=None, __upa=None):
70 "Restitution normalisée des commandes"
72 __text = "\n".join(self._lineSerie)
74 if __filename is not None:
75 __file = os.path.abspath(__filename)
76 __fid = open(__file,"w")
80 def load(self, __filename=None, __content=None, __object=None):
81 "Chargement normalisé des commandes"
82 if __filename is not None and os.path.exists(__filename):
83 self._content = open(__filename, 'r').read()
84 elif __content is not None and type(__content) is str:
85 self._content = __content
86 elif __object is not None and type(__object) is dict:
87 self._object = copy.deepcopy(__object)
89 pass # use "self._content" from initialization
90 __commands = self._extract(self._content, self._object)
93 class _TUIViewer(GenericCaseViewer):
95 Etablissement des commandes d'un cas ADAO TUI (Cas<->TUI)
97 def __init__(self, __name="", __objname="case", __content=None, __object=None):
98 "Initialisation et enregistrement de l'entete"
99 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
100 self._addLine("# -*- coding: utf-8 -*-")
101 self._addLine("#\n# Python script using ADAO TUI\n#")
102 self._addLine("from numpy import array, matrix")
103 self._addLine("import adaoBuilder")
104 self._addLine("%s = adaoBuilder.New('%s')"%(self._objname, self._name))
105 if self._content is not None:
106 for command in self._content:
107 self._append(*command)
108 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
109 "Transformation d'une commande individuelle en un enregistrement"
110 if __command is not None and __keys is not None and __local is not None:
112 if __pre is not None:
113 __text += "%s = "%__pre
114 __text += "%s.%s( "%(self._objname,str(__command))
115 if "self" in __keys: __keys.remove("self")
116 if __command not in ("set","get") and "Concept" in __keys: __keys.remove("Concept")
119 if __v is None: continue
120 if k == "Checked" and not __v: continue
121 if k == "Stored" and not __v: continue
122 if k == "AvoidRC" and __v: continue
123 if k == "noDetails": continue
124 if isinstance(__v,Persistence.Persistence): __v = __v.values()
125 if callable(__v): __text = self._missing%__v.__name__+__text
126 if isinstance(__v,dict):
127 for val in __v.values():
128 if callable(val): __text = self._missing%val.__name__+__text
129 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
130 __text += "%s=%s, "%(k,repr(__v))
131 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
134 self._addLine(__text)
135 def _extract(self, __multilines="", __object=None):
136 "Transformation un enregistrement en une commande individuelle"
139 __multilines = __multilines.replace("\r\n","\n")
140 for line in __multilines.split("\n"):
141 if "adaoBuilder.New" in line and "=" in line:
142 self._objname = line.split("=")[0].strip()
144 logging.debug("TUI Extracting commands of '%s' object..."%(self._objname,))
148 if self._objname+".set" in line:
149 __commands.append( line.replace(self._objname+".","",1) )
150 logging.debug("TUI Extracted command: %s"%(__commands[-1],))
153 class _EPDViewer(GenericCaseViewer):
155 Etablissement des commandes d'un cas EPD (Eficas Python Dictionnary/Cas<-EPD)
157 def __init__(self, __name="", __objname="case", __content=None, __object=None):
158 "Initialisation et enregistrement de l'entete"
159 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
160 self._observerIndex = 0
161 self._addLine("# -*- coding: utf-8 -*-")
162 self._addLine("#\n# Python script using ADAO EPD\n#")
163 self._addLine("from numpy import array, matrix")
165 self._addLine("%s = {}"%__objname)
166 if self._content is not None:
167 for command in self._content:
168 self._append(*command)
169 def _extract(self, __multilines=None, __object=None):
170 "Transformation un enregistrement en une commande individuelle"
171 if __multilines is not None:
172 __multilines = __multilines.replace("\r\n","\n")
175 __getlocals = locals()
176 for k in __getlocals:
178 if type(__getlocals[k]) is dict:
179 if 'ASSIMILATION_STUDY' in __getlocals[k]:
181 self._objdata = __getlocals[k]['ASSIMILATION_STUDY']
182 if 'CHECKING_STUDY' in __getlocals[k]:
184 self._objdata = __getlocals[k]['CHECKING_STUDY']
187 elif __multilines is None and __object is not None and type(__object) is dict:
188 self._objname = "case"
190 if 'ASSIMILATION_STUDY' in __object:
191 self._objdata = __object['ASSIMILATION_STUDY']
192 if 'CHECKING_STUDY' in __object:
193 self._objdata = __object['CHECKING_STUDY']
197 if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata):
198 raise ValueError("Impossible to load given content as an ADAO EPD one (no dictionnary or no 'AlgorithmParameters' key found).")
199 # ----------------------------------------------------------------------
200 logging.debug("EPD Extracting commands of '%s' object..."%(self._objname,))
202 __UserPostAnalysis = ""
203 for k,r in self._objdata.items():
205 logging.debug("EPD Extracted command: %s:%s"%(k, r))
206 if __command == "StudyName" and len(str(r))>0:
207 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
208 elif __command == "StudyRepertory":
209 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
211 elif __command == "UserPostAnalysis" and type(r) is dict:
212 if 'STRING_DATA' in r:
213 __UserPostAnalysis = r['STRING_DATA']['STRING']
214 elif 'SCRIPT_DATA' in r and os.path.exists(r['SCRIPT_DATA']['SCRIPT_FILE']):
215 __UserPostAnalysis = open(r['SCRIPT_DATA']['SCRIPT_FILE'],'r').read()
216 elif 'TEMPLATE_DATA' in r:
218 __itempl = r['TEMPLATE_DATA']['Template']
219 __UserPostAnalysis = r['TEMPLATE_DATA'][__itempl]['ValueTemplate']
221 __UserPostAnalysis = ""
222 __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname)
224 elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
225 if 'Parameters%s'%(r['Algorithm'],) in r and r['Parameters'] == 'Defaults':
226 __Dict = r['Parameters%s'%(r['Algorithm'],)]
227 if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed'])
228 if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
229 __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
230 __parameters = ', Parameters=%s'%(repr(__Dict),)
231 elif 'Dict' in r and r['Parameters'] == 'Dict':
232 __from = r['Dict']['data']
233 if 'STRING_DATA' in __from:
234 __parameters = ", Parameters=%s"%(repr(eval(__from['STRING_DATA']['STRING'])),)
235 elif 'SCRIPT_DATA' in __from and os.path.exists(__from['SCRIPT_DATA']['SCRIPT_FILE']):
236 __parameters = ", Script='%s'"%(__from['SCRIPT_DATA']['SCRIPT_FILE'],)
239 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
241 elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
242 if type(r['SELECTION']) is str:
243 __selection = (r['SELECTION'],)
245 __selection = tuple(r['SELECTION'])
246 for sk in __selection:
247 __idata = r[sk]['%s_data'%sk]
248 if __idata['NodeType'] == 'Template' and 'Template' in __idata['ObserverTemplate']:
249 __template =__idata['ObserverTemplate']['Template']
250 __commands.append( "set( Concept='Observer', Variable='%s', Template='%s' )"%(sk,__template) )
251 if __idata['NodeType'] == 'String' and 'Value' in __idata:
252 __value =__idata['Value']
253 __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) )
255 # Background, ObservationError, ObservationOperator...
256 elif type(r) is dict:
258 if 'Stored' in r and bool(r['Stored']):
259 __argumentsList.append(['Stored',True])
260 if 'INPUT_TYPE' in r and r['INPUT_TYPE'] in r:
261 # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
262 __itype = r['INPUT_TYPE']
263 __idata = r[__itype]['data']
264 if 'FROM' in __idata and __idata['FROM'].upper()+'_DATA' in __idata:
265 # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions
266 __ifrom = __idata['FROM']
267 if __ifrom == 'String' or __ifrom == 'Template':
268 __argumentsList.append([__itype,__idata['STRING_DATA']['STRING']])
269 if __ifrom == 'Script':
270 __argumentsList.append([__itype,True])
271 __argumentsList.append(['Script',__idata['SCRIPT_DATA']['SCRIPT_FILE']])
272 if __ifrom == 'ScriptWithOneFunction':
273 __argumentsList.append(['OneFunction',True])
274 __argumentsList.append(['Script',__idata['SCRIPTWITHONEFUNCTION_DATA'].pop('SCRIPTWITHONEFUNCTION_FILE')])
275 if len(__idata['SCRIPTWITHONEFUNCTION_DATA'])>0:
276 __argumentsList.append(['Parameters',__idata['SCRIPTWITHONEFUNCTION_DATA']])
277 if __ifrom == 'ScriptWithFunctions':
278 __argumentsList.append(['ThreeFunctions',True])
279 __argumentsList.append(['Script',__idata['SCRIPTWITHFUNCTIONS_DATA'].pop('SCRIPTWITHFUNCTIONS_FILE')])
280 if len(__idata['SCRIPTWITHFUNCTIONS_DATA'])>0:
281 __argumentsList.append(['Parameters',__idata['SCRIPTWITHFUNCTIONS_DATA']])
282 __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList]
283 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
285 # ----------------------------------------------------------------------
286 __commands.sort() # Pour commencer par 'AlgorithmParameters'
287 __commands.append(__UserPostAnalysis)
290 class _COMViewer(GenericCaseViewer):
292 Etablissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM)
294 def __init__(self, __name="", __objname="case", __content=None, __object=None):
295 "Initialisation et enregistrement de l'entete"
296 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
297 self._observerIndex = 0
298 self._addLine("# -*- coding: utf-8 -*-")
299 self._addLine("#\n# Python script using ADAO COMM\n#")
300 self._addLine("from numpy import array, matrix")
302 self._addLine("%s = {}"%__objname)
303 if self._content is not None:
304 for command in self._content:
305 self._append(*command)
306 def _extract(self, __multilines=None, __object=None):
307 "Transformation un enregistrement en une commande individuelle"
308 if __multilines is not None:
309 __multilines = __multilines.replace("ASSIMILATION_STUDY","dict")
310 __multilines = __multilines.replace("CHECKING_STUDY", "dict")
311 __multilines = __multilines.replace("_F(", "dict(")
312 __multilines = __multilines.replace(",),);", ",),)")
313 self._objname = "case"
315 exec("self._objdata = "+__multilines)
317 if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata):
318 raise ValueError("Impossible to load given content as an ADAO COMM one (no dictionnary or no 'AlgorithmParameters' key found).")
319 # ----------------------------------------------------------------------
320 logging.debug("COMM Extracting commands of '%s' object..."%(self._objname,))
322 __UserPostAnalysis = ""
323 for k,r in self._objdata.items():
325 logging.debug("COMM Extracted command: %s:%s"%(k, r))
326 if __command == "StudyName" and len(str(r))>0:
327 __commands.append( "set( Concept='Name', String='%s')"%(str(r),) )
328 elif __command == "StudyRepertory":
329 __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) )
331 elif __command == "UserPostAnalysis" and type(r) is dict:
333 __UserPostAnalysis = r['STRING']
334 elif 'SCRIPT_FILE' in r and os.path.exists(r['SCRIPT_FILE']):
335 __UserPostAnalysis = open(r['SCRIPT_FILE'],'r').read()
336 elif 'Template' in r and 'ValueTemplate' in r:
338 __UserPostAnalysis = r['ValueTemplate']
340 __UserPostAnalysis = ""
341 __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname)
343 elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r:
344 if 'Parameters' in r and r['Parameters'] == 'Defaults':
345 __Dict = copy.deepcopy(r)
346 __Dict.pop('Algorithm')
347 if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed'])
348 if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str:
349 __Dict['BoxBounds'] = eval(__Dict['BoxBounds'])
350 __parameters = ', Parameters=%s'%(repr(__Dict),)
351 elif 'data' in r and r['Parameters'] == 'Dict':
353 if 'STRING' in __from:
354 __parameters = ", Parameters=%s"%(repr(eval(__from['STRING'])),)
355 elif 'SCRIPT_FILE' in __from and os.path.exists(__from['SCRIPT_FILE']):
356 __parameters = ", Script='%s'"%(__from['SCRIPT_FILE'],)
359 __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) )
361 elif __command == "Observers" and type(r) is dict and 'SELECTION' in r:
362 if type(r['SELECTION']) is str:
363 __selection = (r['SELECTION'],)
365 __selection = tuple(r['SELECTION'])
366 for sk in __selection:
367 __idata = r['%s_data'%sk]
368 if __idata['NodeType'] == 'Template' and 'Template' in __idata:
369 __template = __idata['Template']
370 if 'Info' in __idata:
371 __info = ", Info='%s'"%(__idata['Info'],)
374 __commands.append( "set( Concept='Observer', Variable='%s', Template='%s'%s )"%(sk,__template,__info) )
375 if __idata['NodeType'] == 'String' and 'Value' in __idata:
376 __value =__idata['Value']
377 __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) )
379 # Background, ObservationError, ObservationOperator...
380 elif type(r) is dict:
382 if 'Stored' in r and bool(r['Stored']):
383 __argumentsList.append(['Stored',True])
384 if 'INPUT_TYPE' in r and 'data' in r:
385 # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function
386 __itype = r['INPUT_TYPE']
388 if 'FROM' in __idata:
389 # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions
390 __ifrom = __idata['FROM']
391 if __ifrom == 'String' or __ifrom == 'Template':
392 __argumentsList.append([__itype,__idata['STRING']])
393 if __ifrom == 'Script':
394 __argumentsList.append([__itype,True])
395 __argumentsList.append(['Script',__idata['SCRIPT_FILE']])
396 if __ifrom == 'ScriptWithOneFunction':
397 __argumentsList.append(['OneFunction',True])
398 __argumentsList.append(['Script',__idata.pop('SCRIPTWITHONEFUNCTION_FILE')])
400 __argumentsList.append(['Parameters',__idata])
401 if __ifrom == 'ScriptWithFunctions':
402 __argumentsList.append(['ThreeFunctions',True])
403 __argumentsList.append(['Script',__idata.pop('SCRIPTWITHFUNCTIONS_FILE')])
405 __argumentsList.append(['Parameters',__idata])
406 __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList]
407 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
409 # ----------------------------------------------------------------------
410 __commands.sort() # Pour commencer par 'AlgorithmParameters'
411 __commands.append(__UserPostAnalysis)
414 class _DCTViewer(GenericCaseViewer):
416 Etablissement des commandes d'un cas DCT (Cas<->DCT)
418 def __init__(self, __name="", __objname="case", __content=None, __object=None):
419 "Initialisation et enregistrement de l'entete"
420 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
421 self._observerIndex = 0
422 self._addLine("# -*- coding: utf-8 -*-")
423 self._addLine("#\n# Python script using ADAO DCT\n#")
424 self._addLine("from numpy import array, matrix")
426 self._addLine("%s = {}"%__objname)
427 if self._content is not None:
428 for command in self._content:
429 self._append(*command)
430 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
431 "Transformation d'une commande individuelle en un enregistrement"
432 if __command is not None and __keys is not None and __local is not None:
434 if "execute" in __command: return
435 if "self" in __keys: __keys.remove("self")
436 if __command in ("set","get") and "Concept" in __keys:
437 __key = __local["Concept"]
438 __keys.remove("Concept")
440 __key = __command.replace("set","").replace("get","")
441 if "Observer" in __key and 'Variable' in __keys:
442 self._observerIndex += 1
443 __key += "_%i"%self._observerIndex
444 __text += "%s['%s'] = {"%(self._objname,str(__key))
447 if __v is None: continue
448 if k == "Checked" and not __v: continue
449 if k == "Stored" and not __v: continue
450 if k == "AvoidRC" and __v: continue
451 if k == "noDetails": continue
452 if isinstance(__v,Persistence.Persistence): __v = __v.values()
453 if callable(__v): __text = self._missing%__v.__name__+__text
454 if isinstance(__v,dict):
455 for val in __v.values():
456 if callable(val): __text = self._missing%val.__name__+__text
457 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
458 __text += "'%s':%s, "%(k,repr(__v))
459 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
460 __text.rstrip(", ").rstrip()
462 if __text[-2:] == "{}": return # Supprime les *Debug et les variables
463 self._addLine(__text)
464 def _extract(self, __multilines="", __object=None):
465 "Transformation un enregistrement en une commande individuelle"
466 __multilines = __multilines.replace("\r\n","\n")
469 __getlocals = locals()
470 for k in __getlocals:
472 if 'AlgorithmParameters' in __getlocals[k] and type(__getlocals[k]) is dict:
474 self._objdata = __getlocals[k]
477 if self._objdata is None:
478 raise ValueError("Impossible to load given content as an ADAO DCT one (no 'AlgorithmParameters' key found).")
479 # ----------------------------------------------------------------------
480 logging.debug("DCT Extracting commands of '%s' object..."%(self._objname,))
482 for k in self._objdata:
484 __command = k.split('_',1)[0]
487 __arguments = ["%s = %s"%(k,repr(v)) for k,v in self._objdata[k].items()]
488 __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments)))
489 __commands.sort() # Pour commencer par 'AlgorithmParameters'
492 class _SCDViewer(GenericCaseViewer):
494 Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD)
496 def __init__(self, __name="", __objname="case", __content=None, __object=None):
497 "Initialisation et enregistrement de l'entete"
498 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
499 self._addLine("# -*- coding: utf-8 -*-")
500 self._addLine("#\n# Input for ADAO converter to YACS\n#")
501 self._addLine("from numpy import array, matrix")
503 self._addLine("study_config = {}")
504 self._addLine("study_config['StudyType'] = 'ASSIMILATION_STUDY'")
505 self._addLine("study_config['Name'] = '%s'"%self._name)
506 self._addLine("observers = {}")
507 self._addLine("study_config['Observers'] = observers")
509 self._addLine("inputvariables_config = {}")
510 self._addLine("inputvariables_config['Order'] =['adao_default']")
511 self._addLine("inputvariables_config['adao_default'] = -1")
512 self._addLine("study_config['InputVariables'] = inputvariables_config")
514 self._addLine("outputvariables_config = {}")
515 self._addLine("outputvariables_config['Order'] = ['adao_default']")
516 self._addLine("outputvariables_config['adao_default'] = -1")
517 self._addLine("study_config['OutputVariables'] = outputvariables_config")
518 if __content is not None:
519 for command in __content:
520 self._append(*command)
521 def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
522 "Transformation d'une commande individuelle en un enregistrement"
523 if __command == "set": __command = __local["Concept"]
524 else: __command = __command.replace("set", "", 1)
527 if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'):
529 elif __command in ['Debug', 'setDebug']:
530 __text = "#\nstudy_config['Debug'] = '1'"
531 elif __command in ['NoDebug', 'setNoDebug']:
532 __text = "#\nstudy_config['Debug'] = '0'"
533 elif __command in ['Observer', 'setObserver']:
534 __obs = __local['Variable']
535 self._numobservers += 1
537 __text += "observers['%s'] = {}\n"%__obs
538 if __local['String'] is not None:
539 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
540 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, __local['String'])
541 if __local['Script'] is not None:
542 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'Script')
543 __text += "observers['%s']['Script'] = \"%s\"\n"%(__obs, __local['Script'])
544 if __local['Template'] is not None and __local['Template'] in Templates.ObserverTemplates:
545 __text += "observers['%s']['nodetype'] = '%s'\n"%(__obs, 'String')
546 __text += "observers['%s']['String'] = \"\"\"%s\"\"\"\n"%(__obs, Templates.ObserverTemplates[__local['Template']])
547 if __local['Info'] is not None:
548 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __local['Info'])
550 __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs)
551 __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers)
552 elif __local is not None: # __keys is not None and
553 numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15)
555 __text += "%s_config = {}\n"%__command
556 if 'self' in __local: __local.pop('self')
558 for __k,__v in __local.items():
559 if __v is None: __to_be_removed.append(__k)
560 for __k in __to_be_removed:
562 for __k,__v in __local.items():
563 if __k == "Concept": continue
564 if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local: continue
565 if __k == 'Algorithm':
566 __text += "study_config['Algorithm'] = %s\n"%(repr(__v))
567 elif __k == 'Script':
570 __v = "'"+repr(__v)+"'"
571 for __lk in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix']:
572 if __lk in __local and __local[__lk]: __k = __lk
573 if __command == "AlgorithmParameters": __k = "Dict"
574 if 'OneFunction' in __local and __local['OneFunction']:
575 __text += "%s_ScriptWithOneFunction = {}\n"%(__command,)
576 __text += "%s_ScriptWithOneFunction['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
577 __text += "%s_ScriptWithOneFunction['Script'] = {}\n"%(__command,)
578 __text += "%s_ScriptWithOneFunction['Script']['Direct'] = %s\n"%(__command,__v)
579 __text += "%s_ScriptWithOneFunction['Script']['Tangent'] = %s\n"%(__command,__v)
580 __text += "%s_ScriptWithOneFunction['Script']['Adjoint'] = %s\n"%(__command,__v)
581 __text += "%s_ScriptWithOneFunction['DifferentialIncrement'] = 1e-06\n"%(__command,)
582 __text += "%s_ScriptWithOneFunction['CenteredFiniteDifference'] = 0\n"%(__command,)
584 __f = 'ScriptWithOneFunction'
585 __v = '%s_ScriptWithOneFunction'%(__command,)
586 if 'ThreeFunctions' in __local and __local['ThreeFunctions']:
587 __text += "%s_ScriptWithFunctions = {}\n"%(__command,)
588 __text += "%s_ScriptWithFunctions['Function'] = ['Direct', 'Tangent', 'Adjoint']\n"%(__command,)
589 __text += "%s_ScriptWithFunctions['Script'] = {}\n"%(__command,)
590 __text += "%s_ScriptWithFunctions['Script']['Direct'] = %s\n"%(__command,__v)
591 __text += "%s_ScriptWithFunctions['Script']['Tangent'] = %s\n"%(__command,__v)
592 __text += "%s_ScriptWithFunctions['Script']['Adjoint'] = %s\n"%(__command,__v)
594 __f = 'ScriptWithFunctions'
595 __v = '%s_ScriptWithFunctions'%(__command,)
596 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
597 __text += "%s_config['From'] = '%s'\n"%(__command,__f)
598 __text += "%s_config['Data'] = %s\n"%(__command,__v)
599 __text = __text.replace("''","'")
600 elif __k in ('Stored', 'Checked'):
602 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
603 elif __k in ('AvoidRC', 'noDetails'):
605 __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v)))
607 if __k == 'Parameters': __k = "Dict"
608 if isinstance(__v,Persistence.Persistence): __v = __v.values()
609 if callable(__v): __text = self._missing%__v.__name__+__text
610 if isinstance(__v,dict):
611 for val in __v.values():
612 if callable(val): __text = self._missing%val.__name__+__text
613 __text += "%s_config['Type'] = '%s'\n"%(__command,__k)
614 __text += "%s_config['From'] = '%s'\n"%(__command,'String')
615 __text += "%s_config['Data'] = \"\"\"%s\"\"\"\n"%(__command,repr(__v))
616 __text += "study_config['%s'] = %s_config"%(__command,__command)
617 numpy.set_printoptions(precision=8,threshold=1000,linewidth=75)
619 self._switchoff = True
620 if __text is not None: self._addLine(__text)
622 self._switchoff = False
623 def _finalize(self, *__args):
624 self.__loadVariablesByScript()
626 self._addLine("Analysis_config = {}")
627 self._addLine("Analysis_config['From'] = 'String'")
628 self._addLine("Analysis_config['Data'] = \"\"\"import numpy")
629 self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])")
630 self._addLine("print 'Analysis:',xa\"\"\"")
631 self._addLine("study_config['UserPostAnalysis'] = Analysis_config")
632 def __loadVariablesByScript(self):
633 __ExecVariables = {} # Necessaire pour recuperer la variable
634 exec("\n".join(self._lineSerie), __ExecVariables)
635 study_config = __ExecVariables['study_config']
636 # Pour Python 3 : self.__hasAlgorithm = bool(study_config['Algorithm'])
637 if 'Algorithm' in study_config:
638 self.__hasAlgorithm = True
640 self.__hasAlgorithm = False
641 if not self.__hasAlgorithm and \
642 "AlgorithmParameters" in study_config and \
643 isinstance(study_config['AlgorithmParameters'], dict) and \
644 "From" in study_config['AlgorithmParameters'] and \
645 "Data" in study_config['AlgorithmParameters'] and \
646 study_config['AlgorithmParameters']['From'] == 'Script':
647 __asScript = study_config['AlgorithmParameters']['Data']
648 __var = ImportFromScript(__asScript).getvalue( "Algorithm" )
649 __text = "#\nstudy_config['Algorithm'] = '%s'"%(__var,)
650 self._addLine(__text)
651 if self.__hasAlgorithm and \
652 "AlgorithmParameters" in study_config and \
653 isinstance(study_config['AlgorithmParameters'], dict) and \
654 "From" not in study_config['AlgorithmParameters'] and \
655 "Data" not in study_config['AlgorithmParameters']:
657 __text += "AlgorithmParameters_config['Type'] = 'Dict'\n"
658 __text += "AlgorithmParameters_config['From'] = 'String'\n"
659 __text += "AlgorithmParameters_config['Data'] = '{}'\n"
660 self._addLine(__text)
663 class _XMLViewer(GenericCaseViewer):
665 Etablissement des commandes d'un cas XML
667 def __init__(self, __name="", __objname="case", __content=None, __object=None):
668 "Initialisation et enregistrement de l'entete"
669 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
670 raise NotImplementedError()
672 class _YACSViewer(GenericCaseViewer):
674 Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
676 def __init__(self, __name="", __objname="case", __content=None, __object=None):
677 "Initialisation et enregistrement de l'entete"
678 GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
679 self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
680 self._append = self.__internalSCD._append
681 def dump(self, __filename=None, __convertSCDinMemory=True):
682 "Restitution normalisée des commandes"
683 self.__internalSCD._finalize()
685 if __filename is None:
686 raise ValueError("A file name has to be given for YACS XML output.")
688 if not PlatformInfo.has_salome or \
689 not PlatformInfo.has_adao:
691 "Unable to get SALOME or ADAO environnement variables for YACS conversion.\n"+\
692 "Please load the right environnement before trying to use it.")
693 elif __convertSCDinMemory:
694 __file = os.path.abspath(__filename)
695 __SCDdump = self.__internalSCD.dump()
696 if os.path.isfile(__file) or os.path.islink(__file):
698 from daYacsSchemaCreator.run import create_schema_from_content
699 create_schema_from_content(__SCDdump, __file)
701 __file = os.path.abspath(__filename)
702 __SCDfile = __file[:__file.rfind(".")] + '_SCD.py'
703 __SCDdump = self.__internalSCD.dump(__SCDfile)
704 if os.path.isfile(__file) or os.path.islink(__file):
706 __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
707 __args = ["python", __converterExe, __SCDfile, __file]
709 __p = subprocess.Popen(__args)
710 (__stdoutdata, __stderrdata) = __p.communicate()
714 if not os.path.exists(__file):
715 __msg = "An error occured during the ADAO YACS Schema build for\n"
716 __msg += "the target output file:\n"
717 __msg += " %s\n"%__file
718 __msg += "See errors details in your launching terminal log.\n"
719 raise ValueError(__msg)
721 __fid = open(__file,"r")
722 __text = __fid.read()
726 class ImportFromScript(object):
728 Obtention d'une variable nommee depuis un fichier script importe
730 def __init__(self, __filename=None):
731 "Verifie l'existence et importe le script"
732 if __filename is None:
733 raise ValueError("The name of the file, containing the variable to be read, has to be specified.")
734 if not os.path.isfile(__filename):
735 raise ValueError("The file containing the variable to be imported doesn't seem to exist. Please check the file. The given file name is:\n \"%s\""%__filename)
736 if os.path.dirname(__filename) != '':
737 sys.path.insert(0, os.path.dirname(__filename))
738 __basename = os.path.basename(__filename).rstrip(".py")
740 __basename = __filename.rstrip(".py")
741 self.__basename = __basename
742 self.__scriptfile = __import__(__basename, globals(), locals(), [])
743 self.__scriptstring = open(__filename,'r').read()
744 def getvalue(self, __varname=None, __synonym=None ):
745 "Renvoie la variable demandee"
746 if __varname is None:
747 raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.")
748 if not hasattr(self.__scriptfile, __varname):
749 if __synonym is None:
750 raise ValueError("The imported script file \"%s\" doesn't contain the mandatory variable \"%s\" to be read. Please check the content of the file and the syntax."%(str(self.__basename)+".py",__varname))
751 elif not hasattr(self.__scriptfile, __synonym):
752 raise ValueError("The imported script file \"%s\" doesn't contain the mandatory variable \"%s\" to be read. Please check the content of the file and the syntax."%(str(self.__basename)+".py",__synonym))
754 return getattr(self.__scriptfile, __synonym)
756 return getattr(self.__scriptfile, __varname)
758 "Renvoie le script complet"
759 return self.__scriptstring
761 # ==============================================================================
762 if __name__ == "__main__":
763 print('\n AUTODIAGNOSTIC \n')