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.
24 import types,string,re,os
25 from Extensions.i18n import tr
26 from generator_python import PythonGenerator
28 # Groupes de mailles dont les types sont definis par des prefixes dans leur nom
29 usePrefix = False # les noms ont des prefixes (True) ou non (False)
30 # liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
31 # Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
32 listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
33 "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
34 "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
35 "PORT_OMEGA","POST_PHI","PB_GRID",
36 "SCUTE","SCUTN","ZS","ZJ","ZT")
37 # liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
38 dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
39 'CONDUCTOR':('COND',),
40 'STRANDED_INDUCTOR':('CURRENT', ),
44 'ZINSULATOR':('ZJ', ),
45 'NILMAT':('NILMAT', )}
46 # separateur entre le prefixe et le reste du nom du groupe de maille
47 sepNomGroupeMaille = '_'
51 HARMONIC = 'HARMONIC' # probleme frequentiel
52 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
54 # nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
55 nomPlugin = 'CARMEL3DFV0'
59 Retourne les informations necessaires pour le chargeur de plugins
60 Ces informations sont retournees dans un dictionnaire
65 # La factory pour creer une instance du plugin
66 'factory' : CARMEL3DFV0Generator,
71 class CARMEL3DFV0Generator(PythonGenerator):
73 Ce generateur parcourt un objet de type JDC et produit
74 un texte au format eficas et
75 un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
78 # Les extensions de fichier permis?
81 #----------------------------------------------------------------------------------------
82 def gener(self,obj,format='brut',config=None):
88 # Cette instruction genere le contenu du fichier de commandes (persistance)
89 self.text=PythonGenerator.gener(self,obj,format)
92 print "self.text = %s" % self.text
94 # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
95 # si le jdc est valide (sinon cela n a pas de sens)
98 # constitution du bloc VERSION du fichier PHYS (existe toujours)
99 self.generBLOC_VERSION(obj)
100 # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
101 self.generBLOC_MATERIALS()
102 # constitution du bloc SOURCES du fichier PHYS (existe toujours)
103 self.generBLOC_SOURCES()
105 except ValueError, err:
106 raise ValueError(str(err))
108 # print "texte carmel3d :\n",self.texteCarmel3D
109 # print "dictMaterDielectric : ",self.dictMaterDielectric
111 print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
112 print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
119 #----------------------------------------------------------------------------------------
121 #----------------------------------------------------------------------------------------
124 self.texteCarmel3D=""
125 self.texteCarmel3D_PARAM=""
126 self.texteCarmel3D_PARAM_SOLV=""
127 self.texteCarmel3D_SH=""
128 self.texteCarmel3D_INFC=""
129 self.texteCarmel3D_CMD=""
130 self.texteCarmel3D_INGEND1=""
131 self.texteCarmel3D_INGEND2=""
132 self.texteCarmel3D_INGEND3=""
133 self.texteCarmel3D_INPOST=""
134 self.debug = True # affichage de messages pour deboguage (.true.) ou non
135 self.dicoEtapeCourant=None
136 self.dicoMCFACTCourant=None
137 self.dicoCourant=None
138 self.dictGroupes = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[], 'ordreStrandJdC':[], 'ordreListeJdC':[], 'ordreDomaineJdC':[]} # 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
139 self.dictMaterConductor={}
140 self.dictMaterDielectric={}
141 self.dictMaterZsurfacic={}
142 self.dictMaterEmIso={}
143 self.dictMaterEmAnIso={}
144 self.dictMaterNilmat={}
145 self.dictMaterZinsulator={}
146 self.dictSourceStInd={}
147 self.dictSourceEport={}
148 self.dictSourceHport={}
161 self.post_global=False
168 # on force le probleme a etre frequentiel, seul possible en l'etat des choses
169 self.problem = HARMONIC
170 self.fichierMaillage = "" # chemin absolu ou relatif du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
171 self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
172 self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
173 self.materiauxGroupesTousHomogenes = True # Tous les groupes sont associés a priori à des matériaux tous homogènes mais pas forcément isotropes. On le vérifie ou modifie ci-dessous.
174 self.materiauxGroupesTousIsotropes = True # Tous les groupes sont associés a priori à des matériaux tous isotropes mais pas forcément homogènes. On le vérifie ou modifie ci-dessous.
176 #----------------------------------------------------------------------------------------
178 #----------------------------------------------------------------------------------------
180 def writeDefault(self,fn) :
181 """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
183 # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
184 #file = fn[:fn.rfind(".")] # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
185 repertory=os.path.dirname(fn) # répertoire de l'étude, e.g., /home/toto/
186 file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
187 namefile=os.path.basename(file) # nom du projet e.g., foo
191 print "ecriture du fichier de parametres (PHYS)"
192 filePHYS = file + '.phys'
193 typeBloc = 'PHYS_FILES'
194 f = open( str(filePHYS), 'w')
195 f.write( self.texteCarmel3D)
200 print "ecriture du fichier de parametres (PARAM)"
201 filePARAM = file + '.param'
202 f = open( str(filePARAM), 'w')
203 f.write('[VERSION \n'
205 ' FILETYPE PARAM\n]\n'
207 ' NAME HARMONIC\n]\n'
209 typeBloc = 'CAR_FILES'
210 self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
211 self.texteCarmel3D_PARAM+=" NAME "+self.projet+".car"
212 self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
213 typeBloc = 'PHYS_FILES'
214 self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
215 self.texteCarmel3D_PARAM+=" NAME "+self.projet+".phys"
216 self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
217 self.texteCarmel3D_PARAM+="[FREQUENCY\n"
218 self.texteCarmel3D_PARAM+=" SINGLE %g \n" % (self.frequency )
219 self.texteCarmel3D_PARAM+="] \n"
220 f.write( self.texteCarmel3D_PARAM)
221 f.write(self.texteCarmel3D_PARAM_SOLV)
224 # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
226 print "ecriture du fichier de parametres (CMD)"
227 fileCMD =file + '.cmd'
228 f = open( str(fileCMD), 'w')
229 f.write(self.texteCarmel3D_CMD)
234 print "ecriture du fichier de parametres (INGENDOF)"
235 fileINGEND = file + '.ingendof'
236 f = open(fileINGEND, 'w')
237 self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
239 nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
242 #if self.dictDomaine !={}:
244 self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
245 except ValueError, err:
246 raise ValueError(str(err))
247 if self.dictPort != {} :
248 self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
249 if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
250 if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
251 f.write(self.texteCarmel3D_INGEND1)
252 f.write(self.texteCarmel3D_INGEND2)
253 f.write(self.texteCarmel3D_INGEND3)
257 print "ecriture du fichier de parametres (INFCARMEL) "
258 fileINFC = file + '.infcarmel'
259 f = open(fileINFC, 'w')
260 self.texteCarmel3D_INFC+= self.projet+".param"
261 f.write(self.texteCarmel3D_INFC)
265 print "ecriture du fichier de parametres (INPOSTPROCESS) "
266 fileINPOST = file + '.inpostprocess'
267 f = open(fileINPOST, 'w')
268 self.texteCarmel3D_INPOST+= self.projet+".param"
269 self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
270 self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
271 f.write(self.texteCarmel3D_INPOST)
274 print "dictionnaire complet=%s" %self.dictGroupes
275 print "dictionnaire des ports =%s" %self.dictPort
277 print "ecriture du fichier d'execution (SH)"
278 print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
279 RepCarmel= os.path.join(repertory,"lancer.sh")
280 f = open( str(RepCarmel), 'wb')
281 self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
282 if self.gendof=="TRUE":
283 self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
284 if self.echelle=="Millimetre":
285 self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
287 self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
288 if self.fcarmel=="TRUE":
289 self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
290 self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe < " + self.projet + ".infcarmel\n"
291 if self.postprocess=="TRUE":
292 self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
293 self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
294 f.write(self.texteCarmel3D_SH)
297 #----------------------------------------------------------------------------------------
298 # analyse de chaque noeud de l'arbre
299 #----------------------------------------------------------------------------------------
301 def generMCSIMP(self,obj) :
302 """recuperation de l objet MCSIMP"""
304 print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
305 s=PythonGenerator.generMCSIMP(self,obj)
306 self.dicoCourant[obj.nom]=obj.valeurFormatee
310 #----------------------------------------------------------------------------------------
311 def generMCFACT(self,obj) :
312 """recuperation de l objet MCFACT"""
314 self.dicoMCFACTCourant=dico
315 self.dicoCourant=self.dicoMCFACTCourant
316 s=PythonGenerator.generMCFACT(self,obj)
317 self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
318 self.dicoMCFACTCourant=None
319 self.dicoCourant=self.dicoEtapeCourant
323 #----------------------------------------------------------------------------------------
324 def generPROC_ETAPE(self,obj):
325 """analyse des PROC du catalogue ( VERSION )"""
327 self.dicoEtapeCourant=dico
328 self.dicoCourant=self.dicoEtapeCourant
329 s=PythonGenerator.generPROC_ETAPE(self,obj)
330 obj.valeur=self.dicoEtapeCourant
333 print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
334 s=PythonGenerator.generPROC_ETAPE(self,obj)
335 if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
336 if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
337 if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
342 #----------------------------------------------------------------------------------------
343 def generETAPE(self,obj):
344 """analyse des OPER du catalogue"""
346 self.dicoEtapeCourant=dico
347 self.dicoCourant=self.dicoEtapeCourant
348 s=PythonGenerator.generETAPE(self,obj)
349 obj.valeur=self.dicoEtapeCourant
351 print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
352 if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
353 if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
354 if obj.nom=="SOURCE" : self.generSOURCE(obj)
355 if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
356 if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
357 s=PythonGenerator.generETAPE(self,obj)
360 #----------------------------------------------------------------------------------------
361 def generMACRO_ETAPE(self,obj):
363 self.dicoEtapeCourant=dico
364 self.dicoCourant=self.dicoEtapeCourant
366 monGenerateur=generator.plugins[nomPlugin]()
367 jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
369 print "jdc_aux_texte : %s" % jdc_aux_texte
371 for cle in monGenerateur.dictMaterConductor:
372 self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
373 for cle in monGenerateur.dictMaterDielectric:
374 self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
375 for cle in monGenerateur.dictMaterZsurfacic:
376 self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
377 for cle in monGenerateur.dictMaterEmIso:
378 self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
379 for cle in monGenerateur.dictMaterEmAnIso:
380 self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
381 for cle in monGenerateur.dictMaterNilmat:
382 self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
383 for cle in monGenerateur.dictMaterZinsulator:
384 self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
386 print "________FIN MACRO______________________________________"
387 s=PythonGenerator.generMACRO_ETAPE(self,obj)
390 #----------------------------------------------------------------------------------------
391 #----------------------------------------------------------------------------------------
392 def generMESHGROUP(self,obj):
393 """preparation de la ligne NAME referencant le groupe de mailles
394 associe le groupe de mailles au materiau ou a la source utilisateur
395 on sauvegarde aussi les noms des groupes de maillage
399 nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
400 print "liste des noms sans prefixes %s" %(nomGroupe)
402 nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
403 print "liste des noms sans prefixes %s" %(nomGroupe)
405 # 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.
406 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
407 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
409 # on utilise le fait que obj.valeur est un dictionnaire
410 self.dictGroupes[nomGroupe] = {}
411 # nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
413 print "obj.valeur.keys()= %s" % obj.valeur.keys()
414 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
415 raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
416 # association a un materiau
417 if 'MATERIAL' in obj.valeur.keys():
418 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
419 self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
420 # association a une source
421 if 'SOURCE' in obj.valeur.keys():
422 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
423 self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
424 # erreur ni materiau ni source associee
425 if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
426 self.dictGroupes[nomGroupe]['STRAND'] = 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
427 self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
428 if 'Domaine' in obj.valeur.keys():
429 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
430 self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
432 texte+="%s"%(obj.valeur['Domaine'])
433 print"le texte=%s" %(texte)
434 self.dictDomaine[obj.get_sdname()]=texte
435 print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
438 # raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
440 print "self.dictGroupes= %s" % repr(self.dictGroupes)
441 except ValueError, err:
442 raise ValueError, str(err)
444 def generMACRO_GROUPE(self, obj):
445 """preparation de la ligne NAME referencant le groupe de mailles
446 associe le groupe de mailles au materiau ou a la source utilisateur
447 on sauvegarde aussi les noms des macros groupes
450 #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
452 nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
453 print "liste des noms sans prefixes %s" %(nomGroupe)
455 nomGroupe = obj.get_sdname() # nom du macro groupe
456 print "liste des noms sans prefixes %s" %(nomGroupe)
457 self.dictGroupes[nomGroupe] = {}
459 # 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.
460 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
461 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
463 # on utilise le fait que obj.valeur est un dictionnaire
465 print "obj.valeur.keys()= %s" % obj.valeur.keys()
466 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
467 raise ValueError,tr("Ce MACRO_GROUPE %s ne peut pas contenir a la fois un MATERIAL et une SOURCE." % nomGroupe)
468 # association a une source
469 if 'SOURCE' in obj.valeur.keys():
470 self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # 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
471 self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
472 # erreur ni materiau ni source associee
473 if 'LISTE_MESHGROUP' in obj.valeur.keys():
474 listeStrandedInductorGeometry = True # indicateur du fait que tous les groupes de la liste sont des inducteurs bobinés ou topologiques, en morceaux ou entier (True), ou non (False). Utilisé pour savoir si le Domaine est nécessaire ou non.
475 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
476 self.dictGroupes[nomGroupe]['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
477 for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
478 groupe = groupe.replace("'", "") # suppression des guillement simpes
479 groupe = groupe.replace('"', "") # suppression des guillement doubles
480 self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
481 if not self.dictGroupes[groupe].has_key('STRAND'): listeStrandedInductorGeometry = False # au moins un groupe de la liste n'est pas un inducteur bobiné ou topologique (morceau ou entier).
482 self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
483 if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
484 raise ValueError, tr(u"Le MACRO_GROUPE %s ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques." % nomGroupe)
485 # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
486 if 'Domaine' in obj.valeur.keys():
487 if listeStrandedInductorGeometry: # Domaine seulement en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
488 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
489 self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
491 texte+="%s"%(obj.valeur['Domaine'])
492 print"le texte=%s" %(texte)
493 self.dictDomaine[obj.get_sdname()]=texte
494 else: # Erreur si Domaine et macro-groupe pas complètement inducteur
495 raise ValueError, tr(u"Ce MACRO_GROUPE %s contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques. Il ne doit pas contenir de Domaine." % nomGroupe)
496 else: # Domaine manquant
497 if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
498 raise ValueError, tr(u"Ce MACRO_GROUPE %s de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine." % nomGroupe)
500 print "self.dictGroupes= %s" % repr(self.dictGroupes)
501 print "self.dictDomaine=%s" %(self.dictDomaine)
502 except ValueError, err:
503 raise ValueError, str(err)
506 def generSOLVEUR(self, obj):
508 print "generation material obj.valeur = %s" % obj.valeur
510 nature = obj.valeur['Type']
511 if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
512 except ValueError, err:
513 raise ValueError, str(err)
515 def generSOLVEUR_LINEAIRE(self, obj):
517 print "generation material obj.valeur = %s" % obj.valeur
519 nature = obj.valeur['Methode_lineaire']
520 if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
521 if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
522 except ValueError, err:
523 raise ValueError, str(err)
525 def generMETHODE_ITERATIVE_BICGCR(self, obj):
528 print "_____________iter_____________"
530 self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
531 self.texteCarmel3D_PARAM_SOLV+=" NAME BICGCR\n"
532 self.texteCarmel3D_PARAM_SOLV+=" [ITERATIVE_PARAM \n"
533 self.texteCarmel3D_PARAM_SOLV+=" NITERMAX "+str(obj.valeur["Nombre_iterations_max"])+"\n"
534 self.texteCarmel3D_PARAM_SOLV+=" EPSILON "+str(obj.valeur["Precision"])+"\n"
535 self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
537 print "texte = %s", texte
540 def generMETHODE_DIRECTE_MUMPS(self, obj):
543 print "_____________directe_____________"
545 self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
546 self.texteCarmel3D_PARAM_SOLV+=" NAME MUMPS\n"
547 self.texteCarmel3D_PARAM_SOLV+=" [MUMPS_PARAMETER \n"
548 self.texteCarmel3D_PARAM_SOLV+=" SYM "+str(obj.valeur["Type_de_matrice"])+"\n"
549 self.texteCarmel3D_PARAM_SOLV+=" ICNTL "+str(obj.valeur["ICNTL_Control_Parameters"])+" "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
550 self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
552 print "texte = %s", texte
556 def generMATERIAL(self,obj):
557 """preparation du bloc correspondant a un materiau du fichier PHYS"""
560 print "generation material obj.valeur = %s" % obj.valeur
562 nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
563 if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
564 if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
565 if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
566 if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
567 if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
568 if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
569 if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
570 except ValueError, err:
571 raise ValueError, str(err)
573 def generMATERIAL_CONDUCTOR(self,obj):
574 """preparation du sous bloc CONDUCTOR"""
577 print "_____________cond_____________"
578 # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
579 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
580 print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
581 raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
583 # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
584 for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
585 # debut du sous bloc de propriete du DIELECTRIC
586 texte+=" ["+keyN1+"\n"
587 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
588 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
589 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
590 # car sinon ces valeurs sont definies dans des fichiers annexes
591 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
592 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
593 if homogeneous and isotropic:
594 # loi (lineaire ou non)
595 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
596 # valeur de la loi lineaire
597 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
598 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
599 # seuls les reels sont pris en compte
600 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
601 texte+=" [NONLINEAR \n"
602 texte+=" ISOTROPY TRUE\n"
603 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
604 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
605 for keyN2 in obj.valeur[keyN1] :
606 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
607 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
608 # fin du sous-bloc NONLINEAR
610 # fin du sous bloc de propriete
613 print "texte = %s", texte
614 self.dictMaterConductor[obj.get_sdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
616 def generMATERIAL_DIELECTRIC(self,obj):
617 """preparation du sous bloc DIELECTRIC"""
620 print "______________nocond_____________"
621 # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
622 if 'PERMITTIVITY' not in obj.valeur:
623 print "obj.valeur=%s" %obj.valeur
624 obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
626 # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
627 for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
628 # debut du sous bloc de propriete du DIELECTRIC
629 texte+=" ["+keyN1+"\n"
630 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
631 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
632 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
633 # car sinon ces valeurs sont definies dans des fichiers annexes
634 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
635 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
636 if homogeneous and isotropic:
637 # loi (lineaire ou non)
638 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
639 # valeur de la loi lineaire
640 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
641 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
642 # seuls les reels sont pris en compte
643 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
644 texte+=" [NONLINEAR \n"
645 texte+=" ISOTROPY TRUE\n"
646 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
647 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
648 for keyN2 in obj.valeur[keyN1] :
649 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
650 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
651 # fin du sous-bloc NONLINEAR
653 # fin du sous bloc de propriete
656 print "texte = %s" % texte
657 self.dictMaterDielectric[obj.get_sdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
659 def generMATERIAL_ZSURFACIC(self,obj):
660 """preparation du sous bloc ZSURFACIC"""
663 print "______________zsurf_____________"
664 # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
665 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
666 print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
667 raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
669 # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
670 for keyN1 in obj.valeur :
671 if keyN1=='TYPE': continue
672 # print "type loi = ", obj.valeur[keyN1]['LAW']
673 # debut du sous bloc de propriete du DIELECTRIC
674 texte+=" ["+keyN1+"\n"
675 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
676 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
677 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
678 # car sinon ces valeurs sont definies dans des fichiers annexes
679 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
680 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
681 if homogeneous and isotropic:
682 # loi (lineaire ou non)
683 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
684 # valeur de la loi lineaire
685 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
686 # fin du sous bloc de propriete
689 print "texte = %s", texte
690 self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
692 def generMATERIAL_EMISO(self,obj):
693 """preparation du sous bloc EM_ISOTROPIC_FILES.
694 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
695 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
697 if "CONDUCTIVITY_File" in obj.valeur:
698 texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
699 if "PERMEABILITY_File" in obj.valeur:
700 texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
701 # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
702 #from os.path import basename
703 #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
704 #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
705 # print "obj get sdname= ", obj.get_sdname()
706 # if obj.get_sdname() in self.dictMaterEmIso.keys() :
707 # self.dictMaterEmIso[obj.get_sdname()].append(texte)
709 self.dictMaterEmIso[obj.get_sdname()]=texte
711 def generMATERIAL_EMANISO(self,obj):
712 """preparation du sous bloc EM_ANISOTROPIC_FILES.
713 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
714 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
716 if "CONDUCTIVITY_File" in obj.valeur:
717 texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
718 if "PERMEABILITY_File" in obj.valeur:
719 texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
720 # print "obj get sdname= ", obj.get_sdname()
721 # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
722 # self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
724 self.dictMaterEmAnIso[obj.get_sdname()]=texte
726 def generMATERIAL_NILMAT(self,obj):
727 """preparation du sous bloc NILMAT"""
729 self.dictMaterNilmat[obj.get_sdname()]=texte
731 def generMATERIAL_ZINSULATOR(self,obj):
732 """"preparation du sous bloc ZINSULATOR"""
734 self.dictMaterZinsulator[obj.get_sdname()]=texte
736 #-------------------------------------------------------------------
738 def generSOURCE(self,obj):
739 """preparation du bloc correspondant a une source du fichier PHYS"""
741 print "generation source obj valeur = %s" % obj.valeur
744 # test de la presence des types de sources reconnus
745 # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
746 # la source ne peut contenir au plus qu'un type de source.
747 if "STRANDED_INDUCTOR" in obj.valeur:
748 self.generSOURCE_STRANDED_INDUCTOR(obj)
749 elif "HPORT" in obj.valeur:
750 self.generSOURCE_HPORT(obj)
751 elif "EPORT" in obj.valeur:
752 self.generSOURCE_EPORT(obj)
754 print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
755 except ValueError, err:
756 raise ValueError, str(err)
758 def generSOURCE_STRANDED_INDUCTOR(self,obj):
759 """preparation du sous bloc STRANDED_INDUCTOR"""
761 sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
763 texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
764 self.nturns=sdict['NTURNS']
765 # test de la presence d'une forme de source reconnue
766 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
767 # la source ne peut contenir au plus qu'un type de source.
768 if "WAVEFORM_CONSTANT" in obj.valeur:
769 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
770 if self.problem == HARMONIC:
771 texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
772 print tr("ATTENTION! Une source constante \
773 n'est possible qu'a frequence nulle \
774 en regime frequentiel")
775 elif "WAVEFORM_SINUS" in obj.valeur:
776 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
777 if self.problem == HARMONIC:
778 texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
779 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
781 print tr("ERREUR! Une forme de la source du \
782 type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
783 self.dictSourceStInd[obj.get_sdname()]=texte
786 except ValueError, err:
787 raise ValueError, str(err)
789 def generSOURCE_HPORT(self,obj):
790 """preparation du sous bloc HPORT"""
792 sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
793 nomPort = obj.get_sdname()
794 self.dictPort[nomPort] = {}
795 self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
797 texte+=" TYPE %s\n" % str(sdict['TYPE'])
798 # test de la presence d'une forme de source reconnue
799 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
800 # la source ne peut contenir au plus qu'un type de source.
801 if "WAVEFORM_CONSTANT" in obj.valeur:
802 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
803 if self.problem == HARMONIC:
804 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
805 print tr("ATTENTION! Une source constante n'est \
806 possible qu'a frequence nulle en regime frequentiel")
807 elif "WAVEFORM_SINUS" in obj.valeur:
808 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
809 if self.problem == HARMONIC:
810 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
811 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
813 print tr("ERREUR! Une forme de la source du type \
814 WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
815 self.dictSourceHport[obj.get_sdname()]=texte
818 except ValueError, err:
819 raise ValueError, str(err)
821 def generSOURCE_EPORT(self,obj):
824 """preparation du sous bloc EPORT"""
826 sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
827 nomPort = obj.get_sdname()
828 self.dictPort[nomPort] = {}
829 self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
830 print "sdict=%s" %(sdict)
832 texte+=" TYPE %s\n" % str(sdict['TYPE'])
833 # test de la presence d'une forme de source reconnue
834 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
835 # la source ne peut contenir au plus qu'un type de source.
836 if "WAVEFORM_CONSTANT" in obj.valeur:
837 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
838 if self.problem == HARMONIC:
839 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
840 print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
841 elif "WAVEFORM_SINUS" in obj.valeur:
842 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
843 if self.problem == HARMONIC:
844 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
845 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
847 print tr("ERREUR! Une forme de la source du type \
848 WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
849 self.dictSourceEport[obj.get_sdname()]=texte
852 except ValueError, err:
853 raise ValueError, str(err)
856 def generPARAM_CIRCULAIRE(self, obj):
858 print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
859 self.centre=obj.valeur["Centre"]
861 def generPOST_COMMANDS(self, obj):
862 """Création du texte de commandes de post-traitement toto.cmd"""
864 print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
866 if obj.valeur.has_key('GLOBAL'):
867 self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
868 if obj.valeur.has_key('VISU'):
869 self.texteCarmel3D_CMD+="[\nVISU"
870 # test de fichier de maillage bien lu
871 if self.fichierMaillage == "": raise ValueError, tr("ERREUR! Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au dessus du bloc POST_COMMANDS.")
872 self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
873 self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Format"]+"\n"
874 self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Type"]+"\n]\n"
875 if obj.valeur.has_key('CUTLINE'):
876 champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
877 self.texteCarmel3D_CMD+="[\nCUTLINE"
878 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["first_point"]))
879 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["last_point"]))
880 self.texteCarmel3D_CMD+="\n%d" % (obj.valeur["CUTLINE"]["number_of_points"], )
881 self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTLINE"]["name"]
882 # création du champ, renommé par rapport à l'interface
883 self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTLINE"]["field"]]
884 self.texteCarmel3D_CMD+="\n]\n"
885 if obj.valeur.has_key('CUTPLANE'):
886 champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
887 axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
888 self.texteCarmel3D_CMD+="[\nCUTPLANE"
889 self.texteCarmel3D_CMD+="\n%d" % (axes[obj.valeur["CUTPLANE"]["normal_vector"]], )
890 self.texteCarmel3D_CMD+="\n%f" % (obj.valeur["CUTPLANE"]["plane_position"], )
891 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTPLANE"]["number_of_points"]))
892 self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTPLANE"]["name"]
893 self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTPLANE"]["field"]]
894 self.texteCarmel3D_CMD+="\n]\n"
897 #---------------------------------------------------------------------------------------
898 # traitement fichier PHYS
899 #---------------------------------------------------------------------------------------
900 def generBLOC_VERSION(self,obj) :
901 # constitution du bloc VERSION du fichier PHYS
902 # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
903 # dans le du catalogue
904 version=obj.addentite('VERSION',pos=None)
905 self.generPROC_ETAPE(obj.etapes[0])
906 self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
907 for cle in obj.etapes[0].valeur :
908 self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
909 self.texteCarmel3D+="]\n"
910 # destruction de l entite creee
911 obj.suppentite(version)
912 #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
913 #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
916 def generBLOC_PARAMETERS(self,obj):
918 print "generation parameters obj.valeur = %s" % obj.valeur
920 self.frequency=obj.valeur["FREQUENCY"]
921 self.repertory=obj.valeur["RepCarmel"]
922 self.fichierMaillage=obj.valeur["Fichier_maillage"]
923 self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
924 self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
925 self.echelle=obj.valeur["Echelle_du_maillage"]
926 self.gendof=obj.valeur["Realiser_topologie_gendof"]
927 self.fcarmel=obj.valeur["Resoudre_probleme"]
928 self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
929 self.formulation=obj.valeur["Formulation"]
930 #----------------------------------------------------------------------------------------
931 def generBLOC_MATERIALS(self) :
932 """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
933 Le bloc MATERIALS existe toujours !
936 print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
937 print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
938 # constitution du bloc MATERIALS du fichier PHYS
939 self.texteCarmel3D+="[MATERIALS\n"
940 # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
941 nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
942 nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
944 print "noms groupes de mailles associes a des materiaux \
945 (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
946 {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
948 try: # mise à jour du fichier .phys selon les matériaux trouvés
949 # constitution du bloc CONDUCTOR du fichier PHYS si existe
950 if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
951 # constitution du bloc DIELECTRIC du fichier PHYS si exixte
952 if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
953 # constitution du bloc ZSURFACIC du fichier PHYS si exixte
954 if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
955 # constitution du bloc NILMAT du fichier PHYS si exixte
956 if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
957 # constitution du bloc ZINSULATOR du fichier PHYS si exixte
958 if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
959 # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
960 # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
961 if self.dictMaterEmIso != {} and self.materiauxGroupesTousIsotropes and not self.materiauxGroupesTousHomogenes : self.creaBLOC_EMISO() # bloc isotrope si au moins un matériau isotrope et non homogene
962 # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
963 if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
964 except ValueError, err:
965 raise ValueError(str(err))
968 # fin du bloc MATERIALS du fichier PHYS
969 self.texteCarmel3D+="]\n"
973 def creaBLOC_CONDUCTOR(self, nomsGroupes) :
974 """Constitution du bloc CONDUCTOR du fichier PHYS"""
975 typeBloc = 'CONDUCTOR' # initialisation du type de bloc
976 dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
978 print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
979 for nom in nomsGroupes: # parcours des noms des groupes de maillage
980 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
981 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
982 print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
983 raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom))
984 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
985 or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
986 self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
987 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
988 or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
989 self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
990 # ecriture du bloc complet
991 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
993 nomReel = self.nomReelGroupe(nom, typeBloc)
996 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
997 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
998 self.texteCarmel3D+=" ]\n" # fin de bloc
1000 def creaBLOC_DIELECTRIC(self, nomsGroupes) :
1001 """Constitution du bloc DIELECTRIC du fichier PHYS"""
1002 typeBloc = 'DIELECTRIC' # initialisation du type de bloc
1003 dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
1005 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1006 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1007 print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
1008 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1009 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
1010 print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
1011 raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom))
1012 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
1013 self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
1014 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
1015 self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
1016 # ecriture du bloc complet
1017 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1018 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
1019 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
1020 self.texteCarmel3D+=" ]\n" # fin de bloc
1022 def creaBLOC_ZSURFACIC(self, nomsGroupes) :
1023 """Constitution du bloc ZSURFACIC du fichier PHYS"""
1024 typeBloc = 'ZSURFACIC' # initialisation du type de bloc
1025 dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
1027 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1028 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1029 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1030 # ecriture du bloc complet
1031 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1033 nomReel = self.nomReelGroupe(nom, typeBloc)
1036 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1037 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
1038 self.texteCarmel3D+=" ]\n" # fin de bloc
1040 def creaBLOC_EMISO(self) :
1041 """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
1042 for cle in self.dictMaterEmIso.keys():
1043 self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
1044 self.texteCarmel3D+= self.dictMaterEmIso[cle]
1045 self.texteCarmel3D+=" ]\n"
1047 def creaBLOC_EMANISO(self) :
1048 """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
1049 for cle in self.dictMaterEmAnIso.keys():
1050 self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
1051 self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
1052 self.texteCarmel3D+=" ]\n"
1054 def creaBLOC_ZINSULATOR(self, nomsGroupes) :
1055 """Constitution du bloc ZINSULATOR du fichier PHYS"""
1056 typeBloc = 'ZINSULATOR' # initialisation du type de bloc
1057 dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
1058 if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
1059 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1060 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1061 # ecriture du bloc complet
1062 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1064 nomReel = self.nomReelGroupe(nom, typeBloc)
1067 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1068 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
1069 self.texteCarmel3D+=" ]\n" # fin de bloc
1071 def creaBLOC_NILMAT(self, nomsGroupes) :
1072 """Constitution du bloc NILMAT du fichier PHYS"""
1073 typeBloc = 'NILMAT' # initialisation du type de bloc
1074 dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
1076 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1077 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1078 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1079 # ecriture du bloc complet
1080 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1082 nomReel = self.nomReelGroupe(nom, typeBloc)
1085 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1086 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
1087 self.texteCarmel3D+=" ]\n" # fin de bloc
1089 #----------------------------------------------------------------------------------------
1090 def generBLOC_SOURCES(self):
1091 """constitution du bloc SOURCES du fichier PHYS"""
1092 self.texteCarmel3D+="[SOURCES\n"
1093 # # tri alphabetique de tous les groupes de maillage associes a des sources
1094 nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
1096 # print "RESULTAT APRES FUSION self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
1099 print 'noms groupes de mailles associes a des sources \
1100 (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
1101 {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
1102 'g_maillage_trie': nomsGroupes}
1103 if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
1104 if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
1105 if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
1106 # fin du bloc SOURCES du fichier PHYS
1107 self.texteCarmel3D+="]\n"
1110 def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
1111 """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
1113 print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
1114 typeBloc = 'STRANDED_INDUCTOR'
1115 # print "liste des NOM=%s" %(nom)
1116 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1117 if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
1118 # ecriture du bloc de l'inducteur bobine
1119 self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
1120 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
1121 self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
1122 self.texteCarmel3D+=" ]\n" # fin de bloc
1124 def creaBLOC_EPORT(self, nomsGroupes) :
1125 """constitution du bloc EPORT du fichier PHYS"""
1127 print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
1129 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1130 if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
1131 # ecriture du bloc du port electrique
1132 self.texteCarmel3D+=" [EPORT\n" # debut de bloc
1134 nomReel = self.nomReelGroupe(nom, typeBloc)
1137 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1138 self.texteCarmel3D+= self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
1139 self.texteCarmel3D+=" ]\n" # fin de bloc
1141 def creaBLOC_HPORT(self, nomsGroupes) :
1142 """constitution du bloc HPORT du fichier PHYS"""
1144 print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
1146 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1147 if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
1148 # ecriture du bloc du port magnetique
1149 self.texteCarmel3D+=" [HPORT\n" # debut de bloc
1151 nomReel = self.nomReelGroupe(nom, typeBloc)
1154 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1155 self.texteCarmel3D+= self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
1156 self.texteCarmel3D+=" ]\n" # fin de bloc
1158 def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
1159 """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
1162 self.direction=obj.valeur["Direction"]
1163 self.section=obj.valeur["Section"]
1164 self.forme=obj.valeur["Forme"]
1165 # texte+="\n%s" %(self.domaine)
1167 if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
1170 texte+="\n%s" % ' '.join(map(str, self.direction))
1171 texte+="\n%g" % (self.section)
1172 self.dictStrand[obj.get_sdname()]=texte
1176 def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
1178 self.centre=obj.valeur["Centre"]
1180 texte+="\n%s" % ' '.join(map(str,self.direction))
1181 texte+="\n%s" % ' '.join(map(str, self.centre))
1182 texte+="\n%g" % (self.section)
1183 self.dictStrand[obj.get_sdname()]=texte
1188 def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
1189 """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
1190 Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
1193 print 'dictGroupes=', self.dictGroupes
1194 print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
1195 print "nomsGroupes=%s" %(nomsGroupes)
1196 nomsSources=self.dictGroupes['ordreDomaineJdC']
1197 nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
1198 if self.debug: print"nomsSources=%s" %nomsSources
1199 for nom in nomsSources:
1200 if self.debug: print "nomSource courant=",nom
1201 if self.dictGroupes[nom].has_key('SOURCE'):
1202 if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
1203 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
1204 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1206 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
1207 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1208 if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
1209 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
1210 strand = self.dictGroupes[nom]['STRAND']
1211 if self.debug: print "un seul morceau : nomStrand courant=", strand
1212 self.texteCarmel3D_INGEND2+= self.dictStrand[strand]
1213 if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
1214 listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
1215 for strand in listeStrand:
1216 #strand = strand.replace("'", "") # suppression des guillemets simples
1217 if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
1218 if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
1219 self.texteCarmel3D_INGEND2+= self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
1221 def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
1223 print "self.dictSourceEport=", self.dictSourceEport
1224 print "self.dictSourceHport=", self.dictSourceHport
1225 nomsSources=self.dictGroupes['ordreDomaineJdC']
1226 nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
1228 for nom in nomsSources:
1229 port=self.dictGroupes[nom]['SOURCE']
1230 if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
1231 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1232 port=self.dictGroupes[nom]['SOURCE']
1234 if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
1235 if self.dictPort[port]['EPORT']=="VOLTAGE":
1236 self.texteCarmel3D_INGEND2+= "\n1"
1238 self.texteCarmel3D_INGEND2+= "\n2"
1239 if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
1240 if self.dictPort[port]['HPORT']=="VOLTAGE":
1241 self.texteCarmel3D_INGEND2+= "\n1"
1243 self.texteCarmel3D_INGEND2+= "\n2"
1245 #-------------------------------------
1246 # Methodes utilitaires
1247 # ------------------------------------
1248 def formateCOMPLEX(self,nbC):
1249 """prise en compte des differentes formes de description d un nombre complexe
1250 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
1254 print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
1256 if isinstance(nbC,(tuple,list)):
1257 if nbC[0] == "'RI'" :
1258 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
1259 if nbC[0] == "'MP'" :
1260 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
1262 nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
1264 print "nbformate : %s" % nbformate
1267 def nomReelGroupe(self, nom, typeBloc=None):
1268 """Calcule et retourne le nom reel du groupe de maillage donne en entree,
1269 en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
1270 de bloc du fichier PHYS specifie.
1271 Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
1273 from string import join
1275 print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
1276 {'nom': nom, 'use_prefix': str(usePrefix)}
1277 nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
1279 # suppression du prefixe si present
1280 partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
1281 # les tests suivants ne generent une erreur que si le prefixe est obligatoire
1282 if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
1283 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
1284 indiquant le type de materiau ou de source associee", nom)
1285 elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
1286 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
1288 # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
1289 if typeBloc is not None:
1290 if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
1291 print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
1292 elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
1293 print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
1294 le prefixe correct pour etre associe a un type %(type_bloc)s", \
1295 {'nom': nom, 'type_bloc': str(typeBloc)})
1297 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1299 print "ce groupe de maille (%(nom)s) a un prefixe qui \
1300 est supprime automatiquement pour devenir : %(nom_reel)s", \
1301 {'nom': nom, 'nom_reel': nomReel}
1303 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1305 print "ce groupe de maille (%(nom)s) a un prefixe qui \
1306 est supprime automatiquement pour devenir : %(nom_reel)s", \
1307 {'nom': nom, 'nom_reel': nomReel}
1309 print "... %s", nomReel