1 # -*- coding: utf-8 -*-
\r
2 # Copyright (C) 2007-2013 EDF R&D
\r
4 # This library is free software; you can redistribute it and/or
\r
5 # modify it under the terms of the GNU Lesser General Public
\r
6 # License as published by the Free Software Foundation; either
\r
7 # version 2.1 of the License.
\r
9 # This library is distributed in the hope that it will be useful,
\r
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
\r
12 # Lesser General Public License for more details.
\r
14 # You should have received a copy of the GNU Lesser General Public
\r
15 # License along with this library; if not, write to the Free Software
\r
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
\r
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
\r
20 """Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
\r
24 import types,string,re,os
\r
25 from Extensions.i18n import tr
\r
26 from generator_python import PythonGenerator
\r
28 # Groupes de mailles dont les types sont definis par des prefixes dans leur nom
\r
29 usePrefix = False # les noms ont des prefixes (True) ou non (False)
\r
30 # liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
\r
31 # Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
\r
32 listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
\r
33 "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
\r
34 "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
\r
35 "PORT_OMEGA","POST_PHI","PB_GRID",
\r
36 "SCUTE","SCUTN","ZS","ZJ","ZT")
\r
37 # liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
\r
38 dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
\r
39 'CONDUCTOR':('COND',),
\r
40 'STRANDED_INDUCTOR':('CURRENT', ),
\r
41 'EPORT':('EPORT', ),
\r
42 'HPORT':('HPORT', ),
\r
43 'ZSURFACIC':('ZS', ),
\r
44 'ZINSULATOR':('ZJ', ),
\r
45 'NILMAT':('NILMAT', )}
\r
46 # separateur entre le prefixe et le reste du nom du groupe de maille
\r
47 sepNomGroupeMaille = '_'
\r
49 # types de problemes
\r
50 HARMONIC = 'HARMONIC' # probleme frequentiel
\r
51 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
\r
53 # nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
\r
54 nomPlugin = 'CARMEL3DFV0'
\r
58 Retourne les informations necessaires pour le chargeur de plugins
\r
59 Ces informations sont retournees dans un dictionnaire
\r
64 # La factory pour creer une instance du plugin
\r
65 'factory' : CARMEL3DFV0Generator,
\r
69 class CARMEL3DFV0Generator(PythonGenerator):
\r
71 Ce generateur parcourt un objet de type JDC et produit
\r
72 un texte au format eficas et
\r
73 un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
\r
76 # Les extensions de fichier permis?
\r
77 extensions=('.comm',)
\r
79 #----------------------------------------------------------------------------------------
\r
80 def gener(self,obj,format='brut',config=None):
\r
84 # Cette instruction genere le contenu du fichier de commandes (persistance)
\r
85 self.text=PythonGenerator.gener(self,obj,format)
\r
88 print "self.text = %s" % self.text
\r
90 # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
\r
91 # si le jdc est valide (sinon cela n a pas de sens)
\r
94 # constitution du bloc VERSION du fichier PHYS (existe toujours)
\r
95 self.generBLOC_VERSION(obj)
\r
96 # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
\r
97 self.generBLOC_MATERIALS()
\r
98 # constitution du bloc SOURCES du fichier PHYS (existe toujours)
\r
99 self.generBLOC_SOURCES()
\r
100 except ValueError, err:
\r
101 raise ValueError(str(err))
\r
103 # print "texte carmel3d :\n",self.texteCarmel3D
\r
104 # print "dictMaterDielectric : ",self.dictMaterDielectric
\r
106 print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
\r
111 #----------------------------------------------------------------------------------------
\r
113 #----------------------------------------------------------------------------------------
\r
115 def initDico(self) :
\r
117 self.texteCarmel3D=""
\r
118 self.debug = True # affichage de messages pour deboguage (.true.) ou non
\r
119 self.dicoEtapeCourant=None
\r
120 self.dicoMCFACTCourant=None
\r
121 self.dicoCourant=None
\r
122 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
\r
123 self.dictMaterConductor={}
\r
124 self.dictMaterDielectric={}
\r
125 self.dictMaterZsurfacic={}
\r
126 self.dictMaterEmIso={}
\r
127 self.dictMaterEmAnIso={}
\r
128 self.dictMaterNilmat={}
\r
129 self.dictMaterZinsulator={}
\r
130 self.dictSourceStInd={}
\r
131 self.dictSourceEport={}
\r
132 self.dictSourceHport={}
\r
133 # on force le probleme a etre frequentiel, seul possible en l'etat des choses
\r
134 self.problem = HARMONIC
\r
137 #----------------------------------------------------------------------------------------
\r
139 #----------------------------------------------------------------------------------------
\r
141 def writeDefault(self,fn) :
\r
142 """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""
\r
144 print "ecriture du fichier de parametres (PHYS)"
\r
145 filePHYS = fn[:fn.rfind(".")] + '.phys'
\r
146 f = open( str(filePHYS), 'wb')
\r
147 f.write( self.texteCarmel3D)
\r
150 #----------------------------------------------------------------------------------------
\r
151 # analyse de chaque noeud de l'arbre
\r
152 #----------------------------------------------------------------------------------------
\r
154 def generMCSIMP(self,obj) :
\r
155 """recuperation de l objet MCSIMP"""
\r
157 print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
\r
158 s=PythonGenerator.generMCSIMP(self,obj)
\r
159 self.dicoCourant[obj.nom]=obj.valeurFormatee
\r
163 #----------------------------------------------------------------------------------------
\r
164 def generMCFACT(self,obj) :
\r
165 """recuperation de l objet MCFACT"""
\r
167 self.dicoMCFACTCourant=dico
\r
168 self.dicoCourant=self.dicoMCFACTCourant
\r
169 s=PythonGenerator.generMCFACT(self,obj)
\r
170 self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
\r
171 self.dicoMCFACTCourant=None
\r
172 self.dicoCourant=self.dicoEtapeCourant
\r
175 #----------------------------------------------------------------------------------------
\r
176 def generPROC_ETAPE(self,obj):
\r
177 """analyse des PROC du catalogue ( VERSION )"""
\r
179 self.dicoEtapeCourant=dico
\r
180 self.dicoCourant=self.dicoEtapeCourant
\r
181 s=PythonGenerator.generPROC_ETAPE(self,obj)
\r
182 obj.valeur=self.dicoEtapeCourant
\r
184 print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
\r
185 s=PythonGenerator.generPROC_ETAPE(self,obj)
\r
188 #----------------------------------------------------------------------------------------
\r
189 def generETAPE(self,obj):
\r
190 """analyse des OPER du catalogue"""
\r
192 self.dicoEtapeCourant=dico
\r
193 self.dicoCourant=self.dicoEtapeCourant
\r
194 s=PythonGenerator.generETAPE(self,obj)
\r
195 obj.valeur=self.dicoEtapeCourant
\r
197 print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
\r
198 if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
\r
199 if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
\r
200 if obj.nom=="SOURCE" : self.generSOURCE(obj)
\r
201 s=PythonGenerator.generETAPE(self,obj)
\r
204 #----------------------------------------------------------------------------------------
\r
205 def generMACRO_ETAPE(self,obj):
\r
207 self.dicoEtapeCourant=dico
\r
208 self.dicoCourant=self.dicoEtapeCourant
\r
210 monGenerateur=generator.plugins[nomPlugin]()
\r
211 jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
\r
213 print "jdc_aux_texte : %s" % jdc_aux_texte
\r
215 for cle in monGenerateur.dictMaterConductor:
\r
216 self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
\r
217 for cle in monGenerateur.dictMaterDielectric:
\r
218 self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
\r
219 for cle in monGenerateur.dictMaterZsurfacic:
\r
220 self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
\r
221 for cle in monGenerateur.dictMaterEmIso:
\r
222 self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
\r
223 for cle in monGenerateur.dictMaterEmAnIso:
\r
224 self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
\r
225 for cle in monGenerateur.dictMaterNilmat:
\r
226 self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
\r
227 for cle in monGenerateur.dictMaterZinsulator:
\r
228 self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
\r
230 print "________FIN MACRO______________________________________"
\r
231 s=PythonGenerator.generMACRO_ETAPE(self,obj)
\r
234 #----------------------------------------------------------------------------------------
\r
235 #----------------------------------------------------------------------------------------
\r
236 def generMESHGROUP(self,obj):
\r
237 """preparation de la ligne NAME referencant le groupe de mailles
\r
238 associe le groupe de mailles au materiau ou a la source utilisateur
\r
239 on sauvegarde aussi les noms des groupes de maillage
\r
243 nomGroupeMaillage = self.nomReelGroupeMaillage(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
\r
245 nomGroupeMaillage = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
\r
246 # 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.
\r
247 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
\r
248 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage
\r
250 # on utilise le fait que obj.valeur est un dictionnaire
\r
252 print "obj.valeur.keys()= %s" % obj.valeur.keys()
\r
253 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
\r
254 raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupeMaillage)
\r
255 # association a un materiau
\r
256 if 'MATERIAL' in obj.valeur.keys():
\r
257 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
\r
258 self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
\r
259 # association a une source
\r
260 elif 'SOURCE' in obj.valeur.keys():
\r
261 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
\r
262 self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
\r
263 # erreur ni materiau ni source associee
\r
265 raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau ou source." % nomGroupeMaillage)
\r
267 print "self.dictGroupesMaillage= %s" % repr(self.dictGroupesMaillage)
\r
268 except ValueError, err:
\r
269 raise ValueError, str(err)
\r
272 def generMATERIAL(self,obj):
\r
273 """preparation du bloc correspondant a un materiau du fichier PHYS"""
\r
276 print "generation material obj.valeur = %s" % obj.valeur
\r
278 nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
\r
279 if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
\r
280 if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
\r
281 if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
\r
282 if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
\r
283 if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
\r
284 if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
\r
285 if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
\r
286 except ValueError, err:
\r
287 raise ValueError, str(err)
\r
289 def generMATERIAL_CONDUCTOR(self,obj):
\r
290 """preparation du sous bloc CONDUCTOR"""
\r
293 print "_____________cond_____________"
\r
294 # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
\r
295 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
\r
296 print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
\r
297 raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
\r
299 # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
\r
300 for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
\r
301 # debut du sous bloc de propriete du DIELECTRIC
\r
302 texte+=" ["+keyN1+"\n"
\r
303 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
\r
304 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
\r
305 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
\r
306 # car sinon ces valeurs sont definies dans des fichiers annexes
\r
307 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
\r
308 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
\r
309 if homogeneous and isotropic:
\r
310 # loi (lineaire ou non)
\r
311 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
\r
312 # valeur de la loi lineaire
\r
313 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
\r
314 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
\r
315 # seuls les reels sont pris en compte
\r
316 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
\r
317 texte+=" [NONLINEAR \n"
\r
318 texte+=" ISOTROPY TRUE\n"
\r
319 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
\r
320 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
\r
321 for keyN2 in obj.valeur[keyN1] :
\r
322 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
\r
323 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
\r
324 # fin du sous-bloc NONLINEAR
\r
326 # fin du sous bloc de propriete
\r
329 print "texte = %s", texte
\r
330 self.dictMaterConductor[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
\r
332 def generMATERIAL_DIELECTRIC(self,obj):
\r
333 """preparation du sous bloc DIELECTRIC"""
\r
336 print "______________nocond_____________"
\r
337 # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
\r
338 if 'PERMEABILITY' not in obj.valeur or 'PERMITTIVITY' not in obj.valeur:
\r
339 print "ERREUR! Le matériau non conducteur (dielectric) de nom %s doit contenir les propriétés PERMEABILITY et PERMITTIVITY." % obj.get_sdname()
\r
340 raise ValueError, tr("ERREUR! Le materiau non conducteur (DIELECTRIC) de nom %s doit contenir les proprietes PERMEABILITY et PERMITTIVITY." % obj.get_sdname())
\r
342 # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
\r
343 for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
\r
344 # debut du sous bloc de propriete du DIELECTRIC
\r
345 texte+=" ["+keyN1+"\n"
\r
346 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
\r
347 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
\r
348 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
\r
349 # car sinon ces valeurs sont definies dans des fichiers annexes
\r
350 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
\r
351 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
\r
352 if homogeneous and isotropic:
\r
353 # loi (lineaire ou non)
\r
354 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
\r
355 # valeur de la loi lineaire
\r
356 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
\r
357 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
\r
358 # seuls les reels sont pris en compte
\r
359 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
\r
360 texte+=" [NONLINEAR \n"
\r
361 texte+=" ISOTROPY TRUE\n"
\r
362 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
\r
363 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
\r
364 for keyN2 in obj.valeur[keyN1] :
\r
365 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
\r
366 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
\r
367 # fin du sous-bloc NONLINEAR
\r
369 # fin du sous bloc de propriete
\r
372 print "texte = %s" % texte
\r
373 self.dictMaterDielectric[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
\r
375 def generMATERIAL_ZSURFACIC(self,obj):
\r
376 """preparation du sous bloc ZSURFACIC"""
\r
379 print "______________zsurf_____________"
\r
380 # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
\r
381 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
\r
382 print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
\r
383 raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
\r
385 # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
\r
386 for keyN1 in obj.valeur :
\r
387 if keyN1=='TYPE': continue
\r
388 # print "type loi = ", obj.valeur[keyN1]['LAW']
\r
389 # debut du sous bloc de propriete du DIELECTRIC
\r
390 texte+=" ["+keyN1+"\n"
\r
391 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
\r
392 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
\r
393 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
\r
394 # car sinon ces valeurs sont definies dans des fichiers annexes
\r
395 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
\r
396 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
\r
397 if homogeneous and isotropic:
\r
398 # loi (lineaire ou non)
\r
399 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
\r
400 # valeur de la loi lineaire
\r
401 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
\r
402 # fin du sous bloc de propriete
\r
405 print "texte = %s", texte
\r
406 self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
\r
408 def generMATERIAL_EMISO(self,obj):
\r
409 """preparation du sous bloc EM_ISOTROPIC_FILES.
\r
410 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
\r
411 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
\r
413 texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
\r
414 texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
\r
415 # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
\r
416 #from os.path import basename
\r
417 #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
\r
418 #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
\r
419 # print "obj get sdname= ", obj.get_sdname()
\r
420 # if obj.get_sdname() in self.dictMaterEmIso.keys() :
\r
421 # self.dictMaterEmIso[obj.get_sdname()].append(texte)
\r
423 self.dictMaterEmIso[obj.get_sdname()]=texte
\r
425 def generMATERIAL_EMANISO(self,obj):
\r
426 """preparation du sous bloc EM_ANISOTROPIC_FILES.
\r
427 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
\r
428 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
\r
430 texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
\r
431 texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
\r
432 # print "obj get sdname= ", obj.get_sdname()
\r
433 # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
\r
434 # self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
\r
436 self.dictMaterEmAnIso[obj.get_sdname()]=texte
\r
438 def generMATERIAL_NILMAT(self,obj):
\r
439 """preparation du sous bloc NILMAT"""
\r
441 self.dictMaterNilmat[obj.get_sdname()]=texte
\r
443 def generMATERIAL_ZINSULATOR(self,obj):
\r
444 """"preparation du sous bloc ZINSULATOR"""
\r
446 self.dictMaterZinsulator[obj.get_sdname()]=texte
\r
448 #-------------------------------------------------------------------
\r
450 def generSOURCE(self,obj):
\r
451 """preparation du bloc correspondant a une source du fichier PHYS"""
\r
453 print "generation source obj valeur = %s" % obj.valeur
\r
456 # test de la presence des types de sources reconnus
\r
457 # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
\r
458 # la source ne peut contenir au plus qu'un type de source.
\r
459 if "STRANDED_INDUCTOR" in obj.valeur:
\r
460 self.generSOURCE_STRANDED_INDUCTOR(obj)
\r
461 elif "HPORT" in obj.valeur:
\r
462 self.generSOURCE_HPORT(obj)
\r
463 elif "EPORT" in obj.valeur:
\r
464 self.generSOURCE_EPORT(obj)
\r
466 print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
\r
467 except ValueError, err:
\r
468 raise ValueError, str(err)
\r
470 def generSOURCE_STRANDED_INDUCTOR(self,obj):
\r
471 """preparation du sous bloc STRANDED_INDUCTOR"""
\r
473 sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
\r
475 texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
\r
476 # test de la presence d'une forme de source reconnue
\r
477 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
\r
478 # la source ne peut contenir au plus qu'un type de source.
\r
479 if "WAVEFORM_CONSTANT" in obj.valeur:
\r
480 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
\r
481 if self.problem == HARMONIC:
\r
482 texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
\r
483 print tr("ATTENTION! Une source constante \
\r
484 n'est possible qu'a frequence nulle \
\r
485 en regime frequentiel")
\r
486 elif "WAVEFORM_SINUS" in obj.valeur:
\r
487 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
\r
488 if self.problem == HARMONIC:
\r
489 texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
\r
490 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
\r
492 print tr("ERREUR! Une forme de la source du \
\r
493 type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
\r
494 self.dictSourceStInd[obj.get_sdname()]=texte
\r
497 except ValueError, err:
\r
498 raise ValueError, str(err)
\r
500 def generSOURCE_HPORT(self,obj):
\r
501 """preparation du sous bloc HPORT"""
\r
503 sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
\r
505 texte+=" TYPE %s\n" % str(sdict['TYPE'])
\r
506 # test de la presence d'une forme de source reconnue
\r
507 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
\r
508 # la source ne peut contenir au plus qu'un type de source.
\r
509 if "WAVEFORM_CONSTANT" in obj.valeur:
\r
510 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
\r
511 if self.problem == HARMONIC:
\r
512 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
\r
513 print tr("ATTENTION! Une source constante n'est \
\r
514 possible qu'a frequence nulle en regime frequentiel")
\r
515 elif "WAVEFORM_SINUS" in obj.valeur:
\r
516 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
\r
517 if self.problem == HARMONIC:
\r
518 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
\r
519 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
\r
521 print tr("ERREUR! Une forme de la source du type \
\r
522 WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
\r
523 self.dictSourceHport[obj.get_sdname()]=texte
\r
526 except ValueError, err:
\r
527 raise ValueError, str(err)
\r
529 def generSOURCE_EPORT(self,obj):
\r
530 """preparation du sous bloc EPORT"""
\r
532 sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
\r
534 texte+=" TYPE %s\n" % str(sdict['TYPE'])
\r
535 # test de la presence d'une forme de source reconnue
\r
536 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
\r
537 # la source ne peut contenir au plus qu'un type de source.
\r
538 if "WAVEFORM_CONSTANT" in obj.valeur:
\r
539 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
\r
540 if self.problem == HARMONIC:
\r
541 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
\r
542 print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
\r
543 elif "WAVEFORM_SINUS" in obj.valeur:
\r
544 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
\r
545 if self.problem == HARMONIC:
\r
546 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
\r
547 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
\r
549 print tr("ERREUR! Une forme de la source du type \
\r
550 WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
\r
551 self.dictSourceEport[obj.get_sdname()]=texte
\r
554 except ValueError, err:
\r
555 raise ValueError, str(err)
\r
557 #---------------------------------------------------------------------------------------
\r
558 # traitement fichier PHYS
\r
559 #---------------------------------------------------------------------------------------
\r
561 def generBLOC_VERSION(self,obj) :
\r
562 # constitution du bloc VERSION du fichier PHYS
\r
563 # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
\r
564 # dans le du catalogue
\r
565 version=obj.addentite('VERSION',pos=None)
\r
566 self.generPROC_ETAPE(obj.etapes[0])
\r
567 self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
\r
568 for cle in obj.etapes[0].valeur :
\r
569 self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
\r
570 self.texteCarmel3D+="]\n"
\r
571 # destruction de l entite creee
\r
572 obj.suppentite(version)
\r
573 #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
\r
574 #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
\r
576 #----------------------------------------------------------------------------------------
\r
577 def generBLOC_MATERIALS(self) :
\r
578 """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
\r
579 Le bloc MATERIALS existe toujours !
\r
582 print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
\r
583 print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
\r
584 # constitution du bloc MATERIALS du fichier PHYS
\r
585 self.texteCarmel3D+="[MATERIALS\n"
\r
586 # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
\r
587 nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
\r
588 nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
\r
590 print "noms groupes de mailles associes a des materiaux \
\r
591 (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
\r
592 {'v_1': self.dictGroupesMaillage['ordreMateriauxJdC'], \
\r
593 'v_2': nomsGroupesMaillage}
\r
595 # constitution du bloc CONDUCTOR du fichier PHYS si existe
\r
596 if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)
\r
597 # constitution du bloc DIELECTRIC du fichier PHYS si exixte
\r
598 if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)
\r
599 # constitution du bloc ZSURFACIC du fichier PHYS si exixte
\r
600 if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)
\r
601 # constitution du bloc NILMAT du fichier PHYS si exixte
\r
602 if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)
\r
603 # constitution du bloc ZINSULATOR du fichier PHYS si exixte
\r
604 if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)
\r
605 # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
\r
606 # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
\r
607 if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()
\r
608 # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
\r
609 if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()
\r
610 except ValueError, err:
\r
611 raise ValueError(str(err))
\r
613 # fin du bloc MATERIALS du fichier PHYS
\r
614 self.texteCarmel3D+="]\n"
\r
616 def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :
\r
617 """Constitution du bloc CONDUCTOR du fichier PHYS"""
\r
618 typeBloc = 'CONDUCTOR' # initialisation du type de bloc
\r
619 dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
\r
621 print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
\r
622 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
623 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
\r
624 # ecriture du bloc complet
\r
625 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
\r
627 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
\r
630 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
\r
631 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
\r
632 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
634 def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :
\r
635 """Constitution du bloc DIELECTRIC du fichier PHYS"""
\r
636 typeBloc = 'DIELECTRIC' # initialisation du type de bloc
\r
637 dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
\r
639 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
\r
640 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
641 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
\r
642 # ecriture du bloc complet
\r
643 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
\r
644 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
\r
645 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
\r
646 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
648 def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :
\r
649 """Constitution du bloc ZSURFACIC du fichier PHYS"""
\r
650 typeBloc = 'ZSURFACIC' # initialisation du type de bloc
\r
651 dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
\r
653 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
\r
654 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
655 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
\r
656 # ecriture du bloc complet
\r
657 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
\r
659 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
\r
662 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
\r
663 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
\r
664 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
666 def creaBLOC_EMISO(self) :
\r
667 """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
\r
668 for cle in self.dictMaterEmIso.keys():
\r
669 self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
\r
670 self.texteCarmel3D+= self.dictMaterEmIso[cle]
\r
671 self.texteCarmel3D+=" ]\n"
\r
673 def creaBLOC_EMANISO(self) :
\r
674 """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
\r
675 for cle in self.dictMaterEmAnIso.keys():
\r
676 self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
\r
677 self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
\r
678 self.texteCarmel3D+=" ]\n"
\r
680 def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :
\r
681 """Constitution du bloc ZINSULATOR du fichier PHYS"""
\r
682 typeBloc = 'ZINSULATOR' # initialisation du type de bloc
\r
683 dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
\r
684 if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
\r
685 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
686 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
\r
687 # ecriture du bloc complet
\r
688 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
\r
690 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
\r
693 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
\r
694 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
\r
695 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
697 def creaBLOC_NILMAT(self, nomsGroupesMaillage) :
\r
698 """Constitution du bloc NILMAT du fichier PHYS"""
\r
699 typeBloc = 'NILMAT' # initialisation du type de bloc
\r
700 dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
\r
702 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
\r
703 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
704 if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
\r
705 # ecriture du bloc complet
\r
706 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
\r
708 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
\r
711 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
\r
712 self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe
\r
713 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
715 #----------------------------------------------------------------------------------------
\r
716 def generBLOC_SOURCES(self):
\r
717 """constitution du bloc SOURCES du fichier PHYS"""
\r
718 self.texteCarmel3D+="[SOURCES\n"
\r
719 # tri alphabetique de tous les groupes de maillage associes a des sources
\r
720 nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste
\r
721 nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels
\r
723 print 'noms groupes de mailles associes a des sources \
\r
724 (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
\r
725 {'g_maillage_orig': self.dictGroupesMaillage['ordreSourcesJdC'], \
\r
726 'g_maillage_trie': nomsGroupesMaillage}
\r
727 if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)
\r
728 if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)
\r
729 if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)
\r
730 # fin du bloc SOURCES du fichier PHYS
\r
731 self.texteCarmel3D+="]\n"
\r
734 def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :
\r
735 """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
\r
737 print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
\r
738 typeBloc = 'STRANDED_INDUCTOR'
\r
739 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
740 if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
\r
741 # ecriture du bloc de l'inducteur bobine
\r
742 self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
\r
743 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
\r
744 self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des proprietes de l'inducteur bobine
\r
745 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
747 def creaBLOC_EPORT(self, nomsGroupesMaillage) :
\r
748 """constitution du bloc EPORT du fichier PHYS"""
\r
750 print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
\r
752 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
753 if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
\r
754 # ecriture du bloc du port electrique
\r
755 self.texteCarmel3D+=" [EPORT\n" # debut de bloc
\r
757 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
\r
760 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
\r
761 self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port electrique
\r
762 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
764 def creaBLOC_HPORT(self, nomsGroupesMaillage) :
\r
765 """constitution du bloc HPORT du fichier PHYS"""
\r
767 print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
\r
769 for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
\r
770 if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
\r
771 # ecriture du bloc du port magnetique
\r
772 self.texteCarmel3D+=" [HPORT\n" # debut de bloc
\r
774 nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
\r
777 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
\r
778 self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port magnetique
\r
779 self.texteCarmel3D+=" ]\n" # fin de bloc
\r
781 #-------------------------------------
\r
782 # Methodes utilitaires
\r
783 # ------------------------------------
\r
784 def formateCOMPLEX(self,nbC):
\r
785 """prise en compte des differentes formes de description d un nombre complexe
\r
786 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
\r
790 print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
\r
792 if isinstance(nbC,(tuple,list)):
\r
793 if nbC[0] == "'RI'" :
\r
794 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
\r
795 if nbC[0] == "'MP'" :
\r
796 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
\r
798 nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
\r
800 print "nbformate : %s" % nbformate
\r
803 def nomReelGroupeMaillage(self, nom, typeBloc=None):
\r
804 """Calcule et retourne le nom reel du groupe de maillage donne en entree,
\r
805 en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
\r
806 de bloc du fichier PHYS specifie.
\r
807 Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
\r
809 from string import join
\r
811 print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
\r
812 {'nom': nom, 'use_prefix': str(usePrefix)}
\r
813 nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
\r
815 # suppression du prefixe si present
\r
816 partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
\r
817 # les tests suivants ne generent une erreur que si le prefixe est obligatoire
\r
818 if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
\r
819 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
\r
820 indiquant le type de materiau ou de source associee", nom)
\r
821 elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
\r
822 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
\r
824 # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
\r
825 if typeBloc is not None:
\r
826 if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
\r
827 print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
\r
828 elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
\r
829 print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
\r
830 le prefixe correct pour etre associe a un type %(type_bloc)s", \
\r
831 {'nom': nom, 'type_bloc': str(typeBloc)})
\r
833 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
\r
835 print "ce groupe de maille (%(nom)s) a un prefixe qui \
\r
836 est supprime automatiquement pour devenir : %(nom_reel)s", \
\r
837 {'nom': nom, 'nom_reel': nomReel}
\r
839 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
\r
841 print "ce groupe de maille (%(nom)s) a un prefixe qui \
\r
842 est supprime automatiquement pour devenir : %(nom_reel)s", \
\r
843 {'nom': nom, 'nom_reel': nomReel}
\r
845 print "... %s", nomReel
\r