generator/generator_CARMEL3D_frequentiel.py

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