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={}
152 self.cutlineValeur=[]
153 self.cutplaneValeur=[]
155 self.fieldmapValeur=[]
156 self.fielddumpValeur=[]
166 self.post_global=False
173 # on force le probleme a etre frequentiel, seul possible en l'etat des choses
174 self.problem = HARMONIC
175 self.fichierMaillage = "" # chemin absolu ou relatif du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
176 self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
177 self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
178 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.
179 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.
181 #----------------------------------------------------------------------------------------
183 #----------------------------------------------------------------------------------------
185 def writeDefault(self,fn) :
186 """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
188 # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
189 #file = fn[:fn.rfind(".")] # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
190 repertory=os.path.dirname(fn) # répertoire de l'étude, e.g., /home/toto/
191 file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
192 namefile=os.path.basename(file) # nom du projet e.g., foo
196 print "ecriture du fichier de parametres (PHYS)"
197 filePHYS = file + '.phys'
198 typeBloc = 'PHYS_FILES'
199 f = open( str(filePHYS), 'w')
200 f.write( self.texteCarmel3D)
205 print "ecriture du fichier de parametres (PARAM)"
206 filePARAM = file + '.param'
207 f = open( str(filePARAM), 'w')
208 f.write('[VERSION \n'
210 ' FILETYPE PARAM\n]\n'
212 ' NAME HARMONIC\n]\n'
214 typeBloc = 'CAR_FILES'
215 self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
216 self.texteCarmel3D_PARAM+=" NAME "+self.projet+".car"
217 self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
218 typeBloc = 'PHYS_FILES'
219 self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
220 self.texteCarmel3D_PARAM+=" NAME "+self.projet+".phys"
221 self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
222 self.texteCarmel3D_PARAM+="[FREQUENCY\n"
223 self.texteCarmel3D_PARAM+=" SINGLE %g \n" % (self.frequency )
224 self.texteCarmel3D_PARAM+="] \n"
225 f.write( self.texteCarmel3D_PARAM)
226 f.write(self.texteCarmel3D_PARAM_SOLV)
229 # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
231 print "ecriture du fichier de parametres (CMD)"
232 fileCMD =file + '.cmd'
233 f = open( str(fileCMD), 'w')
234 f.write(self.texteCarmel3D_CMD)
239 print "ecriture du fichier de parametres (INGENDOF)"
240 fileINGEND = file + '.ingendof'
241 f = open(fileINGEND, 'w')
242 self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
244 nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
247 #if self.dictDomaine !={}:
249 self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
250 except ValueError, err:
251 raise ValueError(str(err))
252 if self.dictPort != {} :
253 self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
254 if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
255 if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
256 f.write(self.texteCarmel3D_INGEND1)
257 f.write(self.texteCarmel3D_INGEND2)
258 f.write(self.texteCarmel3D_INGEND3)
262 print "ecriture du fichier de parametres (INFCARMEL) "
263 fileINFC = file + '.infcarmel'
264 f = open(fileINFC, 'w')
265 self.texteCarmel3D_INFC+= self.projet+".param"
266 f.write(self.texteCarmel3D_INFC)
270 print "ecriture du fichier de parametres (INPOSTPROCESS) "
271 fileINPOST = file + '.inpostprocess'
272 f = open(fileINPOST, 'w')
273 self.texteCarmel3D_INPOST+= self.projet+".param"
274 self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
275 self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
276 f.write(self.texteCarmel3D_INPOST)
279 print "dictionnaire complet=%s" %self.dictGroupes
280 print "dictionnaire des ports =%s" %self.dictPort
282 print "ecriture du fichier d'execution (SH)"
283 print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
284 RepCarmel= os.path.join(repertory,"lancer.sh")
285 f = open( str(RepCarmel), 'wb')
286 self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
287 if self.gendof=="TRUE":
288 self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
289 if self.echelle=="Millimetre":
290 self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
292 self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
293 if self.fcarmel=="TRUE":
294 self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
295 self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe < " + self.projet + ".infcarmel\n"
296 if self.postprocess=="TRUE":
297 self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
298 self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
299 f.write(self.texteCarmel3D_SH)
302 #----------------------------------------------------------------------------------------
303 # analyse de chaque noeud de l'arbre
304 #----------------------------------------------------------------------------------------
306 def generMCSIMP(self,obj) :
307 """recuperation de l objet MCSIMP"""
309 print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
310 s=PythonGenerator.generMCSIMP(self,obj)
312 self.dicoCourant[obj.nom]=obj.valeurFormatee
314 print "Oubli des messages texte homo='information'"
318 #----------------------------------------------------------------------------------------
319 def generMCFACT(self,obj) :
320 """recuperation de l objet MCFACT"""
322 print "MCFACT debut %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
324 self.dicoMCFACTCourant=dico
325 self.dicoCourant=self.dicoMCFACTCourant
326 s=PythonGenerator.generMCFACT(self,obj)
327 # sauvegarde, dans self.dicoEtapeCourant, de la valeur du FACT courant, pour utilisation ultérieure dans generETAPE et generPROC_ETAPE
328 # Traitement des FACT CUTLINE et CUTPLANE multiples (max='**' dans le catalogue)
329 # Ce traitement spécial est nécessaire pour le moment car le générateur bogue sinon au niveau des matériaux (non-linéaires ?)
330 if obj.nom in ('FIELDDUMP','CUTLINE', 'CUTPLANE', 'FIELDMAP', 'VISU3D' ):
331 # Remplissage se self.dicoEtapeCourant pour le nom du FACT courant
332 # Il ne contient qu'une seule valeur (un dictionnaire) par défaut lorsque le FACT est unique (max=1 dans le catalogue),
333 # mais il peut aussi contenir plusieurs valeurs (tableau) dans le cas contraire, e.g., max='**' dans le catalogue
334 if self.dicoEtapeCourant.has_key(obj.nom): # plusieurs valeurs
335 print "self.dicoEtapeCourant= %s"%self.dicoEtapeCourant
336 if type(self.dicoEtapeCourant[obj.nom]) == types.DictType: # une seule valeur entrée jusqu'à présent
337 dicoMCFACTprecedent = self.dicoEtapeCourant[obj.nom] # sauvegarde de la valeur précédente
338 print "dicoMCFACTpreceden= %s self.dicoEtapeCourant= %s"%(dicoMCFACTprecedent,self.dicoEtapeCourant)
339 self.dicoEtapeCourant[obj.nom] = [ dicoMCFACTprecedent, self.dicoMCFACTCourant ] # restructuration en liste et insertion de la valeur précédente et de la valeur courant
340 print "self.dicoEtapeCourant[obj.nom]= %s"%self.dicoEtapeCourant[obj.nom]
341 else: # plusieurs valeurs entrées jusqu'à présent, sous la forme d'une liste de dictionnaires
342 self.dicoEtapeCourant[obj.nom].append(self.dicoMCFACTCourant) # extension de la liste avec cette valeur, placée en dernier
343 else: # une seule valeur ou première valeur
344 self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
345 else: # traitement usuel des FACT uniques, pour ignorer le bogue décrit plus haut
346 self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
347 self.dicoMCFACTCourant=None
348 self.dicoCourant=self.dicoEtapeCourant
350 print "MCFACT fin %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
354 #----------------------------------------------------------------------------------------
355 def generPROC_ETAPE(self,obj):
356 """analyse des PROC du catalogue ( VERSION )"""
358 print "PROC_ETAPE initial: %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
360 self.dicoEtapeCourant=dico
361 self.dicoCourant=self.dicoEtapeCourant
362 s=PythonGenerator.generPROC_ETAPE(self,obj)
363 obj.valeur=self.dicoEtapeCourant # on passe à obj la bonne structure générée par PythonGenerator.generPROC_ETAPE, pour le traitement de chaque partie ci-dessous
365 print "PROC_ETAPE mis a jour: %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
366 if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
367 if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
368 if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
369 s=PythonGenerator.generPROC_ETAPE(self,obj) # obj.valeur a été modifiée pour le traitement ci-dessus, alors il faut tout remettre en ordre en appelant de nouveau PythonGenerator.generPROC_ETAPE
374 #----------------------------------------------------------------------------------------
375 def generETAPE(self,obj):
376 """analyse des OPER du catalogue"""
378 print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
380 self.dicoEtapeCourant=dico
381 self.dicoCourant=self.dicoEtapeCourant
382 s=PythonGenerator.generETAPE(self,obj)
383 obj.valeur=self.dicoEtapeCourant # cf. generPROC_ETAPE
385 print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
386 if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
387 if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
388 if obj.nom=="SOURCE" : self.generSOURCE(obj)
389 if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
390 if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
391 s=PythonGenerator.generETAPE(self,obj) # cf. generPROC_ETAPE
394 #----------------------------------------------------------------------------------------
395 def generMACRO_ETAPE(self,obj):
397 self.dicoEtapeCourant=dico
398 self.dicoCourant=self.dicoEtapeCourant
400 monGenerateur=generator.plugins[nomPlugin]()
401 jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
403 print "jdc_aux_texte : %s" % jdc_aux_texte
405 for cle in monGenerateur.dictMaterConductor:
406 self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
407 for cle in monGenerateur.dictMaterDielectric:
408 self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
409 for cle in monGenerateur.dictMaterZsurfacic:
410 self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
411 for cle in monGenerateur.dictMaterEmIso:
412 self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
413 for cle in monGenerateur.dictMaterEmAnIso:
414 self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
415 for cle in monGenerateur.dictMaterNilmat:
416 self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
417 for cle in monGenerateur.dictMaterZinsulator:
418 self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
420 print "________FIN MACRO______________________________________"
421 s=PythonGenerator.generMACRO_ETAPE(self,obj)
424 #----------------------------------------------------------------------------------------
425 #----------------------------------------------------------------------------------------
426 def generMESHGROUP(self,obj):
427 """preparation de la ligne NAME referencant le groupe de mailles
428 associe le groupe de mailles au materiau ou a la source utilisateur
429 on sauvegarde aussi les noms des groupes de maillage
433 nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
434 print "liste des noms sans prefixes %s" %(nomGroupe)
436 nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
437 print "liste des noms sans prefixes %s" %(nomGroupe)
439 # 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.
440 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
441 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
443 # on utilise le fait que obj.valeur est un dictionnaire
444 self.dictGroupes[nomGroupe] = {}
445 # nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
447 print "obj.valeur.keys()= %s" % obj.valeur.keys()
448 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
449 raise ValueError, nomGroupe + tr(" : ce groupe de maillage ne peut pas etre associe a un materiau et une source a la fois.")
450 # association a un materiau
451 if 'MATERIAL' in obj.valeur.keys():
452 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
453 self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
454 # association a une source
455 if 'SOURCE' in obj.valeur.keys():
456 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
457 self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
458 # erreur ni materiau ni source associee
459 if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
460 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
461 self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
462 if 'Domaine' in obj.valeur.keys():
463 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
464 self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
466 texte+="%s"%(obj.valeur['Domaine'])
467 print"le texte=%s" %(texte)
468 self.dictDomaine[obj.get_sdname()]=texte
469 print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
472 # raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
474 print "self.dictGroupes= %s" % repr(self.dictGroupes)
475 except ValueError, err:
476 raise ValueError, str(err)
478 def generMACRO_GROUPE(self, obj):
479 """preparation de la ligne NAME referencant le groupe de mailles
480 associe le groupe de mailles au materiau ou a la source utilisateur
481 on sauvegarde aussi les noms des macros groupes
484 #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
486 nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
487 print "liste des noms sans prefixes %s" %(nomGroupe)
489 nomGroupe = obj.get_sdname() # nom du macro groupe
490 print "liste des noms sans prefixes %s" %(nomGroupe)
491 self.dictGroupes[nomGroupe] = {}
493 # 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.
494 # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
495 #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
497 # on utilise le fait que obj.valeur est un dictionnaire
499 print "obj.valeur.keys()= %s" % obj.valeur.keys()
500 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
501 raise ValueError, nomgroupe + tr(" : ce MACRO_GROUPE ne peut pas contenir a la fois un MATERIAL et une SOURCE.")
502 # association a une source
503 if 'SOURCE' in obj.valeur.keys():
504 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
505 self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
506 # erreur ni materiau ni source associee
507 if 'LISTE_MESHGROUP' in obj.valeur.keys():
508 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.
509 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
510 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
511 for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
512 groupe = groupe.replace("'", "") # suppression des guillement simpes
513 groupe = groupe.replace('"', "") # suppression des guillement doubles
514 self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
515 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).
516 self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
517 if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
518 raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques.")
519 # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
520 if 'Domaine' in obj.valeur.keys():
521 if listeStrandedInductorGeometry: # Domaine seulement en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
522 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
523 self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
525 texte+="%s"%(obj.valeur['Domaine'])
526 print"le texte=%s" %(texte)
527 self.dictDomaine[obj.get_sdname()]=texte
528 else: # Erreur si Domaine et macro-groupe pas complètement inducteur
529 raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE ne doit pas contenir de Domaine car il contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques.")
530 else: # Domaine manquant
531 if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
532 raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine.")
534 raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE doit contenir une liste de groupes LISTE_MESHGROUP.")
536 print "self.dictGroupes= %s" % repr(self.dictGroupes)
537 print "self.dictDomaine=%s" %(self.dictDomaine)
538 except ValueError, err:
539 raise ValueError, str(err)
542 def generSOLVEUR(self, obj):
544 print "generation material obj.valeur = %s" % obj.valeur
546 nature = obj.valeur['Type']
547 if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
548 except ValueError, err:
549 raise ValueError, str(err)
551 def generSOLVEUR_LINEAIRE(self, obj):
553 print "generation material obj.valeur = %s" % obj.valeur
555 nature = obj.valeur['Methode_lineaire']
556 if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
557 if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
558 except ValueError, err:
559 raise ValueError, str(err)
561 def generMETHODE_ITERATIVE_BICGCR(self, obj):
564 print "_____________iter_____________"
566 self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
567 self.texteCarmel3D_PARAM_SOLV+=" NAME BICGCR\n"
568 self.texteCarmel3D_PARAM_SOLV+=" [ITERATIVE_PARAM \n"
569 self.texteCarmel3D_PARAM_SOLV+=" NITERMAX "+str(obj.valeur["Nombre_iterations_max"])+"\n"
570 self.texteCarmel3D_PARAM_SOLV+=" EPSILON "+str(obj.valeur["Precision"])+"\n"
571 self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
573 print "texte = %s", texte
576 def generMETHODE_DIRECTE_MUMPS(self, obj):
579 print "_____________directe_____________"
581 self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
582 self.texteCarmel3D_PARAM_SOLV+=" NAME MUMPS\n"
583 self.texteCarmel3D_PARAM_SOLV+=" [MUMPS_PARAMETER \n"
584 self.texteCarmel3D_PARAM_SOLV+=" SYM "+str(obj.valeur["Type_de_matrice"])+"\n"
585 self.texteCarmel3D_PARAM_SOLV+=" ICNTL "+str(obj.valeur["ICNTL_Control_Parameters"])+" "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
586 self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
588 print "texte = %s", texte
592 def generMATERIAL(self,obj):
593 """preparation du bloc correspondant a un materiau du fichier PHYS"""
596 print "generation material obj.valeur = %s" % obj.valeur
598 nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
599 if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
600 if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
601 if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
602 if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
603 if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
604 if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
605 if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
606 except ValueError, err:
607 raise ValueError, str(err)
609 def generMATERIAL_CONDUCTOR(self,obj):
610 """preparation du sous bloc CONDUCTOR"""
613 print "_____________cond_____________"
614 # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
615 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
616 print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
617 raise ValueError, obj.get_sdname() + tr(" : ce materiau conducteur (CONDUCTOR) doit contenir les proprietes PERMEABILITY et CONDUCTIVITY.")
619 # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
620 for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
621 # debut du sous bloc de propriete du DIELECTRIC
622 texte+=" ["+keyN1+"\n"
623 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
624 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
625 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
626 # car sinon ces valeurs sont definies dans des fichiers annexes
627 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
628 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
629 if homogeneous and isotropic:
630 # loi (lineaire ou non)
631 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
632 # valeur de la loi lineaire
633 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
634 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
635 # seuls les reels sont pris en compte
636 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
637 texte+=" [NONLINEAR \n"
638 texte+=" ISOTROPY TRUE\n"
639 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
640 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
641 for keyN2 in obj.valeur[keyN1] :
642 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
643 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
644 # fin du sous-bloc NONLINEAR
646 # fin du sous bloc de propriete
649 print "texte = %s", texte
650 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
652 def generMATERIAL_DIELECTRIC(self,obj):
653 """preparation du sous bloc DIELECTRIC"""
656 print "______________nocond_____________"
657 # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
658 if 'PERMITTIVITY' not in obj.valeur:
659 print "obj.valeur=%s" %obj.valeur
660 obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
662 # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
663 for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
664 # debut du sous bloc de propriete du DIELECTRIC
665 texte+=" ["+keyN1+"\n"
666 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
667 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
668 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
669 # car sinon ces valeurs sont definies dans des fichiers annexes
670 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
671 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
672 if homogeneous and isotropic:
673 # loi (lineaire ou non)
674 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
675 # valeur de la loi lineaire
676 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
677 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
678 # seuls les reels sont pris en compte
679 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
680 texte+=" [NONLINEAR \n"
681 texte+=" ISOTROPY TRUE\n"
682 texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
683 # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
684 for keyN2 in obj.valeur[keyN1] :
685 if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
686 texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
687 # fin du sous-bloc NONLINEAR
689 # fin du sous bloc de propriete
692 print "texte = %s" % texte
693 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
695 def generMATERIAL_ZSURFACIC(self,obj):
696 """preparation du sous bloc ZSURFACIC"""
699 print "______________zsurf_____________"
700 # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
701 if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
702 print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
703 raise ValueError, obj.get_sdname() + tr(" : ce materiau impedance de surface (ZSURFACIC) doit contenir les proprietes PERMEABILITY et CONDUCTIVITY.")
705 # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
706 for keyN1 in obj.valeur :
707 if keyN1=='TYPE': continue
708 # print "type loi = ", obj.valeur[keyN1]['LAW']
709 # debut du sous bloc de propriete du DIELECTRIC
710 texte+=" ["+keyN1+"\n"
711 texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
712 texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
713 # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
714 # car sinon ces valeurs sont definies dans des fichiers annexes
715 homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
716 isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
717 if homogeneous and isotropic:
718 # loi (lineaire ou non)
719 texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
720 # valeur de la loi lineaire
721 texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
722 # fin du sous bloc de propriete
725 print "texte = %s", texte
726 self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
728 def generMATERIAL_EMISO(self,obj):
729 """preparation du sous bloc EM_ISOTROPIC_FILES.
730 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
731 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
733 if "CONDUCTIVITY_File" in obj.valeur:
734 texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
735 if "PERMEABILITY_File" in obj.valeur:
736 texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
737 # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
738 #from os.path import basename
739 #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
740 #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
741 # print "obj get sdname= ", obj.get_sdname()
742 # if obj.get_sdname() in self.dictMaterEmIso.keys() :
743 # self.dictMaterEmIso[obj.get_sdname()].append(texte)
745 self.dictMaterEmIso[obj.get_sdname()]=texte
747 def generMATERIAL_EMANISO(self,obj):
748 """preparation du sous bloc EM_ANISOTROPIC_FILES.
749 Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
750 ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
752 if "CONDUCTIVITY_File" in obj.valeur:
753 texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
754 if "PERMEABILITY_File" in obj.valeur:
755 texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
756 # print "obj get sdname= ", obj.get_sdname()
757 # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
758 # self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
760 self.dictMaterEmAnIso[obj.get_sdname()]=texte
762 def generMATERIAL_NILMAT(self,obj):
763 """preparation du sous bloc NILMAT"""
765 self.dictMaterNilmat[obj.get_sdname()]=texte
767 def generMATERIAL_ZINSULATOR(self,obj):
768 """"preparation du sous bloc ZINSULATOR"""
770 self.dictMaterZinsulator[obj.get_sdname()]=texte
772 #-------------------------------------------------------------------
774 def generSOURCE(self,obj):
775 """preparation du bloc correspondant a une source du fichier PHYS"""
777 print "generation source obj valeur = %s" % obj.valeur
780 # test de la presence des types de sources reconnus
781 # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
782 # la source ne peut contenir au plus qu'un type de source.
783 if "STRANDED_INDUCTOR" in obj.valeur:
784 self.generSOURCE_STRANDED_INDUCTOR(obj)
785 elif "HPORT" in obj.valeur:
786 self.generSOURCE_HPORT(obj)
787 elif "EPORT" in obj.valeur:
788 self.generSOURCE_EPORT(obj)
790 print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
791 except ValueError, err:
792 raise ValueError, str(err)
794 def generSOURCE_STRANDED_INDUCTOR(self,obj):
795 """preparation du sous bloc STRANDED_INDUCTOR"""
797 sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
799 texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
800 self.nturns=sdict['NTURNS']
801 # test de la presence d'une forme de source reconnue
802 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
803 # la source ne peut contenir au plus qu'un type de source.
804 if "WAVEFORM_CONSTANT" in obj.valeur:
805 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
806 if self.problem == HARMONIC:
807 texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
808 elif "WAVEFORM_SINUS" in obj.valeur:
809 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
810 if self.problem == HARMONIC:
811 texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
812 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
813 self.dictSourceStInd[obj.get_sdname()]=texte
816 except ValueError, err:
817 raise ValueError, str(err)
819 def generSOURCE_HPORT(self,obj):
820 """preparation du sous bloc HPORT"""
822 sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
823 nomPort = obj.get_sdname()
824 self.dictPort[nomPort] = {}
825 self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
827 texte+=" TYPE %s\n" % str(sdict['TYPE'])
828 # test de la presence d'une forme de source reconnue
829 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
830 # la source ne peut contenir au plus qu'un type de source.
831 if "WAVEFORM_CONSTANT" in obj.valeur:
832 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
833 if self.problem == HARMONIC:
834 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
835 elif "WAVEFORM_SINUS" in obj.valeur:
836 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
837 if self.problem == HARMONIC:
838 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
839 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
840 self.dictSourceHport[obj.get_sdname()]=texte
843 except ValueError, err:
844 raise ValueError, str(err)
846 def generSOURCE_EPORT(self,obj):
849 """preparation du sous bloc EPORT"""
851 sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
852 nomPort = obj.get_sdname()
853 self.dictPort[nomPort] = {}
854 self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
855 print "sdict=%s" %(sdict)
857 texte+=" TYPE %s\n" % str(sdict['TYPE'])
858 # test de la presence d'une forme de source reconnue
859 # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
860 # la source ne peut contenir au plus qu'un type de source.
861 if "WAVEFORM_CONSTANT" in obj.valeur:
862 wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
863 if self.problem == HARMONIC:
864 texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
865 elif "WAVEFORM_SINUS" in obj.valeur:
866 wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
867 if self.problem == HARMONIC:
868 texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
869 % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
870 self.dictSourceEport[obj.get_sdname()]=texte
873 except ValueError, err:
874 raise ValueError, str(err)
877 def generPARAM_CIRCULAIRE(self, obj):
879 print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
880 self.centre=obj.valeur["Centre"]
882 def generPOST_COMMANDS(self, obj):
883 """Création du texte de commandes de post-traitement toto.cmd"""
885 print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
887 if obj.valeur.has_key('GLOBAL'):
888 self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
890 if obj.valeur.has_key('DUMP'):
891 champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
892 self.texteCarmel3D_CMD+="[\nDUMP"
893 self.texteCarmel3D_CMD+="\n"+self.projet + '_postgroups.txt'
894 self.texteCarmel3D_CMD+="\n"+champsFieldkind[obj.valeur["DUMP"]["fieldkind"]]+"\n]\n"
896 if obj.valeur.has_key('FIELDDUMP'):
897 champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'}
898 champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
899 self.texteCarmel3D_CMD+="[\nFIELDDUMP"
900 if type(obj.valeur["FIELDDUMP"]) == types.DictType: # correspondance sur une 'Fielddump'
901 self.fielddumpValeur.append(obj.valeur["FIELDDUMP"])
903 self.fielddumpValeur=obj.valeur["FIELDDUMP"] # correspondance sur plusieurs 'Fielddump'
904 for indexFielddump in self.fielddumpValeur:
905 self.texteCarmel3D_CMD+="\n [\n" +" "+ champs[indexFielddump["field"]]
906 self.texteCarmel3D_CMD+="\n" + " " + champsFieldkind[indexFielddump["fieldkind"]] + "\n ]"
907 self.texteCarmel3D_CMD+="\n]\n"
910 if obj.valeur.has_key('VISU'):
911 self.texteCarmel3D_CMD+="[\nVISU"
912 # test de fichier de maillage bien lu
913 if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
914 self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
915 self.texteCarmel3D_CMD+=obj.valeur["VISU"]["visu_format"]+"\n"
916 self.texteCarmel3D_CMD+=obj.valeur["VISU"]["visu_type"]+"\n]\n"
918 if obj.valeur.has_key('VISU3D'):
919 champsField = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
920 champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
921 if type(obj.valeur["VISU3D"])==types.DictType: # correspondance sur une 'VISU3D'
922 self.visu3dValeur.append(obj.valeur["VISU3D"])
924 self.visu3dValeur=obj.valeur["VISU3D"] # correspondance sur plusieurs 'VISU3D'
925 self.texteCarmel3D_CMD+="[\nVISU3D"
926 if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
927 self.texteCarmel3D_CMD+="\n"+ self.projet
928 self.texteCarmel3D_CMD+="\n" + self.visu3dValeur[0]["visu_format"]
929 for indexVisu3d in self.visu3dValeur:
930 if indexVisu3d["visu_format"]!=self.visu3dValeur[0]["visu_format"]:
931 print "ERREUR! Dans les multiples VISU3D du bloc POST_COMMANDS, le parametre visu_format doit prendre la meme valeur."
932 raise ValueError, tr("Dans les multiples VISU3D du bloc POST_COMMANDS, le parametre visu_format doit prendre la meme valeur.")
933 self.texteCarmel3D_CMD+="\n [\n " + champsField[indexVisu3d["field"]]
934 self.texteCarmel3D_CMD+="\n "+ champsFieldkind[indexVisu3d["fieldkind"]]
935 self.texteCarmel3D_CMD+="\n "+ indexVisu3d["visu_type"]+"\n ]"
936 self.texteCarmel3D_CMD+="\n]\n"
938 if obj.valeur.has_key('ASTER_RMS_LOSSES'):
939 self.texteCarmel3D_CMD+="[\nASTER_RMS_LOSSES"
940 if self.fichierMaillage == "": raise ValueError, tr("Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au-dessus du bloc POST_COMMANDS.")
941 self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
942 self.texteCarmel3D_CMD+= obj.valeur["ASTER_RMS_LOSSES"]["rms_losses_format"] +"\n]\n"
944 if obj.valeur.has_key('CUTLINE'):
945 # création du champ, renommé par rapport à l'interface
946 champsField = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD', 'pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD', 'T':'TFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
947 champsFieldkind={'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
948 champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
949 champsLissage={'aucun':'NONE', 'un seul point par element':'1PTELT'}
950 if type(obj.valeur["CUTLINE"]) == types.DictType: # correspondance sur une 'Cutline'
951 self.cutlineValeur.append(obj.valeur["CUTLINE"]) # transfert d'une dictionnaire à une liste
953 self.cutlineValeur=obj.valeur["CUTLINE"] # correspondance sur plusieurs 'Cutline'
954 for indexCutline in self.cutlineValeur:
955 self.texteCarmel3D_CMD+="[\nCUTLINE"
956 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutline["first_point"]), )
957 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutline["last_point"]), )
958 self.texteCarmel3D_CMD+="\n%d" % (indexCutline["number_of_points"], )
959 self.texteCarmel3D_CMD+="\n" +indexCutline["name"]
960 self.texteCarmel3D_CMD+="\n" + champsField[indexCutline["field"]]
961 if indexCutline.has_key('fieldkind'):
962 self.texteCarmel3D_CMD+="\nFIELDKIND " + champsFieldkind[indexCutline["fieldkind"]]
963 if indexCutline.has_key('output'):
964 self.texteCarmel3D_CMD+="\nOUTPUT " +champsOutput[indexCutline["output"]]
965 if indexCutline.has_key('lissage'):
966 self.texteCarmel3D_CMD+="\nSMOOTHLEVEL " +champsLissage[indexCutline["lissage"]]
967 self.texteCarmel3D_CMD+="\n]\n"
969 if obj.valeur.has_key('CUTPLANE'):
970 champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD','pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
971 champsFieldkind= {'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
972 champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
973 champsLissage={'aucun':'NONE', 'un seul point par element':'1PTELT'}
974 axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
975 if type(obj.valeur["CUTPLANE"]) == types.DictType:
976 self.cutplaneValeur.append(obj.valeur["CUTPLANE"]) # correspondance sur une 'Cutplane'
978 self.cutplaneValeur=obj.valeur["CUTPLANE"] # correspondance sur plusieurs 'Cutplane'
979 for indexCutplane in self.cutplaneValeur:
980 self.texteCarmel3D_CMD+="[\nCUTPLANE"
981 self.texteCarmel3D_CMD+="\n%d" % (axes[indexCutplane["normal_vector"]], )
982 self.texteCarmel3D_CMD+="\n%f" % (indexCutplane["plane_position"], )
983 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexCutplane["number_of_points"]))
984 self.texteCarmel3D_CMD+="\n" + indexCutplane["name"]
985 self.texteCarmel3D_CMD+="\n" + champs[indexCutplane["field"]]
986 if indexCutplane.has_key('fieldkind'):
987 self.texteCarmel3D_CMD+="\nFIELDKIND " + champsFieldkind[indexCutplane["fieldkind"]]
988 if indexCutplane.has_key('output'):
989 self.texteCarmel3D_CMD+="\nOUTPUT " +champsOutput[indexCutplane["output"]]
990 if indexCutplane.has_key('lissage'):
991 self.texteCarmel3D_CMD+="\nSMOOTHLEVEL " +champsLissage[indexCutplane["lissage"]]
992 self.texteCarmel3D_CMD+="\n]\n"
994 if obj.valeur.has_key('FIELDMAP'):
995 champs = {'T':'TFIELD','H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD','pertesJoule':'OHMLOSS_DENSITY', 'champSource':'SOURCEFIELD', 'A':'AFIELD', 'Phi':'PHIFIELD', 'Omega':'OMEGAFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
996 champsFieldkind= {'total':'TOTAL', 'reaction':'REACTION', 'diffracted':'DIFFRACTED'}
997 champsOutput={'xgraphic':'XGRAPHIC', 'gnuplot':'GNUPLOT', 'gmsh':'GMSH'}
998 champsFieldmap_type={'equation':'EQUATION', 'fichier':'FILE'}
999 champsType={'plane':'PLANE', 'line':'LINE'}
1000 axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
1001 if type(obj.valeur["FIELDMAP"]) == types.DictType:
1002 self.fieldmapValeur.append(obj.valeur["FIELDMAP"]) # correspondance sur une 'Fieldmap'
1004 self.fieldmapValeur=obj.valeur["FIELDMAP"]# correspondance sur plusieurs 'Fieldmap'
1005 for indexFieldmap in self.fieldmapValeur:
1006 self.texteCarmel3D_CMD+="[\nFIELDMAP"
1007 self.texteCarmel3D_CMD+="\n" + champsFieldmap_type[indexFieldmap["fieldmap_type"]]
1008 if indexFieldmap["fieldmap_type"]=="equation":
1009 self.texteCarmel3D_CMD+="\n" + champsType[indexFieldmap["type"]]
1010 if indexFieldmap["type"]=="line":
1011 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["first_point"]), )
1012 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["last_point"]), )
1013 self.texteCarmel3D_CMD+="\n%d" % (indexFieldmap["number_of_points"], )
1014 if indexFieldmap["type"]=="plane":
1015 self.texteCarmel3D_CMD+="\n%d" % (axes[indexFieldmap["normal_vector"]], )
1016 self.texteCarmel3D_CMD+="\n%f" % (indexFieldmap["plane_position"], )
1017 self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,indexFieldmap["number_of_points"]))
1018 if indexFieldmap["fieldmap_type"]=="fichier":
1019 self.fichierFieldmap=indexFieldmap["filename"]
1020 self.nomFichierFieldmap = os.path.basename(self.fichierFieldmap) # nom du fichier de fieldmap, sans le chemin
1021 self.texteCarmel3D_CMD+="\n" + self.nomFichierFieldmap
1022 self.texteCarmel3D_CMD+="\n" + champs[indexFieldmap["field"]]
1023 self.texteCarmel3D_CMD+="\n" + champsFieldkind[indexFieldmap["fieldkind"]]
1024 self.texteCarmel3D_CMD+="\n" +indexFieldmap["name"] # nom systématique, quel que soit le fieldmap_type, placé entre fieldkind et output
1025 self.texteCarmel3D_CMD+="\n" +champsOutput[indexFieldmap["output"]]
1026 self.texteCarmel3D_CMD+="\n]\n"
1031 #---------------------------------------------------------------------------------------
1032 # traitement fichier PHYS
1033 #---------------------------------------------------------------------------------------
1034 def generBLOC_VERSION(self,obj) :
1035 # constitution du bloc VERSION du fichier PHYS
1036 # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
1037 # dans le du catalogue
1038 version=obj.addentite('VERSION',pos=None)
1039 self.generPROC_ETAPE(obj.etapes[0])
1040 self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
1041 for cle in obj.etapes[0].valeur :
1042 self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
1043 self.texteCarmel3D+="]\n"
1044 # destruction de l entite creee
1045 obj.suppentite(version)
1046 #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
1047 #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
1050 def generBLOC_PARAMETERS(self,obj):
1052 print "generation parameters obj.valeur = %s" % obj.valeur
1054 self.frequency=obj.valeur["FREQUENCY"]
1055 self.repertory=obj.valeur["RepCarmel"]
1056 self.fichierMaillage=obj.valeur["Fichier_maillage"]
1057 self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
1058 self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
1059 self.echelle=obj.valeur["Echelle_du_maillage"]
1060 self.gendof=obj.valeur["Realiser_topologie_gendof"]
1061 self.fcarmel=obj.valeur["Resoudre_probleme"]
1062 self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
1063 self.formulation=obj.valeur["Formulation"]
1064 #----------------------------------------------------------------------------------------
1065 def generBLOC_MATERIALS(self) :
1066 """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
1067 Le bloc MATERIALS existe toujours !
1070 print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
1071 print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
1072 # constitution du bloc MATERIALS du fichier PHYS
1073 self.texteCarmel3D+="[MATERIALS\n"
1074 # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
1075 nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
1076 nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
1078 print "noms groupes de mailles associes a des materiaux \
1079 (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
1080 {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
1082 try: # mise à jour du fichier .phys selon les matériaux trouvés
1083 # constitution du bloc CONDUCTOR du fichier PHYS si existe
1084 if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
1085 # constitution du bloc DIELECTRIC du fichier PHYS si exixte
1086 if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
1087 # constitution du bloc ZSURFACIC du fichier PHYS si exixte
1088 if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
1089 # constitution du bloc NILMAT du fichier PHYS si exixte
1090 if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
1091 # constitution du bloc ZINSULATOR du fichier PHYS si exixte
1092 if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
1093 # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
1094 # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
1095 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
1096 # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
1097 if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
1098 except ValueError, err:
1099 raise ValueError(str(err))
1102 # fin du bloc MATERIALS du fichier PHYS
1103 self.texteCarmel3D+="]\n"
1107 def creaBLOC_CONDUCTOR(self, nomsGroupes) :
1108 """Constitution du bloc CONDUCTOR du fichier PHYS"""
1109 typeBloc = 'CONDUCTOR' # initialisation du type de bloc
1110 dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
1112 print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1113 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1114 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1115 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
1116 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)
1117 raise ValueError, self.dictGroupes[nom]['MATERIAL'][:] + ',' + nom + tr(" : ce materiau (nom, groupe associe) doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement.")
1118 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
1119 or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
1120 self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
1121 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
1122 or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
1123 self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
1124 # ecriture du bloc complet
1125 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1127 nomReel = self.nomReelGroupe(nom, typeBloc)
1130 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1131 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
1132 self.texteCarmel3D+=" ]\n" # fin de bloc
1134 def creaBLOC_DIELECTRIC(self, nomsGroupes) :
1135 """Constitution du bloc DIELECTRIC du fichier PHYS"""
1136 typeBloc = 'DIELECTRIC' # initialisation du type de bloc
1137 dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
1139 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1140 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1141 print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
1142 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1143 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
1144 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)
1145 raise ValueError, self.dictGroupes[nom]['MATERIAL'][:] + ',' + nom + tr(" : ce materiau (nom, groupe associe) doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement.")
1146 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
1147 self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
1148 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
1149 self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
1150 # ecriture du bloc complet
1151 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1152 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
1153 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
1154 self.texteCarmel3D+=" ]\n" # fin de bloc
1156 def creaBLOC_ZSURFACIC(self, nomsGroupes) :
1157 """Constitution du bloc ZSURFACIC du fichier PHYS"""
1158 typeBloc = 'ZSURFACIC' # initialisation du type de bloc
1159 dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
1161 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1162 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1163 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1164 # ecriture du bloc complet
1165 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1167 nomReel = self.nomReelGroupe(nom, typeBloc)
1170 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1171 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
1172 self.texteCarmel3D+=" ]\n" # fin de bloc
1174 def creaBLOC_EMISO(self) :
1175 """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
1176 for cle in self.dictMaterEmIso.keys():
1177 self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
1178 self.texteCarmel3D+= self.dictMaterEmIso[cle]
1179 self.texteCarmel3D+=" ]\n"
1181 def creaBLOC_EMANISO(self) :
1182 """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
1183 for cle in self.dictMaterEmAnIso.keys():
1184 self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
1185 self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
1186 self.texteCarmel3D+=" ]\n"
1188 def creaBLOC_ZINSULATOR(self, nomsGroupes) :
1189 """Constitution du bloc ZINSULATOR du fichier PHYS"""
1190 typeBloc = 'ZINSULATOR' # initialisation du type de bloc
1191 dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
1192 if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
1193 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1194 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1195 # ecriture du bloc complet
1196 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1198 nomReel = self.nomReelGroupe(nom, typeBloc)
1201 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1202 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
1203 self.texteCarmel3D+=" ]\n" # fin de bloc
1205 def creaBLOC_NILMAT(self, nomsGroupes) :
1206 """Constitution du bloc NILMAT du fichier PHYS"""
1207 typeBloc = 'NILMAT' # initialisation du type de bloc
1208 dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
1210 print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1211 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1212 if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1213 # ecriture du bloc complet
1214 self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
1216 nomReel = self.nomReelGroupe(nom, typeBloc)
1219 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1220 self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
1221 self.texteCarmel3D+=" ]\n" # fin de bloc
1223 #----------------------------------------------------------------------------------------
1224 def generBLOC_SOURCES(self):
1225 """constitution du bloc SOURCES du fichier PHYS"""
1226 self.texteCarmel3D+="[SOURCES\n"
1227 # # tri alphabetique de tous les groupes de maillage associes a des sources
1228 nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
1230 # print "RESULTAT APRES FUSION self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
1233 print 'noms groupes de mailles associes a des sources \
1234 (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
1235 {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
1236 'g_maillage_trie': nomsGroupes}
1237 if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
1238 if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
1239 if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
1240 # fin du bloc SOURCES du fichier PHYS
1241 self.texteCarmel3D+="]\n"
1244 def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
1245 """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
1247 print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
1248 typeBloc = 'STRANDED_INDUCTOR'
1249 # print "liste des NOM=%s" %(nom)
1250 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1251 if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
1252 # ecriture du bloc de l'inducteur bobine
1253 self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
1254 self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
1255 self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
1256 self.texteCarmel3D+=" ]\n" # fin de bloc
1258 def creaBLOC_EPORT(self, nomsGroupes) :
1259 """constitution du bloc EPORT du fichier PHYS"""
1261 print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
1263 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1264 if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
1265 # ecriture du bloc du port electrique
1266 self.texteCarmel3D+=" [EPORT\n" # debut de bloc
1268 nomReel = self.nomReelGroupe(nom, typeBloc)
1271 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1272 self.texteCarmel3D+= self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
1273 self.texteCarmel3D+=" ]\n" # fin de bloc
1275 def creaBLOC_HPORT(self, nomsGroupes) :
1276 """constitution du bloc HPORT du fichier PHYS"""
1278 print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
1280 for nom in nomsGroupes: # parcours des noms des groupes de maillage
1281 if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
1282 # ecriture du bloc du port magnetique
1283 self.texteCarmel3D+=" [HPORT\n" # debut de bloc
1285 nomReel = self.nomReelGroupe(nom, typeBloc)
1288 self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1289 self.texteCarmel3D+= self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
1290 self.texteCarmel3D+=" ]\n" # fin de bloc
1292 def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
1293 """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
1296 self.direction=obj.valeur["Direction"]
1297 self.section=obj.valeur["Section"]
1298 self.forme=obj.valeur["Forme"]
1299 # texte+="\n%s" %(self.domaine)
1301 if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
1304 texte+="\n%s" % ' '.join(map(str, self.direction))
1305 texte+="\n%g" % (self.section)
1306 self.dictStrand[obj.get_sdname()]=texte
1310 def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
1312 self.centre=obj.valeur["Centre"]
1314 texte+="\n%s" % ' '.join(map(str,self.direction))
1315 texte+="\n%s" % ' '.join(map(str, self.centre))
1316 texte+="\n%g" % (self.section)
1317 self.dictStrand[obj.get_sdname()]=texte
1322 def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
1323 """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
1324 Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
1327 print 'dictGroupes=', self.dictGroupes
1328 print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
1329 print "nomsGroupes=%s" %(nomsGroupes)
1330 nomsSources=self.dictGroupes['ordreDomaineJdC']
1331 nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
1332 if self.debug: print"nomsSources=%s" %nomsSources
1333 for nom in nomsSources:
1334 if self.debug: print "nomSource courant=",nom
1335 if self.dictGroupes[nom].has_key('SOURCE'):
1336 if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
1337 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
1338 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1340 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
1341 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1342 if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
1343 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, nom + tr(" : il manque un Domaine a cet inducteur.")
1344 strand = self.dictGroupes[nom]['STRAND']
1345 if self.debug: print "un seul morceau : nomStrand courant=", strand
1346 self.texteCarmel3D_INGEND2+= self.dictStrand[strand]
1347 if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
1348 listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
1349 for strand in listeStrand:
1350 #strand = strand.replace("'", "") # suppression des guillemets simples
1351 if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
1352 if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
1353 self.texteCarmel3D_INGEND2+= self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
1355 def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
1357 print "self.dictSourceEport=", self.dictSourceEport
1358 print "self.dictSourceHport=", self.dictSourceHport
1359 nomsSources=self.dictGroupes['ordreDomaineJdC']
1360 nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
1362 for nom in nomsSources:
1363 port=self.dictGroupes[nom]['SOURCE']
1364 if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
1365 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1366 port=self.dictGroupes[nom]['SOURCE']
1368 if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
1369 if self.dictPort[port]['EPORT']=="VOLTAGE":
1370 self.texteCarmel3D_INGEND2+= "\n1"
1372 self.texteCarmel3D_INGEND2+= "\n2"
1373 if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
1374 if self.dictPort[port]['HPORT']=="VOLTAGE":
1375 self.texteCarmel3D_INGEND2+= "\n1"
1377 self.texteCarmel3D_INGEND2+= "\n2"
1379 #-------------------------------------
1380 # Methodes utilitaires
1381 # ------------------------------------
1382 def formateCOMPLEX(self,nbC):
1383 """prise en compte des differentes formes de description d un nombre complexe
1384 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
1388 print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
1390 if isinstance(nbC,(tuple,list)):
1391 if nbC[0] == "'RI'" :
1392 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
1393 if nbC[0] == "'MP'" :
1394 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
1396 nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
1398 print "nbformate : %s" % nbformate
1401 def nomReelGroupe(self, nom, typeBloc=None):
1402 """Calcule et retourne le nom reel du groupe de maillage donne en entree,
1403 en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
1404 de bloc du fichier PHYS specifie.
1405 Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
1407 from string import join
1409 print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
1410 {'nom': nom, 'use_prefix': str(usePrefix)}
1411 nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
1413 # suppression du prefixe si present
1414 partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
1415 # les tests suivants ne generent une erreur que si le prefixe est obligatoire
1416 if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
1417 print "ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
1418 indiquant le type de materiau ou de source associee" % (nom, )
1419 elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
1420 print "ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable" % (nom, )
1422 # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
1423 if typeBloc is not None:
1424 if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
1425 print "ERREUR! ce type de bloc (%s) n'est pas valable" % (str(typeBloc), )
1426 elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
1427 print "ERREUR! ce groupe de maille (%(nom)s) n'a pas \
1428 le prefixe correct pour etre associe a un type %(type_bloc)s", \
1429 {'nom': nom, 'type_bloc': str(typeBloc)}
1431 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1433 print "ce groupe de maille (%(nom)s) a un prefixe qui \
1434 est supprime automatiquement pour devenir : %(nom_reel)s", \
1435 {'nom': nom, 'nom_reel': nomReel}
1437 nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1439 print "ce groupe de maille (%(nom)s) a un prefixe qui \
1440 est supprime automatiquement pour devenir : %(nom_reel)s", \
1441 {'nom': nom, 'nom_reel': nomReel}
1443 print "... %s", nomReel