1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2021 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 = '_'
50 HARMONIC = 'HARMONIC' # probleme frequentiel
51 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
55 Retourne les informations necessaires pour le chargeur de plugins
56 Ces informations sont retournees dans un dictionnaire
61 # La factory pour creer une instance du plugin
62 'factory' : CARMEL3DGenerator,
66 class CARMEL3DGenerator(PythonGenerator):
68 Ce generateur parcourt un objet de type JDC et produit
69 un texte au format eficas et
70 un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
73 # Les extensions de fichier permis?
76 #----------------------------------------------------------------------------------------
77 def gener(self,obj,format='brut',config=None):
81 # Cette instruction genere le contenu du fichier de commandes (persistance)
82 self.text=PythonGenerator.gener(self,obj,format)
85 print "self.text = %s", self.text
87 # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
88 # si le jdc est valide (sinon cela n a pas de sens)
90 # constitution du bloc VERSION du fichier PHYS (existe toujours)
92 self.generBLOC_VERSION(obj)
93 except ValueError, err:
94 raise ValueError(str(err))
96 # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
97 self.generBLOC_MATERIALS()
99 # constitution du bloc SOURCES du fichier PHYS (existe toujours)
100 self.generBLOC_SOURCES()
102 # print "texte carmel3d :\n",self.texteCarmel3D
103 # print "dictMaterDielectric : ",self.dictMaterDielectric
105 print "dictMaterConductor : %s", repr(self.dictMaterConductor)
110 #----------------------------------------------------------------------------------------
112 #----------------------------------------------------------------------------------------
116 self.texteCarmel3D=""
117 self.debug = True # affichage de messages pour deboguage (.true.) ou non
118 self.dicoEtapeCourant=None
119 self.dicoMCFACTCourant=None
120 self.dicoCourant=None
121 self.dictGroupesMaillage = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[]} # 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
122 self.dictMaterConductor={}
123 self.dictMaterDielectric={}
124 self.dictMaterZsurfacic={}
125 self.dictMaterEmIso={}
126 self.dictMaterEmAnIso={}
127 self.dictMaterNilmat={}
128 self.dictMaterZinsulator={}
129 self.dictSourceStInd={}
130 self.dictSourceEport={}
131 self.dictSourceHport={}
132 # on force le probleme a etre frequentiel, seul possible en l'etat des choses
133 self.problem = HARMONIC
136 #----------------------------------------------------------------------------------------
138 #----------------------------------------------------------------------------------------
140 def writeDefault(self,fn) :
141 """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""
143 print "ecriture du fichier de parametres (PHYS)"
144 filePHYS = fn[:fn.rfind(".")] + '.phys'
145 f = open( str(filePHYS), 'wb')
146 f.write( self.texteCarmel3D)
149 #----------------------------------------------------------------------------------------
150 # analyse de chaque noeud de l'arbre
151 #----------------------------------------------------------------------------------------
153 def generMCSIMP(self,obj) :
154 """recuperation de l objet MCSIMP"""
156 print "MCSIMP %(v_1)s %(v_2)s", {'v_1': obj.nom, "v_2": obj.valeur}
157 s=PythonGenerator.generMCSIMP(self,obj)
158 self.dicoCourant[obj.nom]=obj.valeurFormatee
162 #----------------------------------------------------------------------------------------
163 def generMCFACT(self,obj) :
164 """recuperation de l objet MCFACT"""
166 self.dicoMCFACTCourant=dico
167 self.dicoCourant=self.dicoMCFACTCourant
168 s=PythonGenerator.generMCFACT(self,obj)
169 self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
170 self.dicoMCFACTCourant=None
171 self.dicoCourant=self.dicoEtapeCourant
174 #----------------------------------------------------------------------------------------
175 def generPROC_ETAPE(self,obj):
176 """analyse des PROC du catalogue ( VERSION )"""
178 self.dicoEtapeCourant=dico
179 self.dicoCourant=self.dicoEtapeCourant
180 s=PythonGenerator.generPROC_ETAPE(self,obj)
181 obj.valeur=self.dicoEtapeCourant
183 print "PROC_ETAPE %(v_1)s %(v_2)s", \
184 {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
185 s=PythonGenerator.generPROC_ETAPE(self,obj)
188 #----------------------------------------------------------------------------------------
189 def generETAPE(self,obj):
190 """analyse des OPER du catalogue"""
192 self.dicoEtapeCourant=dico
193 self.dicoCourant=self.dicoEtapeCourant
194 s=PythonGenerator.generETAPE(self,obj)
195 obj.valeur=self.dicoEtapeCourant
197 print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s", \
198 {'v_1': obj.nom, 'v_2': obj.valeur}
199 if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
200 if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
201 if obj.nom=="SOURCE" : self.generSOURCE(obj)
202 s=PythonGenerator.generETAPE(self,obj)
205 #----------------------------------------------------------------------------------------
206 def generMACRO_ETAPE(self,obj):
208 self.dicoEtapeCourant=dico
209 self.dicoCourant=self.dicoEtapeCourant
211 monGenerateur=generator.plugins["CARMEL3D"]()
212 jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
214 print "jdc_aux_texte : %s", jdc_aux_texte
216 for cle in monGenerateur.dictMaterConductor:
217 self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
218 for cle in monGenerateur.dictMaterDielectric:
219 self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
220 for cle in monGenerateur.dictMaterZsurfacic:
221 self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
222 for cle in monGenerateur.dictMaterEmIso:
223 self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
224 for cle in monGenerateur.dictMaterEmAnIso:
225 self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
226 for cle in monGenerateur.dictMaterNilmat:
227 self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
228 for cle in monGenerateur.dictMaterZinsulator:
229 self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
231 print "________FIN MACRO______________________________________"
232 s=PythonGenerator.generMACRO_ETAPE(self,obj)
235 #----------------------------------------------------------------------------------------
236 #----------------------------------------------------------------------------------------
237 def generMESHGROUP(self,obj):
238 """preparation de la ligne NAME referencant le groupe de mailles
239 associe le groupe de mailles au materiau ou a la source utilisateur
240 on sauvegarde aussi les noms des groupes de maillage
245 nomGroupeMaillage = self.nomReelGroupeMaillage(obj.getSdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
247 nomGroupeMaillage = obj.getSdname() # nom du groupe de maillage, i.e. nom du concept
248 # 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.
249 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
250 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage
252 # on utilise le fait que obj.valeur est un dictionnaire
254 print "obj.valeur.keys()= %s", obj.valeur.keys()
255 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
256 raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source.", nomGroupeMaillage)
257 # association a un materiau
258 if 'MATERIAL' in obj.valeur.keys():
259 self.dictGroupesMaillage[nomGroupeMaillage] = 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
260 self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
261 # association a une source
262 elif 'SOURCE' in obj.valeur.keys():
263 self.dictGroupesMaillage[nomGroupeMaillage] = 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
264 self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
265 # erreur ni materiau ni source associee
267 raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau ou source.", nomGroupeMaillage)
269 print "self.dictGroupesMaillage= %s", repr(self.dictGroupesMaillage)
274 def generMATERIAL(self,obj):
275 """preparation du bloc correspondant a un materiau du fichier PHYS"""
278 print "generation material obj valeur = %s", obj.valeur
280 nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
281 if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
282 if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
283 if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
284 if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
285 if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
286 if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
287 if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
291 def generMATERIAL_CONDUCTOR(self,obj):
292 """preparation du sous bloc CONDUCTOR"""
295 print "_____________cond_____________"
296 # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
297 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
298 print "ERREUR! Le bloc CONDUCTOR doit contenir PERMEABILITY et CONDUCTIVITY."
300 # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
301 for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
302 # debut du sous bloc de propriete du DIELECTRIC
303 texte+=" ["+keyN1+"\n"
304 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
305 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
306 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
307 # car sinon ces valeurs sont definies dans des fichiers annexes
308 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
309 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
310 if homogeneous and isotropic:
311 # loi (lineaire ou non)
312 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
313 # valeur de la loi lineaire
314 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
315 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
316 # seuls les reels sont pris en compte
317 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
318 texte+=" [NONLINEAR \n"
319 texte+=" ISOTROPY TRUE\n"
320 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
321 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
322 for keyN2 in obj.valeur[keyN1] :
323 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
324 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
325 # fin du sous-bloc NONLINEAR
327 # fin du sous bloc de propriete
330 print "texte = %s", texte
331 self.dictMaterConductor[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
333 def generMATERIAL_DIELECTRIC(self,obj):
334 """preparation du sous bloc DIELECTRIC"""
337 print "______________nocond_____________"
338 # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
339 if 'PERMEABILITY' not in obj.valeur or 'PERMITTIVITY' not in obj.valeur:
340 print "ERREUR! Le bloc DIELECTRIC doit contenir PERMEABILITY et PERMITTIVITY."
342 # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
343 for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
344 # debut du sous bloc de propriete du DIELECTRIC
345 texte+=" ["+keyN1+"\n"
346 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
347 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
348 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
349 # car sinon ces valeurs sont definies dans des fichiers annexes
350 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
351 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
352 if homogeneous and isotropic:
353 # loi (lineaire ou non)
354 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
355 # valeur de la loi lineaire
356 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
357 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
358 # seuls les reels sont pris en compte
359 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
360 texte+=" [NONLINEAR \n"
361 texte+=" ISOTROPY TRUE\n"
362 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
363 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
364 for keyN2 in obj.valeur[keyN1] :
365 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
366 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
367 # fin du sous-bloc NONLINEAR
369 # fin du sous bloc de propriete
372 print "texte = %s", texte
373 self.dictMaterDielectric[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
375 def generMATERIAL_ZSURFACIC(self,obj):
376 """preparation du sous bloc ZSURFACIC"""
379 print "______________zsurf_____________"
380 # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
381 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
382 print "ERREUR! Le bloc ZSURFACIC doit contenir PERMEABILITY et CONDUCTIVITY."
384 # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
385 for keyN1 in obj.valeur :
386 if keyN1=='TYPE': continue
387 # print "type loi = ", obj.valeur[keyN1]['LAW']
388 # debut du sous bloc de propriete du DIELECTRIC
389 texte+=" ["+keyN1+"\n"
390 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
391 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
392 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
393 # car sinon ces valeurs sont definies dans des fichiers annexes
394 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
395 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
396 if homogeneous and isotropic:
397 # loi (lineaire ou non)
398 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
399 # valeur de la loi lineaire
400 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
401 # fin du sous bloc de propriete
404 print "texte = %s", texte
405 self.dictMaterZsurfacic[obj.getSdname()]=texte # sauvegarde du texte pour ce bloc
407 def generMATERIAL_EMISO(self,obj):
408 """preparation du sous bloc EM_ISOTROPIC_FILES.
409 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
410 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
412 texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
413 texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
414 # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
415 #from os.path import basename
416 #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
417 #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
418 # print "obj get sdname= ", obj.getSdname()
419 # if obj.getSdname() in self.dictMaterEmIso.keys() :
420 # self.dictMaterEmIso[obj.getSdname()].append(texte)
422 self.dictMaterEmIso[obj.getSdname()]=texte
424 def generMATERIAL_EMANISO(self,obj):
425 """preparation du sous bloc EM_ANISOTROPIC_FILES.
426 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
427 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
429 texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
430 texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
431 # print "obj get sdname= ", obj.getSdname()
432 # if obj.getSdname() in self.dictMaterEmAnIso.keys() :
433 # self.dictMaterEmAnIso[obj.getSdname()].append(texte)
435 self.dictMaterEmAnIso[obj.getSdname()]=texte
437 def generMATERIAL_NILMAT(self,obj):
438 """preparation du sous bloc NILMAT"""
440 self.dictMaterNilmat[obj.getSdname()]=texte
442 def generMATERIAL_ZINSULATOR(self,obj):
443 """"preparation du sous bloc ZINSULATOR"""
445 self.dictMaterZinsulator[obj.getSdname()]=texte
447 #-------------------------------------------------------------------
449 def generSOURCE(self,obj):
450 """preparation du bloc correspondant a une source du fichier PHYS"""
452 print "generation source obj valeur = %s", obj.valeur
455 # test de la presence des types de sources reconnus
456 # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
457 # la source ne peut contenir au plus qu'un type de source.
458 if "STRANDED_INDUCTOR" in obj.valeur:
459 self.generSOURCE_STRANDED_INDUCTOR(obj)
460 elif "HPORT" in obj.valeur:
461 self.generSOURCE_HPORT(obj)
462 elif "EPORT" in obj.valeur:
463 self.generSOURCE_EPORT(obj)
465 print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
469 def generSOURCE_STRANDED_INDUCTOR(self,obj):
470 """preparation du sous bloc STRANDED_INDUCTOR"""
472 sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
474 texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
475 # test de la presence d'une forme de source reconnue
476 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
477 # la source ne peut contenir au plus qu'un type de source.
478 if "WAVEFORM_CONSTANT" in obj.valeur:
479 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
480 if self.problem == HARMONIC:
481 texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
482 print tr("ATTENTION! Une source constante \
483 n'est possible qu'a frequence nulle \
484 en regime frequentiel")
485 elif "WAVEFORM_SINUS" in obj.valeur:
486 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
487 if self.problem == HARMONIC:
488 texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
489 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
491 print tr("ERREUR! Une forme de la source du \
492 type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
493 self.dictSourceStInd[obj.getSdname()]=texte
499 def generSOURCE_HPORT(self,obj):
500 """preparation du sous bloc HPORT"""
502 sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
504 texte+=" TYPE %s\n" % str(sdict['TYPE'])
505 # test de la presence d'une forme de source reconnue
506 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
507 # la source ne peut contenir au plus qu'un type de source.
508 if "WAVEFORM_CONSTANT" in obj.valeur:
509 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
510 if self.problem == HARMONIC:
511 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
512 print tr("ATTENTION! Une source constante n'est \
513 possible qu'a frequence nulle en regime frequentiel")
514 elif "WAVEFORM_SINUS" in obj.valeur:
515 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
516 if self.problem == HARMONIC:
517 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
518 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
520 print tr("ERREUR! Une forme de la source du type \
521 WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
522 self.dictSourceHport[obj.getSdname()]=texte
528 def generSOURCE_EPORT(self,obj):
529 """preparation du sous bloc EPORT"""
531 sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
533 texte+=" TYPE %s\n" % str(sdict['TYPE'])
534 # test de la presence d'une forme de source reconnue
535 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
536 # la source ne peut contenir au plus qu'un type de source.
537 if "WAVEFORM_CONSTANT" in obj.valeur:
538 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
539 if self.problem == HARMONIC:
540 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
541 print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
542 elif "WAVEFORM_SINUS" in obj.valeur:
543 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
544 if self.problem == HARMONIC:
545 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
546 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
548 print tr("ERREUR! Une forme de la source du type \
549 WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
550 self.dictSourceEport[obj.getSdname()]=texte
556 #---------------------------------------------------------------------------------------
557 # traitement fichier PHYS
558 #---------------------------------------------------------------------------------------
560 def generBLOC_VERSION(self,obj) :
561 # constitution du bloc VERSION du fichier PHYS
562 # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
563 # dans le du catalogue
564 version=obj.addEntite('VERSION',pos=None)
565 self.generPROC_ETAPE(obj.etapes[0])
566 self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
567 for cle in obj.etapes[0].valeur :
568 self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
569 self.texteCarmel3D+="]\n"
570 # destruction de l entite creee
571 obj.suppEntite(version)
573 #----------------------------------------------------------------------------------------
574 def generBLOC_MATERIALS(self) :
575 """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
576 Le bloc MATERIALS existe toujours !
579 print "cle dictionnaire materconductor : %s", self.dictMaterConductor.keys()
580 print "cle dictionnaire materdielectric : %s", self.dictMaterDielectric.keys()
581 # constitution du bloc MATERIALS du fichier PHYS
582 self.texteCarmel3D+="[MATERIALS\n"
583 # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
584 nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
585 nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
587 print "noms groupes de mailles associes a des materiaux \
588 (ordre JdC puis tri)= %(v_1)s %(v_2)s", \
589 {'v_1': self.dictGroupesMaillage['ordreMateriauxJdC'], \
590 'v_2': nomsGroupesMaillage}
591 # constitution du bloc CONDUCTOR du fichier PHYS si existe
592 if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)
593 # constitution du bloc DIELECTRIC du fichier PHYS si exixte
594 if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)
595 # constitution du bloc ZSURFACIC du fichier PHYS si exixte
596 if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)
597 # constitution du bloc NILMAT du fichier PHYS si exixte
598 if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)
599 # constitution du bloc ZINSULATOR du fichier PHYS si exixte
600 if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)
601 # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
602 # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
603 if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()
604 # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
605 if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()
606 # fin du bloc MATERIALS du fichier PHYS
607 self.texteCarmel3D+="]\n"
609 def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :
610 """Constitution du bloc CONDUCTOR du fichier PHYS"""
611 typeBloc = 'CONDUCTOR' # initialisation du type de bloc
612 dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
614 print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s', \
615 {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
616 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
617 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
618 # ecriture du bloc complet
619 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
621 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
624 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
625 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
626 self.texteCarmel3D+=" ]\n" # fin de bloc
628 def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :
629 """Constitution du bloc DIELECTRIC du fichier PHYS"""
630 typeBloc = 'DIELECTRIC' # initialisation du type de bloc
631 dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
633 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
634 {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
635 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
636 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
637 # ecriture du bloc complet
638 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
639 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
640 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
641 self.texteCarmel3D+=" ]\n" # fin de bloc
643 def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :
644 """Constitution du bloc ZSURFACIC du fichier PHYS"""
645 typeBloc = 'ZSURFACIC' # initialisation du type de bloc
646 dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
648 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
649 {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
650 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
651 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
652 # ecriture du bloc complet
653 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
655 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
658 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
659 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
660 self.texteCarmel3D+=" ]\n" # fin de bloc
662 def creaBLOC_EMISO(self) :
663 """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
664 for cle in self.dictMaterEmIso.keys():
665 self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
666 self.texteCarmel3D+= self.dictMaterEmIso[cle]
667 self.texteCarmel3D+=" ]\n"
669 def creaBLOC_EMANISO(self) :
670 """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
671 for cle in self.dictMaterEmAnIso.keys():
672 self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
673 self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
674 self.texteCarmel3D+=" ]\n"
676 def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :
677 """Constitution du bloc ZINSULATOR du fichier PHYS"""
678 typeBloc = 'ZINSULATOR' # initialisation du type de bloc
679 dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
680 if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
681 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
682 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
683 # ecriture du bloc complet
684 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
686 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
689 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
690 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
691 self.texteCarmel3D+=" ]\n" # fin de bloc
693 def creaBLOC_NILMAT(self, nomsGroupesMaillage) :
694 """Constitution du bloc NILMAT du fichier PHYS"""
695 typeBloc = 'NILMAT' # initialisation du type de bloc
696 dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
698 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s', \
699 {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
700 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
701 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
702 # ecriture du bloc complet
703 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
705 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
708 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
709 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
710 self.texteCarmel3D+=" ]\n" # fin de bloc
712 #----------------------------------------------------------------------------------------
713 def generBLOC_SOURCES(self):
714 """constitution du bloc SOURCES du fichier PHYS"""
715 self.texteCarmel3D+="[SOURCES\n"
716 # tri alphabetique de tous les groupes de maillage associes a des sources
717 nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste
718 nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
720 print 'noms groupes de mailles associes a des sources \
721 (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s', \
722 {'g_maillage_orig': self.dictGroupesMaillage['ordreSourcesJdC'], \
723 'g_maillage_trie': nomsGroupesMaillage}
724 if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)
725 if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)
726 if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)
727 # fin du bloc SOURCES du fichier PHYS
728 self.texteCarmel3D+="]\n"
731 def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :
732 """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
734 print 'cles sources STRANDED_INDUCTOR= %s', self.dictSourceStInd.keys()
735 typeBloc = 'STRANDED_INDUCTOR'
736 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
737 if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
738 # ecriture du bloc de l'inducteur bobine
739 self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
740 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
741 self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des proprietes de l'inducteur bobine
742 self.texteCarmel3D+=" ]\n" # fin de bloc
744 def creaBLOC_EPORT(self, nomsGroupesMaillage) :
745 """constitution du bloc EPORT du fichier PHYS"""
747 print 'cles sources EPORT= %s', self.dictSourceEport.keys()
749 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
750 if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
751 # ecriture du bloc du port electrique
752 self.texteCarmel3D+=" [EPORT\n" # debut de bloc
754 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
757 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
758 self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port electrique
759 self.texteCarmel3D+=" ]\n" # fin de bloc
761 def creaBLOC_HPORT(self, nomsGroupesMaillage) :
762 """constitution du bloc HPORT du fichier PHYS"""
764 print 'cles sources HPORT= %s', self.dictSourceHport.keys()
766 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
767 if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
768 # ecriture du bloc du port magnetique
769 self.texteCarmel3D+=" [HPORT\n" # debut de bloc
771 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
774 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
775 self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port magnetique
776 self.texteCarmel3D+=" ]\n" # fin de bloc
778 #-------------------------------------
779 # Methodes utilitaires
780 # ------------------------------------
781 def formateCOMPLEX(self,nbC):
782 """prise en compte des differentes formes de description d un nombre complexe
783 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
787 print "type : %(type_nb_c)s pour %(nb_c)s", \
788 {'type_nb_c': type(nbC), 'nb_c': nbC}
790 if isinstance(nbC,(tuple,list)):
791 if nbC[0] == "'RI'" :
792 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
793 if nbC[0] == "'MP'" :
794 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
796 nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
798 print "nbformate : %s", nbformate
801 def nomReelGroupeMaillage(self, nom, typeBloc=None):
802 """Calcule et retourne le nom reel du groupe de maillage donne en entree,
803 en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
804 de bloc du fichier PHYS specifie.
805 Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
807 from string import join
809 print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
810 {'nom': nom, 'use_prefix': str(usePrefix)}
811 nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
813 # suppression du prefixe si present
814 partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
815 # les tests suivants ne generent une erreur que si le prefixe est obligatoire
816 if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
817 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
818 indiquant le type de materiau ou de source associee", nom)
819 elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
820 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
822 # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
823 if typeBloc is not None:
824 if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
825 print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
826 elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
827 print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
828 le prefixe correct pour etre associe a un type %(type_bloc)s", \
829 {'nom': nom, 'type_bloc': str(typeBloc)})
831 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
833 print "ce groupe de maille (%(nom)s) a un prefixe qui \
834 est supprime automatiquement pour devenir : %(nom_reel)s", \
835 {'nom': nom, 'nom_reel': nomReel}
837 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
839 print "ce groupe de maille (%(nom)s) a un prefixe qui \
840 est supprime automatiquement pour devenir : %(nom_reel)s", \
841 {'nom': nom, 'nom_reel': nomReel}
843 print "... %s", nomReel