generator/generator_CARMEL3D_frequentiel.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   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.
   8 #
   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.
  13 #
  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
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """Ce module contient le plugin generateur de fichier au format  Code_Carmel3D pour EFICAS.
  21 """
  22
  23 import traceback
  24 import types,string,re,os
  25 from Extensions.i18n import tr
  26 from generator_python import PythonGenerator
  27
  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', ),
  41                                              'EPORT':('EPORT', ),
  42                                              'HPORT':('HPORT', ),
  43                                              'ZSURFACIC':('ZS', ),
  44                                              'ZINSULATOR':('ZJ', ),
  45                                              'NILMAT':('NILMAT', )}
  46 # separateur entre le prefixe et le reste du nom du groupe de maille
  47 sepNomGroupeMaille = '_'
  48
  49
  50 # types de problemes
  51 HARMONIC = 'HARMONIC' # probleme frequentiel
  52 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
  53
  54 # nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
  55 nomPlugin = 'CARMEL3DFV0'
  56
  57 def entryPoint():
  58    """
  59       Retourne les informations necessaires pour le chargeur de plugins
  60       Ces informations sont retournees dans un dictionnaire
  61    """
  62    return {
  63         # Le nom du plugin
  64           'name' : nomPlugin,
  65         # La factory pour creer une instance du plugin
  66           'factory' : CARMEL3DFV0Generator,
  67           }
  68
  69
  70
  71 class CARMEL3DFV0Generator(PythonGenerator):
  72    """
  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')
  76
  77    """
  78    # Les extensions de fichier permis?
  79    extensions=('.comm',)
  80
  81 #----------------------------------------------------------------------------------------
  82    def gener(self,obj,format='brut',config=None):
  83
  84       self.initDico()
  85
  86       #self.debug = True
  87
  88       # Cette instruction genere le contenu du fichier de commandes (persistance)
  89       self.text=PythonGenerator.gener(self,obj,format)
  90
  91       if self.debug:
  92          print "self.text = %s" % self.text
  93
  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)
  96       if obj.isvalid() :
  97            try :
  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()
 104
 105            except ValueError, err:
 106              raise ValueError(str(err))
 107
 108 #      print "texte carmel3d :\n",self.texteCarmel3D
 109 #      print "dictMaterDielectric : ",self.dictMaterDielectric
 110       if self.debug:
 111          print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
 112          print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
 113
 114       return self.text
 115
 116
 117
 118
 119 #----------------------------------------------------------------------------------------
 120 # initialisations
 121 #----------------------------------------------------------------------------------------
 122
 123    def initDico(self) :
 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={}
 149       self.dictStrand={}
 150       self.dictDomaine={}
 151       self.dictPort={}
 152       self.cutlineValeur=[]
 153       self.cutplaneValeur=[]
 154       self.visu3dValeur=[]
 155       self.fieldmapValeur=[]
 156       self.fielddumpValeur=[]
 157       self.repertory=""
 158       self.frequency=""
 159       self.domaine=""
 160       self.direction=""
 161       self.section=""
 162       self.forme=""
 163       self.centre=""
 164       self.echelle=""
 165       self.visu=False
 166       self.post_global=False
 167       self.visu_format=""
 168       self.visu_type=""
 169       self.gendof=""
 170       self.fcarmel=""
 171       self.postprocess=""
 172       self.formulation=""
 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.
 180
 181 #----------------------------------------------------------------------------------------
 182 # ecriture
 183 #----------------------------------------------------------------------------------------
 184
 185    def writeDefault(self,fn) :
 186         """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
 187
 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
 193
 194
 195         if self.debug:
 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)
 201         f.close()
 202
 203
 204         if self.debug:
 205             print "ecriture du fichier de parametres (PARAM)"
 206         filePARAM = file + '.param'
 207         f = open( str(filePARAM), 'w')
 208         f.write('[VERSION \n'
 209                     '   NUM     1\n'
 210                     '   FILETYPE PARAM\n]\n'
 211                     '[PROBLEM\n'
 212                     '   NAME HARMONIC\n]\n'
 213                 )
 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)
 227         f.close()
 228
 229         # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
 230         if self.debug:
 231             print "ecriture du fichier de parametres (CMD)"
 232         fileCMD =file + '.cmd'
 233         f = open( str(fileCMD), 'w')
 234         f.write(self.texteCarmel3D_CMD)
 235         f.close()
 236
 237
 238         if self.debug:
 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)
 243
 244         nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
 245         nomsGroupes.sort()
 246
 247         #if self.dictDomaine !={}:
 248         try:
 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)
 259         f.close()
 260
 261         if self.debug:
 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)
 267         f.close()
 268
 269         if self.debug:
 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)
 277         f.close()
 278
 279         print "dictionnaire complet=%s" %self.dictGroupes
 280         print "dictionnaire des ports =%s"  %self.dictPort
 281         if self.debug:
 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"
 291             else:
 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)
 300         f.close()
 301
 302 #----------------------------------------------------------------------------------------
 303 #  analyse de chaque noeud de l'arbre
 304 #----------------------------------------------------------------------------------------
 305
 306    def generMCSIMP(self,obj) :
 307         """recuperation de l objet MCSIMP"""
 308         if self.debug:
 309             print "MCSIMP %(v_1)s  %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
 310         s=PythonGenerator.generMCSIMP(self,obj)
 311         try:
 312             self.dicoCourant[obj.nom]=obj.valeurFormatee
 313         except:
 314             print "Oubli des messages texte homo='information'"
 315         return s
 316
 317
 318 #----------------------------------------------------------------------------------------
 319    def generMCFACT(self,obj) :
 320         """recuperation de l objet MCFACT"""
 321         if self.debug:
 322             print "MCFACT debut %(v_1)s  %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
 323         dico={}
 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
 349         if self.debug:
 350             print "MCFACT fin %(v_1)s  %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
 351         return s
 352
 353
 354 #----------------------------------------------------------------------------------------
 355    def generPROC_ETAPE(self,obj):
 356         """analyse des PROC du catalogue  ( VERSION )"""
 357         if self.debug:
 358             print "PROC_ETAPE initial: %(v_1)s  %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
 359         dico={}
 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
 364         if self.debug:
 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
 370         return s
 371
 372
 373
 374 #----------------------------------------------------------------------------------------
 375    def generETAPE(self,obj):
 376         """analyse des OPER du catalogue"""
 377         if self.debug:
 378             print "ETAPE mis a jour: obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
 379         dico={}
 380         self.dicoEtapeCourant=dico
 381         self.dicoCourant=self.dicoEtapeCourant
 382         s=PythonGenerator.generETAPE(self,obj)
 383         obj.valeur=self.dicoEtapeCourant # cf. generPROC_ETAPE
 384         if self.debug:
 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
 392         return s
 393
 394 #----------------------------------------------------------------------------------------
 395    def generMACRO_ETAPE(self,obj):
 396         dico={}
 397         self.dicoEtapeCourant=dico
 398         self.dicoCourant=self.dicoEtapeCourant
 399         import generator
 400         monGenerateur=generator.plugins[nomPlugin]()
 401         jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
 402         if self.debug:
 403             print "jdc_aux_texte : %s" % jdc_aux_texte
 404
 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]
 419
 420         print "________FIN MACRO______________________________________"
 421         s=PythonGenerator.generMACRO_ETAPE(self,obj)
 422         return s
 423
 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
 430         """
 431         try:
 432             if usePrefix:
 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)
 435             else:
 436                 nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
 437                 print "liste des noms sans prefixes %s" %(nomGroupe)
 438
 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
 442             #
 443             # on utilise le fait que obj.valeur est un dictionnaire
 444             self.dictGroupes[nomGroupe] = {}
 445 #            nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
 446             if self.debug:
 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)
 465                 texte=""
 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'])
 470
 471 #            else:
 472 #                raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
 473             if self.debug:
 474                 print "self.dictGroupes= %s" % repr(self.dictGroupes)
 475         except ValueError, err:
 476             raise ValueError, str(err)
 477
 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
 482         """
 483         try:
 484             #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
 485             if usePrefix:
 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)
 488             else:
 489                 nomGroupe = obj.get_sdname() # nom du macro groupe
 490                 print "liste des noms sans prefixes %s" %(nomGroupe)
 491             self.dictGroupes[nomGroupe] = {}
 492
 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
 496             #
 497             # on utilise le fait que obj.valeur est un dictionnaire
 498             if self.debug:
 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)
 524                         texte=""
 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.")
 533             else:
 534                 raise ValueError, nomGroupe + tr(" : ce MACRO_GROUPE doit contenir une liste de groupes LISTE_MESHGROUP.")
 535             if self.debug:
 536                 print "self.dictGroupes= %s" % repr(self.dictGroupes)
 537                 print "self.dictDomaine=%s" %(self.dictDomaine)
 538         except ValueError, err:
 539             raise ValueError, str(err)
 540
 541
 542    def generSOLVEUR(self, obj):
 543         if self.debug:
 544             print "generation material obj.valeur = %s" % obj.valeur
 545         try :
 546             nature = obj.valeur['Type']
 547             if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
 548         except ValueError,  err:
 549             raise ValueError,  str(err)
 550
 551    def generSOLVEUR_LINEAIRE(self, obj):
 552         if self.debug:
 553             print "generation material obj.valeur = %s" % obj.valeur
 554         try :
 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)
 560
 561    def generMETHODE_ITERATIVE_BICGCR(self, obj):
 562         texte=""
 563         if self.debug:
 564             print "_____________iter_____________"
 565
 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"
 572         if self.debug:
 573            print "texte = %s", texte
 574
 575
 576    def generMETHODE_DIRECTE_MUMPS(self, obj):
 577         texte=""
 578         if self.debug:
 579             print "_____________directe_____________"
 580
 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"
 587         if self.debug:
 588            print "texte = %s", texte
 589
 590
 591
 592    def generMATERIAL(self,obj):
 593         """preparation du bloc correspondant a un materiau du fichier PHYS"""
 594         texte=""
 595         if self.debug:
 596             print "generation material obj.valeur = %s" % obj.valeur
 597         try :
 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)
 608
 609    def generMATERIAL_CONDUCTOR(self,obj):
 610        """preparation du sous bloc CONDUCTOR"""
 611        texte=""
 612        if self.debug:
 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.")
 618        else:
 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
 645                    texte+="            ]"+"\n"
 646              # fin du sous bloc de propriete
 647              texte+="         ]"+"\n"
 648        if self.debug:
 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
 651
 652    def generMATERIAL_DIELECTRIC(self,obj):
 653         """preparation du sous bloc DIELECTRIC"""
 654         texte=""
 655         if self.debug:
 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}
 661
 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
 688                texte+="            ]"+"\n"
 689          # fin du sous bloc de propriete
 690          texte+="         ]"+"\n"
 691         if self.debug:
 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
 694
 695    def generMATERIAL_ZSURFACIC(self,obj):
 696        """preparation du sous bloc ZSURFACIC"""
 697        texte=""
 698        if self.debug:
 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.")
 704        else:
 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
 723              texte+="         ]"+"\n"
 724        if self.debug:
 725            print "texte = %s", texte
 726        self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
 727
 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.
 732        """
 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)
 744        # else :
 745        self.dictMaterEmIso[obj.get_sdname()]=texte
 746
 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.
 751         """
 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)
 759        #  else :
 760         self.dictMaterEmAnIso[obj.get_sdname()]=texte
 761
 762    def generMATERIAL_NILMAT(self,obj):
 763        """preparation du sous bloc NILMAT"""
 764        texte=""
 765        self.dictMaterNilmat[obj.get_sdname()]=texte
 766
 767    def generMATERIAL_ZINSULATOR(self,obj):
 768        """"preparation du sous bloc ZINSULATOR"""
 769        texte=""
 770        self.dictMaterZinsulator[obj.get_sdname()]=texte
 771
 772 #-------------------------------------------------------------------
 773
 774    def generSOURCE(self,obj):
 775         """preparation du bloc correspondant a une source du fichier PHYS"""
 776         if self.debug:
 777             print "generation source obj valeur = %s" % obj.valeur
 778         texte=""
 779         try :
 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)
 789             else:
 790                print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
 791         except ValueError, err:
 792             raise ValueError, str(err)
 793
 794    def generSOURCE_STRANDED_INDUCTOR(self,obj):
 795         """preparation du sous bloc STRANDED_INDUCTOR"""
 796         texte=""
 797         sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
 798         try :
 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
 814             if self.debug:
 815                 print texte
 816         except ValueError, err:
 817             raise ValueError, str(err)
 818
 819    def generSOURCE_HPORT(self,obj):
 820         """preparation du sous bloc HPORT"""
 821         texte=""
 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'])
 826         try :
 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
 841             if self.debug:
 842                 print texte
 843         except ValueError, err:
 844             raise ValueError, str(err)
 845
 846    def generSOURCE_EPORT(self,obj):
 847
 848
 849         """preparation du sous bloc EPORT"""
 850         texte=""
 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)
 856         try :
 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
 871             if self.debug:
 872                 print texte
 873         except ValueError, err:
 874             raise ValueError, str(err)
 875
 876 #
 877    def generPARAM_CIRCULAIRE(self, obj):
 878         if self.debug:
 879             print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
 880         self.centre=obj.valeur["Centre"]
 881
 882    def generPOST_COMMANDS(self, obj):
 883         """Création du texte de commandes de post-traitement toto.cmd"""
 884         if self.debug:
 885             print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
 886
 887         if obj.valeur.has_key('GLOBAL'):
 888             self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
 889
 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"
 895
 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"])
 902             else:
 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"
 908
 909
 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"
 917
 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"])
 923             else:
 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"
 937
 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"
 943
 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
 952             else:
 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"
 968
 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'
 977             else:
 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"
 993
 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'
1003             else:
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"
1027
1028
1029
1030
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'
1048
1049
1050    def generBLOC_PARAMETERS(self,obj):
1051         if self.debug:
1052             print "generation parameters obj.valeur = %s" % obj.valeur
1053
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 !
1068         """
1069         if self.debug:
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
1077         if self.debug:
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'], \
1081                              'v_2': nomsGroupes}
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))
1100
1101
1102         # fin du bloc MATERIALS du fichier PHYS
1103         self.texteCarmel3D+="]\n"
1104
1105
1106
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
1111         if self.debug:
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
1126                 if usePrefix:
1127                     nomReel = self.nomReelGroupe(nom, typeBloc)
1128                 else:
1129                     nomReel = nom
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
1133
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
1138         if self.debug:
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
1155
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
1160         if self.debug:
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
1166                 if usePrefix:
1167                     nomReel = self.nomReelGroupe(nom, typeBloc)
1168                 else:
1169                     nomReel = nom
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
1173
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"
1180
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"
1187
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
1197                 if usePrefix:
1198                     nomReel = self.nomReelGroupe(nom, typeBloc)
1199                 else:
1200                     nomReel = nom
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
1204
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
1209         if self.debug:
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
1215                 if usePrefix:
1216                     nomReel = self.nomReelGroupe(nom, typeBloc)
1217                 else:
1218                     nomReel = nom
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
1222
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'][:]
1229         nomsGroupes.sort()
1230      #   print "RESULTAT APRES FUSION  self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
1231
1232         if self.debug:
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"
1242
1243
1244    def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
1245         """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
1246         if self.debug:
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
1257
1258    def creaBLOC_EPORT(self, nomsGroupes) :
1259         """constitution du bloc EPORT du fichier PHYS"""
1260         if self.debug:
1261             print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
1262         typeBloc = 'EPORT'
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
1267                 if usePrefix:
1268                     nomReel = self.nomReelGroupe(nom, typeBloc)
1269                 else:
1270                     nomReel = nom
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
1274
1275    def creaBLOC_HPORT(self, nomsGroupes) :
1276         """constitution du bloc HPORT du fichier PHYS"""
1277         if self.debug:
1278             print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
1279         typeBloc = 'HPORT'
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
1284                 if usePrefix:
1285                     nomReel = self.nomReelGroupe(nom, typeBloc)
1286                 else:
1287                     nomReel = nom
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
1291
1292    def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
1293         """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
1294
1295         texte=""
1296         self.direction=obj.valeur["Direction"]
1297         self.section=obj.valeur["Section"]
1298         self.forme=obj.valeur["Forme"]
1299 #        texte+="\n%s" %(self.domaine)
1300
1301         if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
1302         else:
1303             texte+="\n1"
1304             texte+="\n%s" % ' '.join(map(str, self.direction))
1305             texte+="\n%g" % (self.section)
1306             self.dictStrand[obj.get_sdname()]=texte
1307         if self.debug:
1308             print texte
1309
1310    def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
1311             texte=""
1312             self.centre=obj.valeur["Centre"]
1313             texte+="\n2"
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
1318             if self.debug:
1319                 print texte
1320
1321
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.
1325         """
1326         if self.debug:
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
1339             else:
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'] ]
1354
1355    def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
1356         if self.debug:
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
1361
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']
1367
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"
1371                     else:
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"
1376                     else:
1377                         self.texteCarmel3D_INGEND2+= "\n2"
1378
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
1385         """
1386         if self.debug:
1387             print "formatage"
1388             print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
1389         nbformate =""
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])
1395         else:
1396             nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
1397         if self.debug:
1398             print "nbformate : %s" % nbformate
1399         return nbformate
1400
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.
1406         """
1407         from string import join
1408         if self.debug:
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
1412         if usePrefix:
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, )
1421             else:
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)}
1430                     else: # c'est bon
1431                         nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1432                         if self.debug:
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}
1436                 else: # c'est bon
1437                     nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1438                     if self.debug:
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}
1442         if self.debug:
1443             print "... %s", nomReel
1444         return nomReel