1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013 EDF R&D
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.
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
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 """Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
23 import xml.etree.cElementTree as ET
25 import types,string,re,os
26 from Extensions.i18n import tr
27 from generator_python import PythonGenerator
30 HARMONIC = 'HARMONIC' # probleme frequentiel
31 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
33 # nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
34 nomPlugin = 'CARMEL3DTV0'
38 Retourne les informations necessaires pour le chargeur de plugins
39 Ces informations sont retournees dans un dictionnaire
44 # La factory pour creer une instance du plugin
45 'factory' : CARMEL3DTV0Generator,
50 class CARMEL3DTV0Generator(PythonGenerator):
52 Ce generateur parcourt un objet de type JDC et produit
53 un texte au format eficas et
54 un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
57 # Les extensions de fichier permis?
60 #----------------------------------------------------------------------------------------
61 def gener(self,obj,format='brut',config=None):
67 # Cette instruction genere le contenu du fichier de commandes (persistance)
68 self.text=PythonGenerator.gener(self,obj,format)
71 print "self.text = %s" % self.text
73 # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
74 # si le jdc est valide (sinon cela n a pas de sens)
77 # constitution du bloc VERSION du fichier PHYS (existe toujours)
78 self.generBLOC_VERSION(obj)
80 except ValueError, err:
81 raise ValueError(str(err))
88 #----------------------------------------------------------------------------------------
90 #----------------------------------------------------------------------------------------
94 self.texteCarmel3D_SH=""
95 self.debug = True # affichage de messages pour deboguage (.true.) ou non
96 self.dicoEtapeCourant=None
97 self.dicoMCFACTCourant=None
99 self.dictGroupes = {} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
100 self.dictMacroGroupes = {} # macro-groupe et leurs propriétés
102 self.dictMouvement= {'ordre':[]} # dictionnaire contenant les mouvements, avec liste incluse pour l'ordre
103 self.nombreMouvements = 0 # nombre de mouvements définis, servant de compteur aussi
107 self.dictGroupeMilieux={"ordreSource":[], "ordreId":[]}
109 # Parametre du maillage
110 self.identification = ""
111 self.fichierMaillage = ""
112 self.echelleMaillage = ""
113 # Parametre de Precision
115 self.precisionLineaire=""
116 self.kEpsilonDistance=""
118 self.nbIterationMax=""
119 self.methodeNonLineaire = ""
120 self.kEpsilonNonLinearite=""
121 self.kCoefficientRelaxation=""
126 self.typeSolveur = "" # type de solveur, linéaire (Solveur_lineaire) ou non-linéaire (Solveur_non_lineaire)
129 self.carteCourantInduit=""
132 self.fluxInducteur=""
133 self.courantInducteur=""
134 self.tensionInducteur=""
142 self.fluxJinduitTotal=""
143 self.potFlottant = ""
145 # on force le probleme a etre frequentiel, seul possible en l'etat des choses
146 self.problem = HARMONIC
148 def indent(self, elem, level=0, more_sibs=False, espace=4*' '):
149 """Transformation du XML créé par le module interne xml.etree.ElementTree afin d'écrire les indentations et retours à la ligne corrects.
150 D'après un script original de Fredrik Lundh en 2004 (http://effbot.org/zone/element-lib.htm#prettyprint),
151 modifié par Joshua Richardson en 2012 (http://stackoverflow.com/questions/749796/pretty-printing-xml-in-python)
152 et par Loic Chevallier en 2014 (ajout du reglage de l'indentation).
153 L'indentation est de 4 espaces par défaut (cf. argument optionel : espace)
154 Utilisation : self.indent(root), avant écriture dans un fichier de root = ET.Element("configuration") ou de tree = ET.ElementTree(root)
155 où ET = xml.etree.ElementTree
159 i += (level-1) * espace
162 if not elem.text or not elem.text.strip():
163 elem.text = i + espace
168 self.indent(kid, level+1, count < num_kids - 1)
170 if not elem.tail or not elem.tail.strip():
175 if level and (not elem.tail or not elem.tail.strip()):
180 #----------------------------------------------------------------------------------------
182 #----------------------------------------------------------------------------------------
184 def writeDefault(self,fn) :
185 """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
187 file = fn[:fn.rfind(".")] # emplacement du ficher .comm (chemin complet)
188 namefile=os.path.basename(file) # nom du fichier.comm
189 repertory=os.path.dirname(file) # répertoire contenant le fichier .comm (emplacement absolu)
191 # correspondances globales
192 correspondance_booleen = {'oui':'true', 'non':'false'}
194 fileXML = os.path.join(repertory, 'configuration.xml') # nom du fichier de configuration XML (chemin complet)
196 print "\necriture du fichier XML : ", fileXML
197 print "self.dictMaterial = ",self.dictMaterial
198 print "self.dictSource = ",self.dictSource
199 print "self.dictGroupes = ",self.dictGroupes
200 print "self.dictMacroGroupes = ",self.dictMacroGroupes
202 root = ET.Element("configuration")
204 #Bloc <Maillage></Maillage>
205 Maillage = ET.SubElement(root, "Maillage")
206 identification = ET.SubElement(Maillage, "identification")
207 identification.text = self.identification
208 fichierMaillage = ET.SubElement(Maillage, "fichierMaillage")
209 fichierMaillage.text = self.fichierMaillage
210 echelleMaillage = ET.SubElement(Maillage, "echelleMaillage")
211 correspondance_echelleMaillage = {"Metre":1.0, "Millimetre":1.0e-3}
212 echelleMaillage.text = "%f" % (correspondance_echelleMaillage[self.echelleMaillage], )
214 #Bloc <ParametrePrecision></ParametrePrecision>
215 ParametrePrecision = ET.SubElement(root, "ParametrePrecision")
216 TypeSolveurLineaire = ET.SubElement(ParametrePrecision, "TypeSolveurLineaire")
217 if self.precond=="Crout":
218 TypeSolveurLineaire.text = "1"
219 if self.precond=="Jacobi":
220 TypeSolveurLineaire.text = "2"
221 if self.precond=="MUMPS":
222 TypeSolveurLineaire.text = "3"
223 kEpsilonGCP = ET.SubElement(ParametrePrecision, "kEpsilonGCP")
224 kEpsilonGCP.text = "%s" %(self.kEpsilonGCP)
225 nbIterationMax = ET.SubElement(ParametrePrecision, "nbIterationMax")
226 nbIterationMax.text = "%s" %(self.nbIterationMax)
227 if self.typeSolveur == 'Solveur_non_lineaire': # écriture des paramètres du solveur non-linéaire seulement si défini dans l'étude
228 methodeNonLineaire = ET.SubElement(ParametrePrecision, "methodeNonLineaire")
229 methodeNonLineaire.text = "%s" %(self.methodeNonLineaire)
230 kEpsilonNonLinearite = ET.SubElement(ParametrePrecision, "kEpsilonNonLinearite")
231 kEpsilonNonLinearite.text = "%s" %(self.kEpsilonNonLinearite)
232 kCoefficientRelaxation = ET.SubElement(ParametrePrecision, "kCoefficientRelaxation")
233 kCoefficientRelaxation.text = "%s" %(self.kCoefficientRelaxation)
234 kEpsilonDistance = ET.SubElement(ParametrePrecision, "kEpsilonDistance")
235 kEpsilonDistance.text = "%s" %(self.kEpsilonDistance)
236 kdistanceRef = ET.SubElement(ParametrePrecision, "kdistanceRef")
237 kdistanceRef.text = "%s" %(self.kdistanceRef)
238 jauge = ET.SubElement(ParametrePrecision, "jauge")
239 jauge.text = "%s" %(correspondance_booleen[self.jauge], )
240 NBoucleTemps = ET.SubElement(ParametrePrecision, "NBoucleTemps")
241 NBoucleTemps.text = "%s" %(self.NBoucleTemps)
242 dt = ET.SubElement(ParametrePrecision, "dt")
243 dt.text = "%s" %(self.dt)
245 #Bloc <Milieux></Milieux>
250 listeMilieux = [] # liste des milieux, dans l'ordre de création
251 Milieux=ET.SubElement(root, "Milieux") # création du bloc <Milieux>...</Milieux>
252 for nom in self.dictGroupes: # on parcoure tous les groupes MESHGROUP
253 if self.dictGroupes[nom].has_key('MATERIAL') \
254 or self.dictGroupes[nom].has_key('SOURCE') \
255 or self.dictGroupes[nom].has_key('AIMANT') \
256 or self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY') : # si MESHGROUP ou MACRO_GROUPE associé à au moins un matériau, source ou géométrie d'inducteur bobiné, c'est un milieu
257 milieu=ET.SubElement(Milieux,"milieu" ) # création d'un nouveau milieu
258 listeMilieux.append(nom) # mise à jour de la liste des milieux
259 i = i+1 # incrément du numéro de milieu
260 self.dictGroupes[nom]['idMilieu'] = i # affectation de l'id à ce groupe
261 milieu.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
262 milieu.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
263 nomGroupeMaillage = ET.SubElement(milieu, "nomGroupeMaillage") # nom du groupe de maillage
264 nomGroupeMaillage.text = nom
265 if self.dictGroupes[nom].has_key('MATERIAL'): # matériau trouvé pour ce milieu
266 material = self.dictGroupes[nom]['MATERIAL'] # on récupère le nom de la propriété du matériau, clé de self.dictMaterial
267 permeabiliteLineaire=ET.SubElement(milieu, "permeabiliteLineaire")
268 permeabiliteLineaire.text="%s"%(self.dictMaterial[material]["PERMEABILITY"]["VALUE"])
269 if self.dictMaterial[material]["PERMEABILITY"]["LAW"]=="NONLINEAR":
270 coefficientsMarrocco=ET.SubElement(milieu, "coefficientsMarrocco")
271 epsilon = self.dictMaterial[material]["PERMEABILITY"]["EPSILON"]
272 c = self.dictMaterial[material]["PERMEABILITY"]["C"]
273 alpha = self.dictMaterial[material]["PERMEABILITY"]["ALPHA"]
274 tau = self.dictMaterial[material]["PERMEABILITY"]["TAU"]
275 coefficientsMarrocco.text = '%g, %g, %g, %g' % (epsilon, c, alpha, tau)
276 if self.dictMaterial[material].has_key('CONDUCTIVITY'):
277 conductivite=ET.SubElement(milieu, "conductivite")
278 conductivite.text="%s" %(self.dictMaterial[material]["CONDUCTIVITY"]["VALUE"])
279 if self.dictMaterial[material].has_key('AIMANT'):
280 norme=ET.SubElement(milieu, "norme")
281 norme.text="%s" %(self.dictMaterial[material]["AIMANT"]["VALUE"])
282 if self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY'): # géométrie d'inducteur bobiné trouvée pour ce milieu
283 strand=self.dictGroupes[nom]['STRANDED_INDUCTOR_GEOMETRY'] # on récupère le nom de la géométrie d'inducteur bobiné, clé de self.dictStrand
284 axe = ET.SubElement(milieu, "axe")
285 axe.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Direction"]))
286 if self.dictStrand[strand]["Forme"]=="Circulaire":
287 coordonneesPolaires=ET.SubElement(milieu, "coordonneesPolaires")
288 coordonneesPolaires.text="true"
289 origineReperePolaire=ET.SubElement(milieu, "origineReperePolaire")
290 origineReperePolaire.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Centre"]))
291 section=ET.SubElement(milieu, "section")
292 section.text="%g" %(self.dictStrand[strand]["Section"], )
293 if self.dictGroupes[nom].has_key('SOURCE'): # source trouvée pour ce milieu
294 Source = self.dictGroupes[nom]['SOURCE'] # on récupère le nom de la source, clé de self.dictSource
295 self.dictSource[Source]['milieux'].append(nom) # ajout du nom du groupe à cette source
296 if self.dictSource[Source].has_key('STRANDED_INDUCTOR'):
297 nbSpires=ET.SubElement(milieu, "nbSpires")
298 nbSpires.text="%g" %(self.dictSource[Source]["STRANDED_INDUCTOR"]["NTURNS"])
300 #Bloc <ConditionsLimitesChamps>...</ConditionsLimitesChamps>
301 ConditionsLimitesChamps = ET.SubElement(root, "ConditionsLimitesChamps")
302 for nomCondition in self.dictGroupes:
303 if self.dictGroupes[nomCondition].has_key('CONDITION_LIMITE'): # condition aux limites associée à ce groupe, hors symétrie et mouvement
304 if self.dictGroupes[nomCondition].has_key('LISTE'): # MACRO_GROUPE
305 for i in range(len(self.dictGroupes[nomCondition]['LISTE'])):
306 conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
307 Type=ET.SubElement(conditionLimite,"type" )
308 Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
309 GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
310 GroupeNoeud.text="%s" %(self.dictGroupes[nomCondition]['LISTE'][i])
312 conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
313 Type=ET.SubElement(conditionLimite,"type" )
314 Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
315 GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
316 GroupeNoeud.text="%s" %(nomCondition)
318 for i in range(len(self.listSymetrie)): # symétries, définies dans le bloc des conditions aux limites
319 conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamp")
320 Type=ET.SubElement(conditionLimite,"type" )
321 Type.text="%s" %(self.listSymetrie[i]["Type"])
322 GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
323 GroupeNoeud.text="%s" %(self.listSymetrie[i]["Face1"])
324 if 'Face2' in self.listSymetrie[i] :
325 GroupeNoeud2=ET.SubElement(conditionLimite, "groupeNoeud2")
326 GroupeNoeud2.text="%s" %(self.listSymetrie[i]["Face2"])
327 if 'Mouvement_associe' in self.listSymetrie[i]:
328 MouvementAssocie=ET.SubElement(conditionLimite, "mouvementAssocie")
329 nomMouvementAssocie = self.listSymetrie[i]['Mouvement_associe'].nom # on récupère le nom du mouvement associé, car on a stocké le concept tout entier
330 MouvementAssocie.text="%i"%(self.dictMouvement[nomMouvementAssocie]['ordre'], )
331 if 'Groupe_Points' in self.listSymetrie[i] :
332 GroupePoints=ET.SubElement(conditionLimite, "groupePoints")
333 GroupePoints.text="%s" %(self.listSymetrie[i]['Groupe_Points'])
335 #Bloc <TermeSourceElectrique>...</TermeSourceElectrique>
336 TermeSourceElectrique=ET.SubElement(root, "TermeSourceElectrique")
338 if self.debug: print 'self.dictSource = ', self.dictSource
339 for source in self.dictSource.keys(): # parcours des sources
340 if len(self.dictSource[source]['milieux']) > 0: # on continue si au moins un groupe de maillage, i.e., milieux est associé à cette source
341 if self.dictSource[source].has_key('STRANDED_INDUCTOR'): # inducteur bobiné
342 inducteur=ET.SubElement(TermeSourceElectrique, "inducteur")
343 listeMilieux=ET.SubElement(inducteur, "listeMilieux") # création de la liste des milieux
344 idListeMilieux = [] # indices des milieux concernés
345 for milieu in self.dictSource[source]['milieux']: # construction de la liste des milieux
346 idListeMilieux.append(self.dictGroupes[milieu]['idMilieu'])
347 listeMilieux.text = "%s" % ','.join(map(str,idListeMilieux))
348 if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="CURRENT": # source de type courant imposé
349 couplageTension=ET.SubElement(inducteur, "couplageTension")
350 couplageTension.text = "false"
351 courant=ET.SubElement(inducteur, "courant")
352 if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
353 courant.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
354 if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
355 amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
356 frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
357 phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
358 courant.text="%g, %g, %g" % (amplitude, frequence, phase)
359 courant.set('forme', 'sinus') # attribut forme="sinus"
360 if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="VOLTAGE": # source de type tension imposée
361 couplageTension=ET.SubElement(inducteur, "couplageTension")
362 couplageTension.text = "true"
363 tension=ET.SubElement(inducteur, "tension")
364 if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
365 tension.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
366 if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
367 amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
368 frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
369 phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
370 tension.text="%g, %g, %g" % (amplitude, frequence, phase)
371 tension.set('forme', 'sinus') # attribut forme="sinus"
372 if self.dictSource[source]["STRANDED_INDUCTOR"].has_key('Resistance'):
373 resistance=ET.SubElement(inducteur, "resistance")
374 resistance.text="%g" %(self.dictSource[source]["STRANDED_INDUCTOR"]['Resistance'])
376 #definir Terme Source Magnetique
377 #definirTermeSourceMagnetique=ET.SubElement(root, "definirTermeSourceMagnetique")
378 #nombreTermeSourceMagnetique=ET.SubElement(definirTermeSourceMagnetique, "nombreTermeSourceMagnetique")
379 #nombreTermeSourceMagnetique.text="0"
382 #definirAimants=ET.SubElement(root, "definirAimants")
383 #nombreAimants=ET.SubElement(definirAimants, "nombreAimants")
384 #nombreAimants.text="0"
386 #Bloc <Mouvements>...</Mouvements>
388 Mouvements=ET.SubElement(root, "Mouvements")
389 for nom in self.dictMouvement['ordre']: # parcours de la liste des noms de mouvement définis, dans l'ordre
391 mouvement = ET.SubElement(Mouvements, "mouvement") # création de ce mouvement
392 mouvement.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
393 mouvement.set("name", nom ) # ajout de l'attribut name, inutilisé
394 milieuGlissement = ET.SubElement(mouvement, "milieuGlissement")
395 nomMilieuGlissement = self.dictMouvement[nom]['valeurs']['Milieu_glissement'].nom # concept stocké -> nom du concept
396 milieuGlissement.text="%i" % (self.dictGroupes[nomMilieuGlissement]['idMilieu'], ) # numéro du milieu défini par son nom, selon tableaux remplis précédemment
397 surfaceGlissement = ET.SubElement(mouvement, "surfaceGlissement")
398 surfaceGlissement.text= self.dictMouvement[nom]['valeurs']['Surface_glissement'].nom # concept stocké -> nom du concept
399 deltaMaillage = ET.SubElement(mouvement, "deltaMaillage")
400 deltaMaillage.text="%g" % (self.dictMouvement[nom]['valeurs']['Delta_maillage'], )
401 nbPermutPas = ET.SubElement(mouvement, "nbPermutPas")
402 nbPermutPas.text="%i" % (self.dictMouvement[nom]['valeurs']['Nombre_pas_permutation'], )
403 axeRotation = ET.SubElement(mouvement, "axeRotation")
404 axeRotation.text= self.dictMouvement[nom]['valeurs']['Axe_rotation']
406 #definir Force Couple
407 #definirForceCouple=ET.SubElement(root, "definirForceCouple")
408 #nombreForceCouple=ET.SubElement(definirForceCouple, "nombreForceCouple")
409 #nombreForceCouple.text="0"
411 #bloc <SpiresExploratrices></SpiresExploratrices>
412 i = 0 # compteur de spires
413 spiresExploratrices = False # pas de spires exploratrices a priori
414 for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
415 if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
416 spiresExploratrices = True
417 if spiresExploratrices: # on a trouvé au moins une spire exploratrice
418 SpiresExploratrices=ET.SubElement(root, "SpiresExploratrices") # création du bloc XML adéquat
419 for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
420 if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
421 spire = ET.SubElement(SpiresExploratrices, "spireExploratrice") # création du bloc XML pour cette spire
422 spire.text = nom # le nom du groupe de noeud est directement écrit
423 i = i+1 # incrément du numéro de spire
424 spire.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
425 spire.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
427 #bloc <PotentielsFlottants></PotentielsFlottants>
428 i = 0 # compteur de potentiels flottants
429 potentielsFlottants = False # pas de potentiel flottant a priori
430 for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
431 if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
432 potentielsFlottants = True
433 if potentielsFlottants: # on a trouvé au moins un potentiel flottant
434 PotentielsFlottants=ET.SubElement(root, "PotentielsFlottants") # création du bloc XML adéquat
435 for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
436 if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
437 potentielFlottant = ET.SubElement(PotentielsFlottants, "potentielFlottant") # création du bloc XML pour ce potentiel flottant
438 potentielFlottant.text = nom # le nom du groupe de noeud est directement écrit
439 i = i+1 # incrément du numéro de spire
440 potentielFlottant.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
441 potentielFlottant.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
444 #Definir Post traitement
445 postraitement=ET.SubElement(root, "postraitement")
446 carteChamp=ET.SubElement(postraitement, "carteChamp")
447 if type(self.carteChamp)==float:
448 carteChamp.text="%s" %(self.carteChamp)
449 else: carteChamp.text="%s" % ','.join(map(str,self.carteChamp))
450 carteCourantInduit=ET.SubElement(postraitement, "carteCourantInduit")
451 if type(self.carteCourantInduit)==float:
452 carteCourantInduit.text="%s" %(self.carteCourantInduit)
453 else: carteCourantInduit.text="%s" % ','.join(map(str,self.carteCourantInduit))
454 carteForce=ET.SubElement(postraitement, "carteForce")
455 if type(self.carteForce)==float:
456 carteForce.text="%s" %(self.carteForce)
457 else: carteForce.text="%s" % ','.join(map(str,self.carteForce))
458 perteJoule=ET.SubElement(postraitement, "perteJoule")
459 perteJoule.text="%s" %(correspondance_booleen[self.perteJoule])
460 fluxInducteur=ET.SubElement(postraitement, "fluxInducteur")
461 fluxInducteur.text="%s" %(correspondance_booleen[self.fluxInducteur])
462 courantInducteur=ET.SubElement(postraitement, "courantInducteur")
463 courantInducteur.text="%s" %(correspondance_booleen[self.courantInducteur])
464 tensionInducteur=ET.SubElement(postraitement, "tensionInducteur")
465 tensionInducteur.text="%s" %(correspondance_booleen[self.tensionInducteur])
466 energie=ET.SubElement(postraitement, "energie")
467 energie.text="%s" %(correspondance_booleen[self.energie])
468 ForceCouple=ET.SubElement(postraitement, "ForceCouple")
469 ForceCouple.text="%s" %(correspondance_booleen[self.ForceCouple])
470 fluxSpire=ET.SubElement(postraitement, "fluxSpire")
471 fluxSpire.text="%s" %(correspondance_booleen[self.fluxSpire])
472 fluxGroupe=ET.SubElement(postraitement, "fluxGroupe")
473 fluxGroupe.text="%s" %(correspondance_booleen[self.fluxGroupe])
474 ddpElect=ET.SubElement(postraitement, "ddpElect")
475 ddpElect.text="%s" %(correspondance_booleen[self.ddpElect])
476 ddpMagn=ET.SubElement(postraitement, "ddpMagn")
477 ddpMagn.text="%s" %(correspondance_booleen[self.ddpMagn])
478 fluxMagn=ET.SubElement(postraitement, "fluxMagn")
479 fluxMagn.text="%s" %(correspondance_booleen[self.fluxMagn])
480 fluxJinduitTotal=ET.SubElement(postraitement, "fluxJinduitTotal")
481 fluxJinduitTotal.text="%s" %(correspondance_booleen[self.fluxJinduitTotal])
482 potentielFlottant=ET.SubElement(postraitement, "potFlottant")
483 potentielFlottant.text="%s" %(correspondance_booleen[self.potFlottant])
485 self.indent(root) # indentations et retours à la ligne, à l'aide d'une fonction maison, car xml.etree.ElementTree ne sait pas faire et le module lxml n'est pas disponible dans Salomé
487 tree = ET.ElementTree(root)
489 tree.write(fileXML, encoding="UTF-8")
491 # print "le dico complet=%s" %(self.dictGroupes)
494 print "ecriture du fichier d'execution (SH)"
495 RepCarmel=os.path.join(repertory,"lancer.sh")
496 f = open( RepCarmel, 'wb')
497 self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
498 self.texteCarmel3D_SH+='./carmel << FIN\n'
499 correspondance_resolution = {"(T-)Omega seulement":"1\n","A(-Phi) seulement":"2\n", "(T-)Omega puis A(-Phi)":"1\n2\n", "A(-Phi) puis (T-)Omega":"2\n1\n"}
500 self.texteCarmel3D_SH+= correspondance_resolution[self.formulation]
501 self.texteCarmel3D_SH+='0\nFIN\n'
502 f.write(self.texteCarmel3D_SH)
506 #----------------------------------------------------------------------------------------
507 # analyse de chaque noeud de l'arbre
508 #----------------------------------------------------------------------------------------
510 def generMCSIMP(self,obj) :
511 """recuperation de l objet MCSIMP"""
513 print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
514 s=PythonGenerator.generMCSIMP(self,obj)
515 self.dicoCourant[obj.nom]=obj.valeurFormatee
519 #----------------------------------------------------------------------------------------
520 def generMCFACT(self,obj) :
521 """recuperation de l objet MCFACT"""
523 self.dicoMCFACTCourant=dico
524 self.dicoCourant=self.dicoMCFACTCourant
525 s=PythonGenerator.generMCFACT(self,obj)
526 self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
527 self.dicoMCFACTCourant=None
528 self.dicoCourant=self.dicoEtapeCourant
532 #----------------------------------------------------------------------------------------
533 def generPROC_ETAPE(self,obj):
534 """analyse des PROC du catalogue ( VERSION )"""
536 self.dicoEtapeCourant=dico
537 self.dicoCourant=self.dicoEtapeCourant
538 s=PythonGenerator.generPROC_ETAPE(self,obj)
539 obj.valeur=self.dicoEtapeCourant
542 print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
543 s=PythonGenerator.generPROC_ETAPE(self,obj)
544 if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
545 if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
546 if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
547 if obj.nom=="SYMETRIE" : self.generBLOC_SYMETRIE(obj)
548 if obj.nom=="POST_TRAITEMENT" : self.generPOST_TRAITEMENT(obj)
553 #----------------------------------------------------------------------------------------
554 def generETAPE(self,obj):
555 """analyse des OPER du catalogue"""
557 self.dicoEtapeCourant=dico
558 self.dicoCourant=self.dicoEtapeCourant
559 s=PythonGenerator.generETAPE(self,obj)
560 obj.valeur=self.dicoEtapeCourant
562 print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
563 if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
564 if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
565 if obj.nom=="SOURCE" : self.generSOURCE(obj)
566 if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
567 if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
568 if obj.nom=="MOUVEMENT" : self.generMOUVEMENT(obj)
569 s=PythonGenerator.generETAPE(self,obj)
572 #----------------------------------------------------------------------------------------
573 def generMACRO_ETAPE(self,obj):
574 """Utilisé par INCLUDE"""
576 self.dicoEtapeCourant=dico
577 self.dicoCourant=self.dicoEtapeCourant
579 monGenerateur=generator.plugins[nomPlugin]()
580 jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
582 print "jdc_aux_texte : %s" % jdc_aux_texte
584 # sauvegarde de tous les matériaux trouvés dans les bibliothèques INCLUDE
585 for cle in monGenerateur.dictMaterial:
586 self.dictMaterial[cle] = monGenerateur.dictMaterial[cle]
587 # sauvegarde de toutes les sources trouvées dans les bibliothèques INCLUDE
588 for cle in monGenerateur.dictSource:
589 self.dictSource[cle] = monGenerateur.dictSource[cle]
591 print "________FIN MACRO______________________________________"
592 s=PythonGenerator.generMACRO_ETAPE(self,obj)
595 #----------------------------------------------------------------------------------------
596 #----------------------------------------------------------------------------------------
597 def generMESHGROUP(self,obj):
598 """preparation de la ligne NAME referencant le groupe de mailles
599 associe le groupe de mailles au materiau ou a la source utilisateur
600 on sauvegarde aussi les noms des groupes de maillage
603 nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
604 print "liste des noms sans prefixes %s" %(nomGroupe)
606 # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
607 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
608 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
610 # on utilise le fait que obj.valeur est un dictionnaire
611 self.dictGroupes[nomGroupe] = {}
613 print "obj.valeur.keys()= %s" % obj.valeur.keys()
614 #if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
615 # raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
616 # association a un materiau
617 if 'MATERIAL' in obj.valeur.keys():
618 self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
619 # self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
620 # association a une source
621 if 'SOURCE' in obj.valeur.keys():
622 self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
623 # self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
624 # erreur ni materiau ni source associee
625 if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
626 self.dictGroupes[nomGroupe]['STRANDED_INDUCTOR_GEOMETRY'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
627 # self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
628 if 'CONDITION_LIMITE' in obj.valeur.keys():
629 self.dictGroupes[nomGroupe]['CONDITION_LIMITE'] = obj.valeur['CONDITION_LIMITE']
630 # self.dictGroupes['ordreConditionJdC'].append(nomGroupe)
631 if 'Domaine' in obj.valeur.keys():
632 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
633 # self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
635 texte+="%s"%(obj.valeur['Domaine'])
636 print"le texte=%s" %(texte)
637 self.dictDomaine[obj.get_sdname()]=texte
638 print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
639 if 'Potentiel_Flottant' in obj.valeur.keys():
640 self.dictGroupes[nomGroupe]['Potentiel_Flottant'] = True
641 if 'Spire_Exploratrice' in obj.valeur.keys():
642 self.dictGroupes[nomGroupe]['Spire_Exploratrice'] = True
645 # raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
647 print "self.dictGroupes= %s" % repr(self.dictGroupes)
648 except ValueError, err:
649 raise ValueError, str(err)
651 def generMACRO_GROUPE(self, obj):
652 """preparation de la ligne NAME referencant le groupe de mailles
653 associe le groupe de mailles au materiau ou a la source utilisateur
654 on sauvegarde aussi les noms des macros groupes
657 nomMacroGroupe = obj.get_sdname() # nom du macro groupe
658 print "liste des noms sans prefixes %s" %(nomMacroGroupe)
659 self.dictMacroGroupes[nomMacroGroupe] = obj.valeur # sauvegarde des propriétés du macro-groupe
662 print "obj.valeur.keys()= %s" % obj.valeur.keys()
663 # association a une source
664 if 'LISTE_MESHGROUP' in obj.valeur.keys(): # test de liste définie dans la macro-groupe, sinon erreur
665 listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
666 self.dictMacroGroupes[nomMacroGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
667 for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
668 groupe = groupe.replace("'", "") # suppression des guillement simples
669 groupe = groupe.replace('"', "") # suppression des guillement doubles
670 self.dictMacroGroupes[nomMacroGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
672 raise ValueError, tr("Ce MACRO_GROUPE %s doit contenir une liste de groupes LISTE_MESHGROUP." % nomMacroGroupe)
674 for nomGroupe in self.dictMacroGroupes[nomMacroGroupe]['LISTE']: # liste des groupes MESHGROUP de ce macro-groupe. On leur associe les propriétés du MACRO_GROUPE
675 for propriete in ('SOURCE', 'MATERIAL', 'STRANDED_INDUCTOR_GEOMETRY'): # liste des propriétés automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
676 if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
677 if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete].nom: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
678 print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
679 ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
680 raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
681 ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe ))
682 else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
683 self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete].nom # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
684 for propriete in ('CONDITION_LIMITE', ): # liste des propriétés définies à l'avance automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
685 if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
686 if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete]: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
687 print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
688 ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
689 raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
690 ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe ))
691 else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
692 self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete] # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
693 except ValueError, err:
694 raise ValueError, str(err)
697 def generSOLVEUR(self, obj):
699 print "generation solveur obj.valeur = %s" % obj.valeur
701 self.typeSolveur = obj.valeur['Type']
702 if self.typeSolveur == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
703 if self.typeSolveur == "Solveur_non_lineaire" :
704 self.generSOLVEUR_LINEAIRE(obj)
705 self.generSOLVEUR_NON_LINEAIRE(obj)
706 except ValueError, err:
707 raise ValueError, str(err)
709 def generSOLVEUR_LINEAIRE(self, obj):
711 print "generation material obj.valeur = %s" % obj.valeur
713 nature = obj.valeur['Methode_lineaire']
714 if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
715 if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
716 except ValueError, err:
717 raise ValueError, str(err)
719 def generMETHODE_ITERATIVE_BICGCR(self, obj):
721 print "generation methode iterative BICGCR obj.valeur = %s" % obj.valeur
722 self.kEpsilonGCP = obj.valeur["Precision"]
723 self.precond=obj.valeur["Preconditionneur"]
724 self.nbIterationMax=obj.valeur["Nombre_iterations_max"]
727 def generMETHODE_DIRECTE_MUMPS(self, obj):
730 print "_____________directe_____________"
732 def generSOLVEUR_NON_LINEAIRE(self, obj):
734 print "generation solveur_non_lineaire obj.valeur = %s" % obj.valeur
735 correspondance_methodeNonLineaire = {"Methode de Newton":2,"Methode de substitution":1} # correspondance sur la méthode non-linéaire entre le catalogue et le XML
736 self.methodeNonLineaire = correspondance_methodeNonLineaire[obj.valeur["Methode_non_lineaire"]]
737 self.kEpsilonNonLinearite=obj.valeur["PrecisionNonLineaire"]
738 self.kCoefficientRelaxation=obj.valeur["Coefficient_de_Relaxation"]
740 def generMATERIAL(self,obj):
741 """preparation du bloc correspondant a un materiau du fichier PHYS"""
744 print "generation material obj.valeur = %s" % obj.valeur
746 nomMaterial = obj.get_sdname()
747 self.dictMaterial[nomMaterial]=obj.valeur
748 print"self.dictMaterial=%s" %(self.dictMaterial)
749 except ValueError, err:
750 raise ValueError, str(err)
751 #-------------------------------------------------------------------
753 def generSOURCE(self,obj):
754 """preparation du bloc correspondant a une source du fichier PHYS"""
756 print "generation source obj valeur = %s" % obj.valeur
759 nomSource = obj.get_sdname()
760 self.dictSource[nomSource]=obj.valeur # dictionnaire
761 self.dictSource[nomSource]['milieux'] = [] # liste ordonnée des groupes associés à cette source
762 print"mon dico des sources=%s" %(self.dictSource)
763 except ValueError, err:
764 raise ValueError, str(err)
766 def generPOST_COMMANDS(self, obj):
768 print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
773 self.post_global = False
774 if obj.valeur.has_key('GLOBAL'):
775 self.post_global = True
776 if obj.valeur.has_key('VISU'):
778 self.visu_format=obj.valeur["VISU"]["VISU_Format"]
779 # self.visu_type=obj.valeur["VISU"]["VISU_Type"]
782 #---------------------------------------------------------------------------------------
783 # traitement fichier PHYS
784 #---------------------------------------------------------------------------------------
785 def generBLOC_VERSION(self,obj) :
786 # constitution du bloc VERSION du fichier PHYS
787 # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
788 # dans le du catalogue
789 version=obj.addentite('VERSION',pos=None)
790 self.generPROC_ETAPE(obj.etapes[0])
791 self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
792 for cle in obj.etapes[0].valeur :
793 self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
794 self.texteCarmel3D+="]\n"
795 # destruction de l entite creee
796 obj.suppentite(version)
797 #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
798 #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
801 def generBLOC_PARAMETERS(self,obj):
803 print "generation parameters obj.valeur = %s" % obj.valeur
805 self.identification = obj.valeur["Identification_du_Modele"]
806 self.fichierMaillage = obj.valeur["Fichier_maillage"]
807 self.echelleMaillage = obj.valeur["Echelle_du_maillage"]
809 self.kEpsilonDistance=obj.valeur["kEpsilonDistance"]
810 self.kdistanceRef=obj.valeur["kdistanceRef"]
811 self.jauge=obj.valeur["Jauge"]
812 self.NBoucleTemps=obj.valeur["Nb_pas_de_temps"]
813 self.dt=obj.valeur["Pas_de_temps"]
815 self.repertory=obj.valeur["RepCarmel"]
816 self.fcarmel=obj.valeur["Resoudre_probleme"]
817 self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
818 self.formulation=obj.valeur["Formulation"]
820 def generBLOC_SYMETRIE(self, obj):
822 print "generation de la symetrie obj.valeur = %s" % obj.valeur
825 self.listSymetrie.append(obj.valeur)
826 print"ma liste symetrie =%s" %(self.listSymetrie)
827 except ValueError, err:
828 raise ValueError, str(err)
829 #----------------------------------------------------------------------------------------
831 def generMOUVEMENT(self, obj):
833 print "generation du mouvement obj.valeur = %s" % obj.valeur
836 nom = obj.get_sdname()
837 self.nombreMouvements = self.nombreMouvements+1
838 self.dictMouvement[nom] = {'ordre': self.nombreMouvements, 'valeurs': obj.valeur}
839 self.dictMouvement['ordre'].append(nom)
841 print "self.dictMouvement =%s" %(self.dictMouvement)
842 print "self.nombreMouvements =%i" %(self.nombreMouvements)
843 except ValueError, err:
844 raise valueError, str(err)
845 #----------------------------------------------------------------------------------------
846 def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
847 """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
849 print "generation strand obj valeur = %s" % obj.valeur
851 nomStrand = obj.get_sdname()
852 self.dictStrand[nomStrand]=obj.valeur
853 print"mon dico des stranded inductor geometry=%s" %(self.dictStrand)
855 except ValueError, err:
856 raise ValueError, str(err)
858 def generPOST_TRAITEMENT(self, obj):
860 print "generation post traitement obj.valeur = %s" % obj.valeur
861 self.carteChamp=obj.valeur["Cartes_des_champs"]
862 self.carteCourantInduit=obj.valeur["Cartes_des_courants_induits"]
863 self.carteForce=obj.valeur["Cartes_des_forces"]
864 self.perteJoule=obj.valeur["Pertes_Joules"]
865 self.fluxInducteur=obj.valeur["Flux_par_inducteur"]
866 self.courantInducteur=obj.valeur["Courants_par_inducteur"]
867 self.tensionInducteur=obj.valeur["Tensions_par_inducteur"]
868 self.energie=obj.valeur["Energie"]
869 self.ForceCouple=obj.valeur["Forces_et_couple"]
870 self.fluxSpire=obj.valeur["Flux_par_spire"]
871 self.fluxGroupe=obj.valeur["Flux_par_groupe"]
872 self.ddpElect=obj.valeur["Tensions_electriques"]
873 self.ddpMagn=obj.valeur["DDP_magnetiques"]
874 self.fluxMagn=obj.valeur["Flux_magnetiques"]
875 self.fluxJinduitTotal=obj.valeur["Flux_J_induit"]
876 self.potFlottant=obj.valeur["Potentiel_Flottant"]
878 #-------------------------------------
879 # Methodes utilitaires
880 # ------------------------------------
881 def formateCOMPLEX(self,nbC):
882 """prise en compte des differentes formes de description d un nombre complexe
883 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
887 print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
889 if isinstance(nbC,(tuple,list)):
890 if nbC[0] == "'RI'" :
891 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
892 if nbC[0] == "'MP'" :
893 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
895 nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
897 print "nbformate : %s" % nbformate