generator/generator_CARMEL3D_frequentiel.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """Ce module contient le plugin generateur de fichier au format  Code_Carmel3D pour EFICAS.
  21 """
  22
  23 import traceback
  24 import types,string,re,os
  25 from Extensions.i18n import tr
  26 from generator_python import PythonGenerator
  27
  28 # Groupes de mailles dont les types sont definis par des prefixes dans leur nom
  29 usePrefix = False # les noms ont des prefixes (True) ou non (False)
  30 # liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
  31 # Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
  32 listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
  33                          "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
  34                          "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
  35                          "PORT_OMEGA","POST_PHI","PB_GRID",
  36                          "SCUTE","SCUTN","ZS","ZJ","ZT")
  37 # liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
  38 dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
  39                                              'CONDUCTOR':('COND',),
  40                                              'STRANDED_INDUCTOR':('CURRENT', ),
  41                                              'EPORT':('EPORT', ),
  42                                              'HPORT':('HPORT', ),
  43                                              'ZSURFACIC':('ZS', ),
  44                                              'ZINSULATOR':('ZJ', ),
  45                                              'NILMAT':('NILMAT', )}
  46 # separateur entre le prefixe et le reste du nom du groupe de maille
  47 sepNomGroupeMaille = '_'
  48
  49
  50 # types de problemes
  51 HARMONIC = 'HARMONIC' # probleme frequentiel
  52 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
  53
  54 # nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
  55 nomPlugin = 'CARMEL3DFV0'
  56
  57 def entryPoint():
  58    """
  59       Retourne les informations necessaires pour le chargeur de plugins
  60       Ces informations sont retournees dans un dictionnaire
  61    """
  62    return {
  63         # Le nom du plugin
  64           'name' : nomPlugin,
  65         # La factory pour creer une instance du plugin
  66           'factory' : CARMEL3DFV0Generator,
  67           }
  68
  69
  70
  71 class CARMEL3DFV0Generator(PythonGenerator):
  72    """
  73       Ce generateur parcourt un objet de type JDC et produit
  74       un texte au format eficas et
  75       un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
  76
  77    """
  78    # Les extensions de fichier permis?
  79    extensions=('.comm',)
  80
  81 #----------------------------------------------------------------------------------------
  82    def gener(self,obj,format='brut',config=None):
  83
  84       self.initDico()
  85
  86       #self.debug = True
  87
  88       # Cette instruction genere le contenu du fichier de commandes (persistance)
  89       self.text=PythonGenerator.gener(self,obj,format)
  90
  91       if self.debug:
  92          print "self.text = %s" % self.text
  93
  94       # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
  95       # si le jdc est valide (sinon cela n a pas de sens)
  96       if obj.isvalid() :
  97            try :
  98              # constitution du bloc VERSION du fichier PHYS (existe toujours)
  99              self.generBLOC_VERSION(obj)
 100              # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
 101              self.generBLOC_MATERIALS()
 102              # constitution du bloc SOURCES du fichier PHYS (existe toujours)
 103              self.generBLOC_SOURCES()
 104
 105            except ValueError, err:
 106              raise ValueError(str(err))
 107
 108 #      print "texte carmel3d :\n",self.texteCarmel3D
 109 #      print "dictMaterDielectric : ",self.dictMaterDielectric
 110       if self.debug:
 111          print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
 112          print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
 113
 114       return self.text
 115
 116
 117
 118
 119 #----------------------------------------------------------------------------------------
 120 # initialisations
 121 #----------------------------------------------------------------------------------------
 122
 123    def initDico(self) :
 124       self.texteCarmel3D=""
 125       self.texteCarmel3D_PARAM=""
 126       self.texteCarmel3D_PARAM_SOLV=""
 127       self.texteCarmel3D_SH=""
 128       self.texteCarmel3D_INFC=""
 129       self.texteCarmel3D_CMD=""
 130       self.texteCarmel3D_INGEND1=""
 131       self.texteCarmel3D_INGEND2=""
 132       self.texteCarmel3D_INGEND3=""
 133       self.texteCarmel3D_INPOST=""
 134       self.debug = True # affichage de messages pour deboguage (.true.) ou non
 135       self.dicoEtapeCourant=None
 136       self.dicoMCFACTCourant=None
 137       self.dicoCourant=None
 138       self.dictGroupes = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[], 'ordreStrandJdC':[], 'ordreListeJdC':[], 'ordreDomaineJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
 139       self.dictMaterConductor={}
 140       self.dictMaterDielectric={}
 141       self.dictMaterZsurfacic={}
 142       self.dictMaterEmIso={}
 143       self.dictMaterEmAnIso={}
 144       self.dictMaterNilmat={}
 145       self.dictMaterZinsulator={}
 146       self.dictSourceStInd={}
 147       self.dictSourceEport={}
 148       self.dictSourceHport={}
 149       self.dictStrand={}
 150       self.dictDomaine={}
 151       self.dictPort={}
 152       self.repertory=""
 153       self.frequency=""
 154       self.domaine=""
 155       self.direction=""
 156       self.section=""
 157       self.forme=""
 158       self.centre=""
 159       self.echelle=""
 160       self.visu=False
 161       self.post_global=False
 162       self.visu_format=""
 163       self.visu_type=""
 164       self.gendof=""
 165       self.fcarmel=""
 166       self.postprocess=""
 167       self.formulation=""
 168       # on force le probleme a etre frequentiel, seul possible en l'etat des choses
 169       self.problem = HARMONIC
 170       self.fichierMaillage = "" # chemin absolu ou relatif  du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
 171       self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
 172       self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
 173       self.materiauxGroupesTousHomogenes = True # Tous les groupes sont associés a priori à des matériaux tous homogènes mais pas forcément isotropes. On le vérifie ou modifie ci-dessous.
 174       self.materiauxGroupesTousIsotropes = True # Tous les groupes sont associés a priori à des matériaux tous isotropes mais pas forcément homogènes. On le vérifie ou modifie ci-dessous.
 175
 176 #----------------------------------------------------------------------------------------
 177 # ecriture
 178 #----------------------------------------------------------------------------------------
 179
 180    def writeDefault(self,fn) :
 181         """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
 182
 183         # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
 184         #file =  fn[:fn.rfind(".")]  # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
 185         repertory=os.path.dirname(fn)  # répertoire de l'étude, e.g., /home/toto/
 186         file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
 187         namefile=os.path.basename(file) # nom du projet e.g., foo
 188
 189
 190         if self.debug:
 191             print "ecriture du fichier de parametres (PHYS)"
 192         filePHYS = file + '.phys'
 193         typeBloc = 'PHYS_FILES'
 194         f = open( str(filePHYS), 'w')
 195         f.write( self.texteCarmel3D)
 196         f.close()
 197
 198
 199         if self.debug:
 200             print "ecriture du fichier de parametres (PARAM)"
 201         filePARAM = file + '.param'
 202         f = open( str(filePARAM), 'w')
 203         f.write('[VERSION \n'
 204                     '   NUM     1\n'
 205                     '   FILETYPE PARAM\n]\n'
 206                     '[PROBLEM\n'
 207                     '   NAME HARMONIC\n]\n'
 208                 )
 209         typeBloc = 'CAR_FILES'
 210         self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
 211         self.texteCarmel3D_PARAM+="    NAME "+self.projet+".car"
 212         self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
 213         typeBloc = 'PHYS_FILES'
 214         self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
 215         self.texteCarmel3D_PARAM+="    NAME "+self.projet+".phys"
 216         self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
 217         self.texteCarmel3D_PARAM+="[FREQUENCY\n"
 218         self.texteCarmel3D_PARAM+="   SINGLE %g \n" % (self.frequency )
 219         self.texteCarmel3D_PARAM+="] \n"
 220         f.write( self.texteCarmel3D_PARAM)
 221         f.write(self.texteCarmel3D_PARAM_SOLV)
 222         f.close()
 223
 224         # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
 225         if self.debug:
 226             print "ecriture du fichier de parametres (CMD)"
 227         fileCMD =file + '.cmd'
 228         f = open( str(fileCMD), 'w')
 229         f.write(self.texteCarmel3D_CMD)
 230         f.close()
 231
 232
 233         if self.debug:
 234             print "ecriture du fichier de parametres (INGENDOF)"
 235         fileINGEND = file + '.ingendof'
 236         f = open(fileINGEND, 'w')
 237         self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
 238
 239         nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
 240         nomsGroupes.sort()
 241
 242         #if self.dictDomaine !={}:
 243         try:
 244             self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
 245         except ValueError, err:
 246             raise ValueError(str(err))
 247         if self.dictPort != {} :
 248             self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
 249         if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
 250         if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
 251         f.write(self.texteCarmel3D_INGEND1)
 252         f.write(self.texteCarmel3D_INGEND2)
 253         f.write(self.texteCarmel3D_INGEND3)
 254         f.close()
 255
 256         if self.debug:
 257             print "ecriture du fichier de parametres (INFCARMEL) "
 258         fileINFC = file + '.infcarmel'
 259         f = open(fileINFC, 'w')
 260         self.texteCarmel3D_INFC+= self.projet+".param"
 261         f.write(self.texteCarmel3D_INFC)
 262         f.close()
 263
 264         if self.debug:
 265             print "ecriture du fichier de parametres (INPOSTPROCESS) "
 266         fileINPOST = file + '.inpostprocess'
 267         f = open(fileINPOST, 'w')
 268         self.texteCarmel3D_INPOST+= self.projet+".param"
 269         self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
 270         self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
 271         f.write(self.texteCarmel3D_INPOST)
 272         f.close()
 273
 274         print "dictionnaire complet=%s" %self.dictGroupes
 275         print "dictionnaire des ports =%s"  %self.dictPort
 276         if self.debug:
 277             print "ecriture du fichier d'execution (SH)"
 278             print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
 279         RepCarmel= os.path.join(repertory,"lancer.sh")
 280         f = open( str(RepCarmel), 'wb')
 281         self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
 282         if self.gendof=="TRUE":
 283             self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
 284             if self.echelle=="Millimetre":
 285                 self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
 286             else:
 287                 self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
 288         if self.fcarmel=="TRUE":
 289             self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
 290             self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe <  " + self.projet + ".infcarmel\n"
 291         if self.postprocess=="TRUE":
 292             self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
 293             self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
 294         f.write(self.texteCarmel3D_SH)
 295         f.close()
 296
 297 #----------------------------------------------------------------------------------------
 298 #  analyse de chaque noeud de l'arbre
 299 #----------------------------------------------------------------------------------------
 300
 301    def generMCSIMP(self,obj) :
 302         """recuperation de l objet MCSIMP"""
 303         if self.debug:
 304             print "MCSIMP %(v_1)s  %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
 305         s=PythonGenerator.generMCSIMP(self,obj)
 306         self.dicoCourant[obj.nom]=obj.valeurFormatee
 307         return s
 308
 309
 310 #----------------------------------------------------------------------------------------
 311    def generMCFACT(self,obj) :
 312         """recuperation de l objet MCFACT"""
 313         dico={}
 314         self.dicoMCFACTCourant=dico
 315         self.dicoCourant=self.dicoMCFACTCourant
 316         s=PythonGenerator.generMCFACT(self,obj)
 317         self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
 318         self.dicoMCFACTCourant=None
 319         self.dicoCourant=self.dicoEtapeCourant
 320         return s
 321
 322
 323 #----------------------------------------------------------------------------------------
 324    def generPROC_ETAPE(self,obj):
 325         """analyse des PROC du catalogue  ( VERSION )"""
 326         dico={}
 327         self.dicoEtapeCourant=dico
 328         self.dicoCourant=self.dicoEtapeCourant
 329         s=PythonGenerator.generPROC_ETAPE(self,obj)
 330         obj.valeur=self.dicoEtapeCourant
 331
 332         if self.debug:
 333             print "PROC_ETAPE %(v_1)s  %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
 334         s=PythonGenerator.generPROC_ETAPE(self,obj)
 335         if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
 336         if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
 337         if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
 338         return s
 339
 340
 341
 342 #----------------------------------------------------------------------------------------
 343    def generETAPE(self,obj):
 344         """analyse des OPER du catalogue"""
 345         dico={}
 346         self.dicoEtapeCourant=dico
 347         self.dicoCourant=self.dicoEtapeCourant
 348         s=PythonGenerator.generETAPE(self,obj)
 349         obj.valeur=self.dicoEtapeCourant
 350         if self.debug:
 351             print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
 352         if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
 353         if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
 354         if obj.nom=="SOURCE" : self.generSOURCE(obj)
 355         if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
 356         if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
 357         s=PythonGenerator.generETAPE(self,obj)
 358         return s
 359
 360 #----------------------------------------------------------------------------------------
 361    def generMACRO_ETAPE(self,obj):
 362         dico={}
 363         self.dicoEtapeCourant=dico
 364         self.dicoCourant=self.dicoEtapeCourant
 365         import generator
 366         monGenerateur=generator.plugins[nomPlugin]()
 367         jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
 368         if self.debug:
 369             print "jdc_aux_texte : %s" % jdc_aux_texte
 370
 371         for cle in monGenerateur.dictMaterConductor:
 372             self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
 373         for cle in monGenerateur.dictMaterDielectric:
 374             self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
 375         for cle in monGenerateur.dictMaterZsurfacic:
 376             self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
 377         for cle in monGenerateur.dictMaterEmIso:
 378             self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
 379         for cle in monGenerateur.dictMaterEmAnIso:
 380             self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
 381         for cle in monGenerateur.dictMaterNilmat:
 382             self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
 383         for cle in monGenerateur.dictMaterZinsulator:
 384             self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
 385
 386         print "________FIN MACRO______________________________________"
 387         s=PythonGenerator.generMACRO_ETAPE(self,obj)
 388         return s
 389
 390 #----------------------------------------------------------------------------------------
 391 #----------------------------------------------------------------------------------------
 392    def generMESHGROUP(self,obj):
 393         """preparation de la ligne NAME referencant le groupe de mailles
 394             associe le groupe de mailles au materiau ou a la source utilisateur
 395             on sauvegarde aussi les noms des groupes de maillage
 396         """
 397         try:
 398             if usePrefix:
 399                 nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
 400                 print "liste des noms sans prefixes %s" %(nomGroupe)
 401             else:
 402                 nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
 403                 print "liste des noms sans prefixes %s" %(nomGroupe)
 404
 405             # 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.
 406             # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
 407             #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
 408             #
 409             # on utilise le fait que obj.valeur est un dictionnaire
 410             self.dictGroupes[nomGroupe] = {}
 411 #            nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
 412             if self.debug:
 413                 print "obj.valeur.keys()= %s" % obj.valeur.keys()
 414             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
 415                 raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau  et au moins une source." % nomGroupe)
 416             # association a un materiau
 417             if 'MATERIAL' in obj.valeur.keys():
 418                 self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
 419                 self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
 420             # association a une source
 421             if 'SOURCE' in obj.valeur.keys():
 422                 self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
 423                 self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
 424             # erreur ni materiau ni source associee
 425             if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
 426                     self.dictGroupes[nomGroupe]['STRAND'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
 427                     self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
 428             if 'Domaine' in obj.valeur.keys():
 429                 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
 430                 self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
 431                 texte=""
 432                 texte+="%s"%(obj.valeur['Domaine'])
 433                 print"le texte=%s" %(texte)
 434                 self.dictDomaine[obj.get_sdname()]=texte
 435                 print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
 436
 437 #            else:
 438 #                raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
 439             if self.debug:
 440                 print "self.dictGroupes= %s" % repr(self.dictGroupes)
 441         except ValueError, err:
 442             raise ValueError, str(err)
 443
 444    def generMACRO_GROUPE(self, obj):
 445         """preparation de la ligne NAME referencant le groupe de mailles
 446             associe le groupe de mailles au materiau ou a la source utilisateur
 447             on sauvegarde aussi les noms des macros groupes
 448         """
 449         try:
 450             #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
 451             if usePrefix:
 452                 nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
 453                 print "liste des noms sans prefixes %s" %(nomGroupe)
 454             else:
 455                 nomGroupe = obj.get_sdname() # nom du macro groupe
 456                 print "liste des noms sans prefixes %s" %(nomGroupe)
 457             self.dictGroupes[nomGroupe] = {}
 458
 459             # 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.
 460             # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
 461             #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
 462             #
 463             # on utilise le fait que obj.valeur est un dictionnaire
 464             if self.debug:
 465                 print "obj.valeur.keys()= %s" % obj.valeur.keys()
 466             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
 467                 raise ValueError,tr("Ce MACRO_GROUPE %s ne peut pas contenir a la fois un MATERIAL et une SOURCE." % nomGroupe)
 468             # association a une source
 469             if 'SOURCE' in obj.valeur.keys():
 470                 self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
 471                 self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
 472             # erreur ni materiau ni source associee
 473             if 'LISTE_MESHGROUP' in obj.valeur.keys():
 474                 listeStrandedInductorGeometry = True # indicateur du fait que tous les groupes de la liste sont des inducteurs bobinés ou topologiques, en morceaux ou entier (True), ou non (False). Utilisé pour savoir si le Domaine est nécessaire ou non.
 475                 listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
 476                 self.dictGroupes[nomGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
 477                 for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
 478                     groupe = groupe.replace("'", "") # suppression des guillement simpes
 479                     groupe = groupe.replace('"', "") # suppression des guillement doubles
 480                     self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
 481                     if not self.dictGroupes[groupe].has_key('STRAND'): listeStrandedInductorGeometry = False # au moins un groupe de la liste n'est pas un inducteur bobiné ou topologique (morceau ou entier).
 482                 self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
 483                 if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
 484                     raise ValueError, tr(u"Le MACRO_GROUPE %s ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques." % nomGroupe)
 485                 # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
 486                 if 'Domaine' in obj.valeur.keys():
 487                     if listeStrandedInductorGeometry: # Domaine seulement  en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
 488                         self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
 489                         self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
 490                         texte=""
 491                         texte+="%s"%(obj.valeur['Domaine'])
 492                         print"le texte=%s" %(texte)
 493                         self.dictDomaine[obj.get_sdname()]=texte
 494                     else: # Erreur si Domaine et macro-groupe pas complètement inducteur
 495                         raise ValueError, tr(u"Ce MACRO_GROUPE %s contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques. Il ne doit pas contenir de Domaine." % nomGroupe)
 496                 else: # Domaine manquant
 497                     if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
 498                         raise ValueError, tr(u"Ce MACRO_GROUPE %s de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine." % nomGroupe)
 499             if self.debug:
 500                 print "self.dictGroupes= %s" % repr(self.dictGroupes)
 501                 print "self.dictDomaine=%s" %(self.dictDomaine)
 502         except ValueError, err:
 503             raise ValueError, str(err)
 504
 505
 506    def generSOLVEUR(self, obj):
 507         if self.debug:
 508             print "generation material obj.valeur = %s" % obj.valeur
 509         try :
 510             nature = obj.valeur['Type']
 511             if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
 512         except ValueError,  err:
 513             raise ValueError,  str(err)
 514
 515    def generSOLVEUR_LINEAIRE(self, obj):
 516         if self.debug:
 517             print "generation material obj.valeur = %s" % obj.valeur
 518         try :
 519             nature = obj.valeur['Methode_lineaire']
 520             if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
 521             if nature  =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
 522         except ValueError,  err:
 523             raise ValueError,  str(err)
 524
 525    def generMETHODE_ITERATIVE_BICGCR(self, obj):
 526         texte=""
 527         if self.debug:
 528             print "_____________iter_____________"
 529
 530             self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
 531             self.texteCarmel3D_PARAM_SOLV+="    NAME BICGCR\n"
 532             self.texteCarmel3D_PARAM_SOLV+="    [ITERATIVE_PARAM \n"
 533             self.texteCarmel3D_PARAM_SOLV+="        NITERMAX   "+str(obj.valeur["Nombre_iterations_max"])+"\n"
 534             self.texteCarmel3D_PARAM_SOLV+="        EPSILON  "+str(obj.valeur["Precision"])+"\n"
 535             self.texteCarmel3D_PARAM_SOLV+="    ]\n] \n"
 536         if self.debug:
 537            print "texte = %s", texte
 538
 539
 540    def generMETHODE_DIRECTE_MUMPS(self, obj):
 541         texte=""
 542         if self.debug:
 543             print "_____________directe_____________"
 544
 545             self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
 546             self.texteCarmel3D_PARAM_SOLV+="    NAME MUMPS\n"
 547             self.texteCarmel3D_PARAM_SOLV+="    [MUMPS_PARAMETER \n"
 548             self.texteCarmel3D_PARAM_SOLV+="         SYM   "+str(obj.valeur["Type_de_matrice"])+"\n"
 549             self.texteCarmel3D_PARAM_SOLV+="       ICNTL   "+str(obj.valeur["ICNTL_Control_Parameters"])+"     "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
 550             self.texteCarmel3D_PARAM_SOLV+="    ]\n] \n"
 551         if self.debug:
 552            print "texte = %s", texte
 553
 554
 555
 556    def generMATERIAL(self,obj):
 557         """preparation du bloc correspondant a un materiau du fichier PHYS"""
 558         texte=""
 559         if self.debug:
 560             print "generation material obj.valeur = %s" % obj.valeur
 561         try :
 562             nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
 563             if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
 564             if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
 565             if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
 566             if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
 567             if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
 568             if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
 569             if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
 570         except ValueError, err:
 571             raise ValueError, str(err)
 572
 573    def generMATERIAL_CONDUCTOR(self,obj):
 574        """preparation du sous bloc CONDUCTOR"""
 575        texte=""
 576        if self.debug:
 577            print "_____________cond_____________"
 578        # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
 579        if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
 580             print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
 581             raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
 582        else:
 583           # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
 584           for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
 585              # debut du sous bloc de propriete du DIELECTRIC
 586              texte+="         ["+keyN1+"\n"
 587              texte+="            HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
 588              texte+="            ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
 589              # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
 590              # car sinon ces valeurs sont definies dans des fichiers annexes
 591              homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
 592              isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
 593              if homogeneous and isotropic:
 594                 # loi (lineaire ou non)
 595                 texte+="            LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
 596                 # valeur de la loi lineaire
 597                 texte+="            VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
 598                 # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
 599                 #  seuls les reels sont pris en compte
 600                 if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
 601                    texte+="            [NONLINEAR \n"
 602                    texte+="                ISOTROPY TRUE\n"
 603                    texte+="                NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
 604                    # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
 605                    for keyN2 in obj.valeur[keyN1] :
 606                       if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
 607                           texte+="                "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
 608                    # fin du sous-bloc NONLINEAR
 609                    texte+="            ]"+"\n"
 610              # fin du sous bloc de propriete
 611              texte+="         ]"+"\n"
 612        if self.debug:
 613            print "texte = %s", texte
 614        self.dictMaterConductor[obj.get_sdname()]={'texte':  texte,  'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
 615
 616    def generMATERIAL_DIELECTRIC(self,obj):
 617         """preparation du sous bloc DIELECTRIC"""
 618         texte=""
 619         if self.debug:
 620            print "______________nocond_____________"
 621            # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
 622         if 'PERMITTIVITY' not in obj.valeur:
 623             print "obj.valeur=%s" %obj.valeur
 624             obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
 625
 626         # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
 627         for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
 628          # debut du sous bloc de propriete du DIELECTRIC
 629          texte+="         ["+keyN1+"\n"
 630          texte+="            HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
 631          texte+="            ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
 632          # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
 633          # car sinon ces valeurs sont definies dans des fichiers annexes
 634          homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
 635          isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
 636          if homogeneous and isotropic:
 637             # loi (lineaire ou non)
 638             texte+="            LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
 639             # valeur de la loi lineaire
 640             texte+="            VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
 641             # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
 642             #  seuls les reels sont pris en compte
 643             if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
 644                texte+="            [NONLINEAR \n"
 645                texte+="                ISOTROPY TRUE\n"
 646                texte+="                NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
 647                # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
 648                for keyN2 in obj.valeur[keyN1] :
 649                   if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
 650                       texte+="                "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
 651                # fin du sous-bloc NONLINEAR
 652                texte+="            ]"+"\n"
 653          # fin du sous bloc de propriete
 654          texte+="         ]"+"\n"
 655         if self.debug:
 656            print "texte = %s" % texte
 657         self.dictMaterDielectric[obj.get_sdname()]={'texte':  texte,  'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
 658
 659    def generMATERIAL_ZSURFACIC(self,obj):
 660        """preparation du sous bloc ZSURFACIC"""
 661        texte=""
 662        if self.debug:
 663            print "______________zsurf_____________"
 664        # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
 665        if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
 666             print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
 667             raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
 668        else:
 669           # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
 670           for keyN1 in obj.valeur :
 671              if keyN1=='TYPE': continue
 672              # print "type loi = ", obj.valeur[keyN1]['LAW']
 673              # debut du sous bloc de propriete du DIELECTRIC
 674              texte+="         ["+keyN1+"\n"
 675              texte+="            HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
 676              texte+="            ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
 677              # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
 678              # car sinon ces valeurs sont definies dans des fichiers annexes
 679              homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
 680              isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
 681              if homogeneous and isotropic:
 682                 # loi (lineaire ou non)
 683                 texte+="            LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
 684                 # valeur de la loi lineaire
 685                 texte+="            VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
 686              # fin du sous bloc de propriete
 687              texte+="         ]"+"\n"
 688        if self.debug:
 689            print "texte = %s", texte
 690        self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
 691
 692    def generMATERIAL_EMISO(self,obj):
 693        """preparation du sous bloc EM_ISOTROPIC_FILES.
 694        Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
 695         ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
 696        """
 697        if "CONDUCTIVITY_File" in obj.valeur:
 698             texte ="        CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
 699        if "PERMEABILITY_File" in obj.valeur:
 700             texte+="        PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
 701        # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
 702        #from os.path import basename
 703        #texte ="        CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
 704        #texte+="        PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
 705        #      print "obj get sdname= ", obj.get_sdname()
 706        #   if obj.get_sdname() in self.dictMaterEmIso.keys() :
 707        #    self.dictMaterEmIso[obj.get_sdname()].append(texte)
 708        # else :
 709        self.dictMaterEmIso[obj.get_sdname()]=texte
 710
 711    def generMATERIAL_EMANISO(self,obj):
 712         """preparation du sous bloc EM_ANISOTROPIC_FILES.
 713         Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
 714             ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
 715         """
 716         if "CONDUCTIVITY_File" in obj.valeur:
 717             texte ="        CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
 718         if "PERMEABILITY_File" in obj.valeur:
 719             texte+="        PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
 720        #  print "obj get sdname= ", obj.get_sdname()
 721        #  if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
 722        #    self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
 723        #  else :
 724         self.dictMaterEmAnIso[obj.get_sdname()]=texte
 725
 726    def generMATERIAL_NILMAT(self,obj):
 727        """preparation du sous bloc NILMAT"""
 728        texte=""
 729        self.dictMaterNilmat[obj.get_sdname()]=texte
 730
 731    def generMATERIAL_ZINSULATOR(self,obj):
 732        """"preparation du sous bloc ZINSULATOR"""
 733        texte=""
 734        self.dictMaterZinsulator[obj.get_sdname()]=texte
 735
 736 #-------------------------------------------------------------------
 737
 738    def generSOURCE(self,obj):
 739         """preparation du bloc correspondant a une source du fichier PHYS"""
 740         if self.debug:
 741             print "generation source obj valeur = %s" % obj.valeur
 742         texte=""
 743         try :
 744             # test de la presence des types de sources reconnus
 745             # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
 746             # la source ne peut contenir au plus qu'un type de source.
 747             if "STRANDED_INDUCTOR" in obj.valeur:
 748                self.generSOURCE_STRANDED_INDUCTOR(obj)
 749             elif "HPORT" in obj.valeur:
 750                self.generSOURCE_HPORT(obj)
 751             elif "EPORT" in obj.valeur:
 752                self.generSOURCE_EPORT(obj)
 753             else:
 754                print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
 755         except ValueError, err:
 756             raise ValueError, str(err)
 757
 758    def generSOURCE_STRANDED_INDUCTOR(self,obj):
 759         """preparation du sous bloc STRANDED_INDUCTOR"""
 760         texte=""
 761         sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
 762         try :
 763             texte+="        NTURNS %s\n" % str(sdict['NTURNS'])
 764             self.nturns=sdict['NTURNS']
 765             # test de la presence d'une forme de source reconnue
 766             # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
 767             # la source ne peut contenir au plus qu'un type de source.
 768             if "WAVEFORM_CONSTANT" in obj.valeur:
 769                wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
 770                if self.problem == HARMONIC:
 771                   texte+="        CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
 772                   print tr("ATTENTION! Une source constante \
 773                                   n'est possible qu'a frequence nulle \
 774                                   en regime frequentiel")
 775             elif "WAVEFORM_SINUS" in obj.valeur:
 776                wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
 777                if self.problem == HARMONIC:
 778                   texte+="        CURJ POLAR %(ampli)s %(phase)s\n" \
 779                          % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
 780             else:
 781                print tr("ERREUR! Une forme de la source du \
 782                                type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
 783             self.dictSourceStInd[obj.get_sdname()]=texte
 784             if self.debug:
 785                 print texte
 786         except ValueError, err:
 787             raise ValueError, str(err)
 788
 789    def generSOURCE_HPORT(self,obj):
 790         """preparation du sous bloc HPORT"""
 791         texte=""
 792         sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
 793         nomPort = obj.get_sdname()
 794         self.dictPort[nomPort] = {}
 795         self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
 796         try :
 797             texte+="        TYPE %s\n" % str(sdict['TYPE'])
 798             # test de la presence d'une forme de source reconnue
 799             # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
 800             # la source ne peut contenir au plus qu'un type de source.
 801             if "WAVEFORM_CONSTANT" in obj.valeur:
 802                wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
 803                if self.problem == HARMONIC:
 804                   texte+="        AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
 805                   print tr("ATTENTION! Une source constante n'est \
 806                                   possible qu'a frequence nulle en regime frequentiel")
 807             elif "WAVEFORM_SINUS" in obj.valeur:
 808                wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
 809                if self.problem == HARMONIC:
 810                   texte+="        AMP POLAR %(ampli)s %(phase)s\n" \
 811                          % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
 812             else:
 813                print tr("ERREUR! Une forme de la source du type \
 814                                WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
 815             self.dictSourceHport[obj.get_sdname()]=texte
 816             if self.debug:
 817                 print texte
 818         except ValueError, err:
 819             raise ValueError, str(err)
 820
 821    def generSOURCE_EPORT(self,obj):
 822
 823
 824         """preparation du sous bloc EPORT"""
 825         texte=""
 826         sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
 827         nomPort = obj.get_sdname()
 828         self.dictPort[nomPort] = {}
 829         self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
 830         print "sdict=%s" %(sdict)
 831         try :
 832             texte+="        TYPE %s\n" % str(sdict['TYPE'])
 833             # test de la presence d'une forme de source reconnue
 834             # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
 835             # la source ne peut contenir au plus qu'un type de source.
 836             if "WAVEFORM_CONSTANT" in obj.valeur:
 837                wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
 838                if self.problem == HARMONIC:
 839                   texte+="        AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
 840                   print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
 841             elif "WAVEFORM_SINUS" in obj.valeur:
 842                wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
 843                if self.problem == HARMONIC:
 844                   texte+="        AMP POLAR %(ampli)s %(phase)s\n" \
 845                          % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
 846             else:
 847                print tr("ERREUR! Une forme de la source du type \
 848                                WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
 849             self.dictSourceEport[obj.get_sdname()]=texte
 850             if self.debug:
 851                 print texte
 852         except ValueError, err:
 853             raise ValueError, str(err)
 854
 855 #
 856    def generPARAM_CIRCULAIRE(self, obj):
 857         if self.debug:
 858             print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
 859         self.centre=obj.valeur["Centre"]
 860
 861    def generPOST_COMMANDS(self, obj):
 862         """Création du texte de commandes de post-traitement toto.cmd"""
 863         if self.debug:
 864             print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
 865
 866         if obj.valeur.has_key('GLOBAL'):
 867             self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
 868         if obj.valeur.has_key('VISU'):
 869             self.texteCarmel3D_CMD+="[\nVISU"
 870             # test de fichier de maillage bien lu
 871             if self.fichierMaillage == "":  raise ValueError, tr("ERREUR! Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au dessus du bloc POST_COMMANDS.")
 872             self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
 873             self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Format"]+"\n"
 874             self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Type"]+"\n]\n"
 875         if obj.valeur.has_key('CUTLINE'):
 876             champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
 877             self.texteCarmel3D_CMD+="[\nCUTLINE"
 878             self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["first_point"]))
 879             self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["last_point"]))
 880             self.texteCarmel3D_CMD+="\n%d" % (obj.valeur["CUTLINE"]["number_of_points"], )
 881             self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTLINE"]["name"]
 882             # création du champ, renommé par rapport à l'interface
 883             self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTLINE"]["field"]]
 884             self.texteCarmel3D_CMD+="\n]\n"
 885         if obj.valeur.has_key('CUTPLANE'):
 886             champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
 887             axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
 888             self.texteCarmel3D_CMD+="[\nCUTPLANE"
 889             self.texteCarmel3D_CMD+="\n%d" % (axes[obj.valeur["CUTPLANE"]["normal_vector"]], )
 890             self.texteCarmel3D_CMD+="\n%f" % (obj.valeur["CUTPLANE"]["plane_position"], )
 891             self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTPLANE"]["number_of_points"]))
 892             self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTPLANE"]["name"]
 893             self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTPLANE"]["field"]]
 894             self.texteCarmel3D_CMD+="\n]\n"
 895
 896
 897 #---------------------------------------------------------------------------------------
 898 # traitement fichier PHYS
 899 #---------------------------------------------------------------------------------------
 900    def generBLOC_VERSION(self,obj) :
 901       # constitution du bloc VERSION du fichier PHYS
 902       # creation d une entite  VERSION ; elle sera du type PROC car decrit ainsi
 903       # dans le du catalogue
 904       version=obj.addentite('VERSION',pos=None)
 905       self.generPROC_ETAPE(obj.etapes[0])
 906       self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
 907       for cle in obj.etapes[0].valeur :
 908           self.texteCarmel3D+="   "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
 909       self.texteCarmel3D+="]\n"
 910       # destruction de l entite creee
 911       obj.suppentite(version)
 912       #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
 913       #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
 914
 915
 916    def generBLOC_PARAMETERS(self,obj):
 917         if self.debug:
 918             print "generation parameters obj.valeur = %s" % obj.valeur
 919
 920         self.frequency=obj.valeur["FREQUENCY"]
 921         self.repertory=obj.valeur["RepCarmel"]
 922         self.fichierMaillage=obj.valeur["Fichier_maillage"]
 923         self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
 924         self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
 925         self.echelle=obj.valeur["Echelle_du_maillage"]
 926         self.gendof=obj.valeur["Realiser_topologie_gendof"]
 927         self.fcarmel=obj.valeur["Resoudre_probleme"]
 928         self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
 929         self.formulation=obj.valeur["Formulation"]
 930 #----------------------------------------------------------------------------------------
 931    def generBLOC_MATERIALS(self) :
 932         """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
 933         Le bloc MATERIALS existe toujours !
 934         """
 935         if self.debug:
 936             print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
 937             print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
 938         # constitution du bloc MATERIALS du fichier PHYS
 939         self.texteCarmel3D+="[MATERIALS\n"
 940         # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
 941         nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
 942         nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
 943         if self.debug:
 944             print "noms groupes de mailles associes a des materiaux \
 945                             (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
 946                             {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
 947                              'v_2': nomsGroupes}
 948         try:  # mise à jour du fichier .phys selon les matériaux trouvés
 949             # constitution du bloc CONDUCTOR du fichier PHYS si existe
 950             if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
 951             # constitution du bloc DIELECTRIC du fichier PHYS si exixte
 952             if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
 953             # constitution du bloc ZSURFACIC du fichier PHYS si exixte
 954             if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
 955             # constitution du bloc NILMAT du fichier PHYS si exixte
 956             if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
 957             # constitution du bloc ZINSULATOR du fichier PHYS si exixte
 958             if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
 959             # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
 960             # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
 961             if self.dictMaterEmIso != {} and self.materiauxGroupesTousIsotropes and not self.materiauxGroupesTousHomogenes : self.creaBLOC_EMISO() # bloc isotrope si au moins un matériau isotrope et non homogene
 962             # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
 963             if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
 964         except ValueError, err:
 965             raise ValueError(str(err))
 966
 967
 968         # fin du bloc MATERIALS du fichier PHYS
 969         self.texteCarmel3D+="]\n"
 970
 971
 972
 973    def creaBLOC_CONDUCTOR(self, nomsGroupes) :
 974         """Constitution du bloc CONDUCTOR du fichier PHYS"""
 975         typeBloc = 'CONDUCTOR' # initialisation du type de bloc
 976         dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
 977         if self.debug:
 978             print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
 979         for nom in nomsGroupes: # parcours des noms des groupes de maillage
 980             if self.dictGroupes[nom]['MATERIAL'][:]  in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
 981                 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
 982                     print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:],  nom)
 983                     raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:],  nom))
 984                 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
 985                  or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
 986                     self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
 987                 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
 988                  or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
 989                     self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
 990                 # ecriture du bloc complet
 991                 self.texteCarmel3D+="     ["+typeBloc+"\n" # debut de bloc
 992                 if usePrefix:
 993                     nomReel = self.nomReelGroupe(nom, typeBloc)
 994                 else:
 995                     nomReel = nom
 996                 self.texteCarmel3D+="        NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
 997                 self.texteCarmel3D+=  dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
 998                 self.texteCarmel3D+="     ]\n" # fin de bloc
 999
1000    def creaBLOC_DIELECTRIC(self, nomsGroupes) :
1001         """Constitution du bloc DIELECTRIC du fichier PHYS"""
1002         typeBloc = 'DIELECTRIC' # initialisation du type de bloc
1003         dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
1004         if self.debug:
1005             print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1006         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1007             print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
1008             if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1009                 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
1010                     print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:],  nom)
1011                     raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:],  nom))
1012                 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
1013                     self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
1014                 if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
1015                     self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
1016                  # ecriture du bloc complet
1017                 self.texteCarmel3D+="     ["+typeBloc+"\n" # debut de bloc
1018                 self.texteCarmel3D+="        NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
1019                 self.texteCarmel3D+=  dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
1020                 self.texteCarmel3D+="     ]\n" # fin de bloc
1021
1022    def creaBLOC_ZSURFACIC(self, nomsGroupes) :
1023         """Constitution du bloc ZSURFACIC du fichier PHYS"""
1024         typeBloc = 'ZSURFACIC' # initialisation du type de bloc
1025         dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
1026         if self.debug:
1027             print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1028         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1029             if self.dictGroupes[nom]['MATERIAL'][:]  in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1030                 # ecriture du bloc complet
1031                 self.texteCarmel3D+="     ["+typeBloc+"\n" # debut de bloc
1032                 if usePrefix:
1033                     nomReel = self.nomReelGroupe(nom, typeBloc)
1034                 else:
1035                     nomReel = nom
1036                 self.texteCarmel3D+="        NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1037                 self.texteCarmel3D+=  dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
1038                 self.texteCarmel3D+="     ]\n" # fin de bloc
1039
1040    def creaBLOC_EMISO(self) :
1041         """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
1042         for cle in self.dictMaterEmIso.keys():
1043             self.texteCarmel3D+="     [EM_ISOTROPIC_FILES\n"
1044             self.texteCarmel3D+= self.dictMaterEmIso[cle]
1045             self.texteCarmel3D+="     ]\n"
1046
1047    def creaBLOC_EMANISO(self) :
1048         """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
1049         for cle in self.dictMaterEmAnIso.keys():
1050             self.texteCarmel3D+="     [EM_ANISOTROPIC_FILES\n"
1051             self.texteCarmel3D+=  self.dictMaterEmAnIso[cle]
1052             self.texteCarmel3D+="     ]\n"
1053
1054    def creaBLOC_ZINSULATOR(self, nomsGroupes) :
1055         """Constitution du bloc ZINSULATOR du fichier PHYS"""
1056         typeBloc = 'ZINSULATOR' # initialisation du type de bloc
1057         dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
1058         if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
1059         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1060             if self.dictGroupes[nom]['MATERIAL'][:]  in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1061                 # ecriture du bloc complet
1062                 self.texteCarmel3D+="     ["+typeBloc+"\n" # debut de bloc
1063                 if usePrefix:
1064                     nomReel = self.nomReelGroupe(nom, typeBloc)
1065                 else:
1066                     nomReel = nom
1067                 self.texteCarmel3D+="        NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1068                 self.texteCarmel3D+=  dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
1069                 self.texteCarmel3D+="     ]\n" # fin de bloc
1070
1071    def creaBLOC_NILMAT(self, nomsGroupes) :
1072         """Constitution du bloc NILMAT du fichier PHYS"""
1073         typeBloc = 'NILMAT' # initialisation du type de bloc
1074         dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
1075         if self.debug:
1076             print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
1077         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1078             if self.dictGroupes[nom]['MATERIAL'][:]  in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
1079                 # ecriture du bloc complet
1080                 self.texteCarmel3D+="     ["+typeBloc+"\n" # debut de bloc
1081                 if usePrefix:
1082                     nomReel = self.nomReelGroupe(nom, typeBloc)
1083                 else:
1084                     nomReel = nom
1085                 self.texteCarmel3D+="        NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1086                 self.texteCarmel3D+=  dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
1087                 self.texteCarmel3D+="     ]\n" # fin de bloc
1088
1089 #----------------------------------------------------------------------------------------
1090    def generBLOC_SOURCES(self):
1091         """constitution du bloc SOURCES du fichier PHYS"""
1092         self.texteCarmel3D+="[SOURCES\n"
1093 #        # tri alphabetique de tous les groupes de maillage associes a des sources
1094         nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
1095         nomsGroupes.sort()
1096      #   print "RESULTAT APRES FUSION  self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
1097
1098         if self.debug:
1099             print 'noms groupes de mailles associes a des sources \
1100                             (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
1101                             {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
1102                              'g_maillage_trie': nomsGroupes}
1103         if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
1104         if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
1105         if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
1106         # fin du bloc SOURCES du fichier PHYS
1107         self.texteCarmel3D+="]\n"
1108
1109
1110    def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
1111         """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
1112         if self.debug:
1113             print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
1114         typeBloc = 'STRANDED_INDUCTOR'
1115 #        print "liste des NOM=%s" %(nom)
1116         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1117             if self.dictGroupes[nom]['SOURCE'][:]  in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
1118                 # ecriture du bloc de l'inducteur bobine
1119                 self.texteCarmel3D+="     [STRANDED_INDUCTOR\n" # debut de bloc
1120                 self.texteCarmel3D+="        NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
1121                 self.texteCarmel3D+=  self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
1122                 self.texteCarmel3D+="     ]\n" # fin de bloc
1123
1124    def creaBLOC_EPORT(self, nomsGroupes) :
1125         """constitution du bloc EPORT du fichier PHYS"""
1126         if self.debug:
1127             print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
1128         typeBloc = 'EPORT'
1129         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1130             if self.dictGroupes[nom]['SOURCE'][:]  in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
1131                 # ecriture du bloc du port electrique
1132                 self.texteCarmel3D+="     [EPORT\n" # debut de bloc
1133                 if usePrefix:
1134                     nomReel = self.nomReelGroupe(nom, typeBloc)
1135                 else:
1136                     nomReel = nom
1137                 self.texteCarmel3D+="        NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1138                 self.texteCarmel3D+=  self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
1139                 self.texteCarmel3D+="     ]\n" # fin de bloc
1140
1141    def creaBLOC_HPORT(self, nomsGroupes) :
1142         """constitution du bloc HPORT du fichier PHYS"""
1143         if self.debug:
1144             print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
1145         typeBloc = 'HPORT'
1146         for nom in nomsGroupes: # parcours des noms des groupes de maillage
1147             if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
1148                 # ecriture du bloc du port magnetique
1149                 self.texteCarmel3D+="     [HPORT\n" # debut de bloc
1150                 if usePrefix:
1151                     nomReel = self.nomReelGroupe(nom, typeBloc)
1152                 else:
1153                     nomReel = nom
1154                 self.texteCarmel3D+="        NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
1155                 self.texteCarmel3D+=  self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
1156                 self.texteCarmel3D+="     ]\n" # fin de bloc
1157
1158    def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
1159         """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
1160
1161         texte=""
1162         self.direction=obj.valeur["Direction"]
1163         self.section=obj.valeur["Section"]
1164         self.forme=obj.valeur["Forme"]
1165 #        texte+="\n%s" %(self.domaine)
1166
1167         if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
1168         else:
1169             texte+="\n1"
1170             texte+="\n%s" % ' '.join(map(str, self.direction))
1171             texte+="\n%g" % (self.section)
1172             self.dictStrand[obj.get_sdname()]=texte
1173         if self.debug:
1174             print texte
1175
1176    def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
1177             texte=""
1178             self.centre=obj.valeur["Centre"]
1179             texte+="\n2"
1180             texte+="\n%s" % ' '.join(map(str,self.direction))
1181             texte+="\n%s" % ' '.join(map(str, self.centre))
1182             texte+="\n%g" % (self.section)
1183             self.dictStrand[obj.get_sdname()]=texte
1184             if self.debug:
1185                 print texte
1186
1187
1188    def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
1189         """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
1190         Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
1191         """
1192         if self.debug:
1193             print 'dictGroupes=', self.dictGroupes
1194             print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
1195             print "nomsGroupes=%s" %(nomsGroupes)
1196         nomsSources=self.dictGroupes['ordreDomaineJdC']
1197         nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
1198         if self.debug: print"nomsSources=%s" %nomsSources
1199         for nom in nomsSources:
1200             if self.debug: print "nomSource courant=",nom
1201             if self.dictGroupes[nom].has_key('SOURCE'):
1202                 if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
1203                     if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError,  tr("Il manque le Domaine à l'inducteur de nom : "+nom)
1204                     self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1205             else:
1206                     if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError,  tr("Il manque le Domaine à l'inducteur de nom : "+nom)
1207                     self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1208             if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
1209                 if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError,  tr("Il manque le Domaine à l'inducteur de nom : "+nom)
1210                 strand = self.dictGroupes[nom]['STRAND']
1211                 if self.debug: print "un seul morceau : nomStrand courant=", strand
1212                 self.texteCarmel3D_INGEND2+=  self.dictStrand[strand]
1213             if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
1214                 listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
1215                 for strand in listeStrand:
1216                     #strand = strand.replace("'", "") # suppression des guillemets simples
1217                     if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
1218                     if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
1219                     self.texteCarmel3D_INGEND2+=  self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
1220
1221    def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
1222         if self.debug:
1223            print "self.dictSourceEport=",  self.dictSourceEport
1224            print "self.dictSourceHport=",  self.dictSourceHport
1225         nomsSources=self.dictGroupes['ordreDomaineJdC']
1226         nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
1227
1228         for nom in nomsSources:
1229             port=self.dictGroupes[nom]['SOURCE']
1230             if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
1231                 self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
1232                 port=self.dictGroupes[nom]['SOURCE']
1233
1234                 if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
1235                     if self.dictPort[port]['EPORT']=="VOLTAGE":
1236                         self.texteCarmel3D_INGEND2+= "\n1"
1237                     else:
1238                         self.texteCarmel3D_INGEND2+= "\n2"
1239                 if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
1240                     if self.dictPort[port]['HPORT']=="VOLTAGE":
1241                         self.texteCarmel3D_INGEND2+= "\n1"
1242                     else:
1243                         self.texteCarmel3D_INGEND2+= "\n2"
1244
1245 #-------------------------------------
1246 # Methodes utilitaires
1247 # ------------------------------------
1248    def formateCOMPLEX(self,nbC):
1249         """prise en compte des differentes formes de description d un nombre complexe
1250         3 formats possibles : 2 listes (anciennement tuples?)  et 1 nombre complexe
1251         """
1252         if self.debug:
1253             print "formatage"
1254             print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
1255         nbformate =""
1256         if isinstance(nbC,(tuple,list)):
1257             if nbC[0] == "'RI'" :
1258                 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
1259             if nbC[0] == "'MP'" :
1260                 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
1261         else:
1262             nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
1263         if self.debug:
1264             print "nbformate : %s" % nbformate
1265         return nbformate
1266
1267    def nomReelGroupe(self, nom, typeBloc=None):
1268         """Calcule et retourne le nom reel du groupe de maillage donne en entree,
1269         en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
1270         de bloc du fichier PHYS specifie.
1271         Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
1272         """
1273         from string import join
1274         if self.debug:
1275             print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
1276                             {'nom': nom, 'use_prefix': str(usePrefix)}
1277         nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
1278         if usePrefix:
1279             # suppression du prefixe si present
1280             partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
1281             # les tests suivants ne generent une erreur que si le prefixe est obligatoire
1282             if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
1283                 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
1284                                 indiquant le type de materiau ou de source associee", nom)
1285             elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
1286                 print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable",  nom)
1287             else:
1288                 # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
1289                 if typeBloc is not None:
1290                     if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
1291                         print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
1292                     elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
1293                         print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
1294                                         le prefixe correct pour etre associe a un type %(type_bloc)s", \
1295                                         {'nom': nom, 'type_bloc': str(typeBloc)})
1296                     else: # c'est bon
1297                         nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1298                         if self.debug:
1299                             print "ce groupe de maille (%(nom)s) a un prefixe qui \
1300                                             est supprime automatiquement pour devenir : %(nom_reel)s", \
1301                                             {'nom': nom, 'nom_reel': nomReel}
1302                 else: # c'est bon
1303                     nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
1304                     if self.debug:
1305                         print "ce groupe de maille (%(nom)s) a un prefixe qui \
1306                                         est supprime automatiquement pour devenir : %(nom_reel)s", \
1307                                         {'nom': nom, 'nom_reel': nomReel}
1308         if self.debug:
1309             print "... %s", nomReel
1310         return nomReel