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