-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2012 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
-"""
-
-import traceback
-import types,string,re,os
-
-from generator_python import PythonGenerator
-
-# dictionnaire contenant la liste des materiaux :
-# cle = nom du materiau
-# valeur = nature du materiau ; correspond a un sous bloc du bloc MATERIALS du fichier de parametres Carmel3D
-#
-# les materiaux sont :
-# - des materiaux de reference connus fournis par THEMIS,
-# - ou des materiaux generiques theoriques
-#
-#
-dictNatureMaterRef={"DIELECTRIC":"DIELECTRIC",
- "CONDUCTOR":"CONDUCTOR",
- "ZSURFACIC":"ZSURFACIC",
- "ZINSULATOR":"ZINSULATOR",
- "NILMAT":"NILMAT",
- "EM_ISOTROPIC":"EMISO",
- "EM_ANISOTROPIC":"EMANISO",
- "ACIER_CIMBLOT":"CONDUCTOR",
- "ACIER_Noir":"CONDUCTOR",
- "ACIER_PE":"CONDUCTOR",
- "ALU":"CONDUCTOR",
- "BRONZE":"CONDUCTOR",
- "CUIVRE":"CONDUCTOR",
- "FERRITE_Mn_Zn":"CONDUCTOR",
- "FERRITE_Ni_Zn":"CONDUCTOR",
- "INCONEL600":"CONDUCTOR",
- "POTASSE":"CONDUCTOR",
- "M6X2ISO1":"CONDUCTOR",
- "AIR":"DIELECTRIC",
- "FERRITEB30":"DIELECTRIC",
- "E24":"DIELECTRIC",
- "FEV470":"DIELECTRIC",
- "FEV600":"DIELECTRIC",
- "FEV800":"DIELECTRIC",
- "FEV1000":"DIELECTRIC",
- "HA600":"DIELECTRIC",
- "M600_65":"DIELECTRIC",
- "M6X":"EMANISO",
- "M6X_lineaire":"EMANISO",
- "M6X_homog":"EMANISO"
- }
-
-# Groupes de mailles dont les types sont définis par des préfixes dans leur nom
-usePrefix = False # les noms ont des préfixes (True) ou non (False)
-# liste des préfixes des groupes de mailles, sans le caractère _ séparant le préfixe du reste du nom
-# Ce préfixe (et caractère _) doivent être supprimés dans le fichier .phys
-listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
- "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
- "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
- "PORT_OMEGA","POST_PHI","PB_GRID",
- "SCUTE","SCUTN","ZS","ZJ","ZT")
-# liste des préfixes des groupes de mailles, sans le séparateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
-dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
- 'CONDUCTOR':('COND',),
- 'STRANDED_INDUCTOR':('CURRENT', ),
- 'EPORT':('EPORT', ),
- 'HPORT':('HPORT', ),
- 'ZSURFACIC':('ZS', ),
- 'ZINSULATOR':('ZJ', ),
- 'NILMAT':('NILMAT', )}
-# séparateur entre le préfixe et le reste du nom du groupe de maille
-sepNomGroupeMaille = '_'
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'CARMEL3D',
- # La factory pour creer une instance du plugin
- 'factory' : CARMEL3DGenerator,
- }
-
-
-class CARMEL3DGenerator(PythonGenerator):
- """
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
-
- """
- # Les extensions de fichier permis?
- extensions=('.comm',)
-
-#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None):
-
- self.initDico()
-
- # Cette instruction genere le contenu du fichier de commandes (persistance)
- self.text=PythonGenerator.gener(self,obj,format)
-
- if self.debug:
- print "self.text=",self.text
-
- # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
- # si le jdc est valide (sinon cela n a pas de sens)
- if obj.isvalid() :
- # constitution du bloc VERSION du fichier PHYS (existe toujours)
- self.generBLOC_VERSION(obj)
-
- # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
- self.generBLOC_MATERIALS()
-
- # constitution du bloc SOURCES du fichier PHYS (existe toujours)
- self.generBLOC_SOURCES()
-
-# print "texte carmel3d :\n",self.texteCarmel3D
-# print "dictMaterDielectric : ",self.dictMaterDielectric
- if self.debug:
- print "dictMaterConductor : ",self.dictMaterConductor
-
- return self.text
-
-
-#----------------------------------------------------------------------------------------
-# initialisations
-#----------------------------------------------------------------------------------------
-
- def initDico(self) :
-
- self.texteCarmel3D=""
- self.debug = False # affichage de messages pour déboguage (.true.) ou non
- self.dicoEtapeCourant=None
- self.dicoMCFACTCourant=None
- self.dicoCourant=None
- self.dictGroupesMaillage = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[]} # association des noms de groupes de maillage avec les noms de matériaux ou de sources, en sauvegardant l'ordre du JdC en séparant les groupes associés à des matériaux de ceux associés à des sources
- self.dictMaterConductor={}
- self.dictMaterDielectric={}
- self.dictMaterZsurfacic={}
- self.dictMaterEmIso={}
- self.dictMaterEmAnIso={}
- self.dictMaterNilmat={}
- self.dictMaterZinsulator={}
- self.dictSourceStInd={}
- self.dictSourceEport={}
- self.dictSourceHport={}
-
-
-#----------------------------------------------------------------------------------------
-# ecriture
-#----------------------------------------------------------------------------------------
-
- def writeDefault(self,fn) :
- """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""
- if self.debug: print "ecriture fic phys"
- filePHYS = fn[:fn.rfind(".")] + '.phys'
- f = open( str(filePHYS), 'wb')
- f.write( self.texteCarmel3D)
- f.close()
-
-#----------------------------------------------------------------------------------------
-# analyse de chaque noeud de l'arbre
-#----------------------------------------------------------------------------------------
-
- def generMCSIMP(self,obj) :
- """recuperation de l objet MCSIMP"""
- if self.debug: print "MCSIMP", obj.nom, " ", obj.valeur
- s=PythonGenerator.generMCSIMP(self,obj)
- self.dicoCourant[obj.nom]=obj.valeurFormatee
- return s
-
-
-#----------------------------------------------------------------------------------------
- def generMCFACT(self,obj) :
- """recuperation de l objet MCFACT"""
- dico={}
- self.dicoMCFACTCourant=dico
- self.dicoCourant=self.dicoMCFACTCourant
- s=PythonGenerator.generMCFACT(self,obj)
- self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
- self.dicoMCFACTCourant=None
- self.dicoCourant=self.dicoEtapeCourant
- return s
-
-#----------------------------------------------------------------------------------------
- def generPROC_ETAPE(self,obj):
- """analyse des PROC du catalogue ( VERSION )"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant
- if self.debug: print "PROC_ETAPE", obj.nom, " ", obj.valeur
- s=PythonGenerator.generPROC_ETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
- def generETAPE(self,obj):
- """analyse des OPER du catalogue"""
- dico={}
- self.dicoEtapeCourant=dico
- self.dicoCourant=self.dicoEtapeCourant
- s=PythonGenerator.generETAPE(self,obj)
- obj.valeur=self.dicoEtapeCourant
- if self.debug: print "ETAPE :obj.nom =", obj.nom, " , obj.valeur= ", obj.valeur
- if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
- if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
- if obj.nom=="SOURCE" : self.generSOURCE(obj)
- s=PythonGenerator.generETAPE(self,obj)
- return s
-
-#----------------------------------------------------------------------------------------
-#----------------------------------------------------------------------------------------
- def generMESHGROUP(self,obj):
- """preparation de la ligne NAME referencant le groupe de mailles
- associe le groupe de mailles au materiau ou a la source utilisateur
- on sauvegarde aussi les noms des groupes de maillage
- """
- try:
- if usePrefix:
- nomGroupeMaillage = self.nomReelGroupeMaillage(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec préfixes enlevés
- else:
- nomGroupeMaillage = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
- # test: un et un seul nom de matériau ou source doit être associé à ce groupe de maillage, via les clés MATERIAL et SOURCE, respectivement.
- # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
- #assert len(obj.valeur.keys())==1,u"Un et un seul nom de matériau ou source doit être associé à ce groupe du maillage :"+nomGroupeMaillage
- #
- # on utilise le fait que obj.valeur est un dictionnaire
- if self.debug: print "obj.valeur.keys()=", obj.valeur.keys()
- if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de présence de matériau et source à la fois
- raise ValueError, u"ce groupe de maillage ("+nomGroupeMaillage+") est associé à au moins un matériau et au moins une source."
- # association à un matériau
- if 'MATERIAL' in obj.valeur.keys():
- self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un matériau ou source, par son nom, i.e. nom du concept du matériau ou de la source
- self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associé à un matériau, dans l'ordre du JdC
- # association à une source
- elif 'SOURCE' in obj.valeur.keys():
- self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un matériau ou source, par son nom, i.e. nom du concept du matériau ou de la source
- self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associé à une source, dans l'ordre du JdC
- # erreur ni matériau ni source associée
- else:
- raise ValueError, u"ce groupe de maillage ("+nomGroupeMaillage+") n'est associé à aucun matériau ou source."
- if self.debug:
- print "self.dictGroupesMaillage=",self.dictGroupesMaillage
- except:
- pass
-
-
- def generMATERIAL(self,obj):
- """préparation du bloc correspondant à un matériau du fichier PHYS"""
- texte=""
- if self.debug: print "gener material obj valeur = ", obj.valeur
- try :
- nature=dictNatureMaterRef[obj.valeur['MAT_REF']]
- if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
- if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
- if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
- if nature=="EMISO" : self.generMATERIAL_EMISO(obj)
- if nature=="EMANISO" : self.generMATERIAL_EMANISO(obj)
- if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
- if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
- except:
- pass
-
- def generMATERIAL_CONDUCTOR(self,obj):
- # preparation du sous bloc CONDUCTOR
- texte=""
- # print "__________cond_________________"
- # parcours des proprietes du sous bloc CONDUCTOR
- for keyN1 in obj.valeur :
- if keyN1=='MAT_REF': continue
- # print "keyN1=", keyN1
-# print obj.valeur[keyN1]['TYPE_LAW']
- texte+=" ["+keyN1+"\n"
- # loi lineaire reelle
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :
- texte+=" LAW LINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE_REAL"])+" 0\n"
- # loi lineaire complexe
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_COMPLEX' :
- # print "si avec linear complex"
- texte+=" LAW LINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE "
- # print "nbre a formater : ",obj.valeur[keyN1]["VALUE_COMPLEX"]
- chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])
- texte+= chC+"\n"
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
- # seuls les reels sont pris en compte
- if obj.valeur[keyN1]['TYPE_LAW']=='NONLINEAR' :
- texte+=" LAW NONLINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE"])+" 0\n"
- texte+=" [NONLINEAR \n"
- texte+=" ISOTROPY TRUE\n"
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
- for keyN2 in obj.valeur[keyN1] :
- if keyN2 != 'TYPE_LAW' and keyN2 != 'VALUE' and keyN2 != 'NATURE' :
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
- texte+=" ]"+"\n"
- texte+=" ]"+"\n"
-
- self.dictMaterConductor[obj.get_sdname()]=texte
- # self.dictMaterConductor[obj.get_sdname()]=[texte,]
-# print texte
-
-
- def generMATERIAL_DIELECTRIC(self,obj):
- # preparation du sous bloc DIELECTRIC
- texte=""
- # print "______________nocond_____________"
- # parcours des proprietes du sous bloc DIELECTRIC
- for keyN1 in obj.valeur :
- if keyN1=='MAT_REF': continue
- # print "type loi = ", obj.valeur[keyN1]['TYPE_LAW']
- # debut du sous bloc de propriete du DIELECTRIC
- texte+=" ["+keyN1+"\n"
- # loi lineaire reelle
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :
- texte+=" LAW LINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE_REAL"])+" 0\n"
- # loi lineaire complexe
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_COMPLEX' :
- texte+=" LAW LINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE "
- chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])
- texte+= chC+"\n"
-
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
- # seuls les reels sont pris en compte
- if obj.valeur[keyN1]['TYPE_LAW']=='NONLINEAR' :
- texte+=" LAW NONLINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE"])+" 0\n"
- texte+=" [NONLINEAR \n"
- texte+=" ISOTROPY TRUE\n"
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
- for keyN2 in obj.valeur[keyN1] :
- if keyN2 != 'TYPE_LAW' and keyN2 != 'VALUE' and keyN2 != 'NATURE' :
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
- texte+=" ]"+"\n"
- # fin du sous bloc de propriete
- texte+=" ]"+"\n"
- #print "texte = ", texte
- self.dictMaterDielectric[obj.get_sdname()]=texte
-
- def generMATERIAL_ZSURFACIC(self,obj):
- # preparation du sous bloc ZSURFACIC
- texte=""
- #print "______________zsurf_____________"
- for keyN1 in obj.valeur :
- if keyN1=='MAT_REF': continue
- # print "keyN1=", keyN1
- # print obj.valeur[keyN1]['TYPE_LAW']
- texte+=" ["+keyN1+"\n"
- # loi lineaire reelle
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :
- texte+=" LAW LINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE_REAL"])+" 0\n"
- # loi lineaire complexe
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_COMPLEX' :
- texte+=" LAW LINEAR\n"
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
- texte+=" VALUE "
- chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])
- texte+= chC+"\n"
- texte+=" ]"+"\n"
- self.dictMaterZsurfacic[obj.get_sdname()]=texte
-
- def generMATERIAL_EMISO(self,obj):
- """preparation du sous bloc EM_ISOTROPIC_FILES.
- Les fichiers sont indiqués par le chemin indiqué dans Eficas, i.e. le chemin absolu par défaut
- """
- texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
- texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # Possibilité de forcer le chemin relatif (nom de fichier seulement) plutôt que le chemin absolu par défaut
- #from os.path import basename
- #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
- #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
- # print "obj get sdname= ", obj.get_sdname()
- # if obj.get_sdname() in self.dictMaterEmIso.keys() :
- # self.dictMaterEmIso[obj.get_sdname()].append(texte)
- # else :
- self.dictMaterEmIso[obj.get_sdname()]=texte
-
- def generMATERIAL_EMANISO(self,obj):
- """preparation du sous bloc EM_ANISOTROPIC_FILES.
- Les fichiers sont indiqués par le chemin indiqué dans Eficas, i.e. le chemin absolu par défaut
- """
- texte =" CONDUCTIVITY "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
- texte+=" PERMEABILITY "+str(obj.valeur["PERMEABILITY_File"])+"\n"
- # Possibilité de forcer le chemin relatif (nom de fichier seulement) plutôt que le chemin absolu par défaut
- #from os.path import basename
- #texte =" CONDUCTIVITY "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
- #texte+=" PERMEABILITY "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
- # print "obj get sdname= ", obj.get_sdname()
- # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
- # self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
- # else :
- self.dictMaterEmAnIso[obj.get_sdname()]=texte
-
- def generMATERIAL_NILMAT(self,obj):
- # preparation du sous bloc NILMAT
- texte=""
- self.dictMaterNilmat[obj.get_sdname()]=texte
-
- def generMATERIAL_ZINSULATOR(self,obj):
- """"preparation du sous bloc ZINSULATOR"""
- texte=""
- self.dictMaterZinsulator[obj.get_sdname()]=texte
-
-#-------------------------------------------------------------------
-
- def generSOURCE(self,obj):
- """preparation du bloc correspondant à une source du fichier PHYS"""
- if self.debug: print "gener source obj valeur = ", obj.valeur
- texte=""
- try :
- typesource=obj.valeur['TYPE_SOURCE']
- if typesource=="STRANDED_INDUCTOR" : self.generSOURCE_STRANDED_INDUCTOR(obj)
- if typesource=="HPORT" : self.generSOURCE_HPORT(obj)
- if typesource=="EPORT" : self.generSOURCE_EPORT(obj)
- except:
- pass
-
- def generSOURCE_STRANDED_INDUCTOR(self,obj):
- """preparation du sous bloc STRANDED_INDUCTOR"""
- texte=""
- try :
- texte+=" NTURNS "+ str(obj.valeur['NTURNS']) + "\n"
- texte+=" CURJ " + self.formateCOMPLEX(obj.valeur['CURJ']) + "\n"
- self.dictSourceStInd[obj.get_sdname()]=texte
- if self.debug: print texte
- except:
- pass
-
- def generSOURCE_HPORT(self,obj):
- """preparation du sous bloc HPORT"""
- texte=""
- try :
- texte+=" TYPE "+ str(obj.valeur['TYPE']) + "\n"
- texte+=" AMP " + self.formateCOMPLEX(obj.valeur['AMP']) + "\n"
- self.dictSourceHport[obj.get_sdname()]=texte
- if self.debug: print texte
- except:
- pass
-
- def generSOURCE_EPORT(self,obj):
- """preparation du sous bloc EPORT"""
- texte=""
- try :
- texte+=" TYPE "+ str(obj.valeur['TYPE']) + "\n"
- texte+=" AMP " + self.formateCOMPLEX(obj.valeur['AMP']) + "\n"
- self.dictSourceEport[obj.get_sdname()]=texte
- if self.debug: print texte
- except:
- pass
-
-#---------------------------------------------------------------------------------------
-# traitement fichier PHYS
-#---------------------------------------------------------------------------------------
-
- def generBLOC_VERSION(self,obj) :
- # constitution du bloc VERSION du fichier PHYS
- # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
- # dans le du catalogue
- version=obj.addentite('VERSION',pos=None)
- self.generPROC_ETAPE(obj.etapes[0])
- self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
- for cle in obj.etapes[0].valeur :
- self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
- self.texteCarmel3D+="]\n"
- # destruction de l entite creee
- obj.suppentite(version)
-
-#----------------------------------------------------------------------------------------
- def generBLOC_MATERIALS(self) :
- """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
- Le bloc MATERIALS existe toujours !
- """
- if self.debug:
- print "cle dico materconductor : " , self.dictMaterConductor.keys()
- print "cle dico materdielectric : " , self.dictMaterDielectric.keys()
- # constitution du bloc MATERIALS du fichier PHYS
- self.texteCarmel3D+="[MATERIALS\n"
- # tri alphabétique de tous les groupes de maillage associés à des sources (plus nécessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
- nomsGroupesMaillage.sort() # tri alphabétique, avec les préfixes éventuels
- if self.debug:
- print u"noms groupes de mailles associés à des matériaux (ordre JdC puis tri)=", self.dictGroupesMaillage['ordreMateriauxJdC'], nomsGroupesMaillage
- # constitution du bloc CONDUCTOR du fichier PHYS si existe
- if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)
- # constitution du bloc DIELECTRIC du fichier PHYS si exixte
- if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)
- # constitution du bloc ZSURFACIC du fichier PHYS si exixte
- if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)
- # constitution du bloc NILMAT du fichier PHYS si exixte
- if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)
- # constitution du bloc ZINSULATOR du fichier PHYS si exixte
- if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)
- # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont placés en dernier dans le fichier PHYS
- # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
- if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()
- # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
- if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()
- # fin du bloc MATERIALS du fichier PHYS
- self.texteCarmel3D+="]\n"
-
- def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :
- """Constitution du bloc CONDUCTOR du fichier PHYS"""
- typeBloc = 'CONDUCTOR' # initialisation du type de bloc
- dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des propriétés du bloc
- if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :
- """Constitution du bloc DIELECTRIC du fichier PHYS"""
- typeBloc = 'DIELECTRIC' # initialisation du type de bloc
- dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des propriétés du bloc
- if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :
- """Constitution du bloc ZSURFACIC du fichier PHYS"""
- typeBloc = 'ZSURFACIC' # initialisation du type de bloc
- dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des propriétés du bloc
- if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_EMISO(self) :
- """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
- for cle in self.dictMaterEmIso.keys():
- self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
- self.texteCarmel3D+= self.dictMaterEmIso[cle]
- self.texteCarmel3D+=" ]\n"
-
- def creaBLOC_EMANISO(self) :
- """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
- for cle in self.dictMaterEmAnIso.keys():
- self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
- self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
- self.texteCarmel3D+=" ]\n"
-
- def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :
- """Constitution du bloc ZINSULATOR du fichier PHYS"""
- typeBloc = 'ZINSULATOR' # initialisation du type de bloc
- dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des propriétés du bloc
- if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_NILMAT(self, nomsGroupesMaillage) :
- """Constitution du bloc NILMAT du fichier PHYS"""
- typeBloc = 'NILMAT' # initialisation du type de bloc
- dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des propriétés du bloc
- if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type
- # ecriture du bloc complet
- self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
-#----------------------------------------------------------------------------------------
- def generBLOC_SOURCES(self):
- """constitution du bloc SOURCES du fichier PHYS"""
- self.texteCarmel3D+="[SOURCES\n"
- # tri alphabétique de tous les groupes de maillage associés à des sources
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste
- nomsGroupesMaillage.sort() # tri alphabétique, avec les préfixes éventuels
- if self.debug:
- print u'noms groupes de mailles associés à des sources (ordre JdC puis tri)=', self.dictGroupesMaillage['ordreSourcesJdC'], nomsGroupesMaillage
- if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)
- if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)
- if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)
- # fin du bloc SOURCES du fichier PHYS
- self.texteCarmel3D+="]\n"
-
-
- def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :
- """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
- if self.debug: print u'clés sources STRANDED_INDUCTOR=', self.dictSourceStInd.keys()
- typeBloc = 'STRANDED_INDUCTOR'
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associée est un inducteur bobiné
- # ecriture du bloc de l'inducteur bobiné
- self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # début de bloc
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des propriétés de l'inducteur bobiné
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_EPORT(self, nomsGroupesMaillage) :
- """constitution du bloc EPORT du fichier PHYS"""
- if self.debug: print u'clés sources EPORT=', self.dictSourceEport.keys()
- typeBloc = 'EPORT'
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associée est un port électrique
- # ecriture du bloc du port électrique
- self.texteCarmel3D+=" [EPORT\n" # début de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des propriétés du port électrique
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
- def creaBLOC_HPORT(self, nomsGroupesMaillage) :
- """constitution du bloc HPORT du fichier PHYS"""
- if self.debug: print u'clés sources HPORT=', self.dictSourceHport.keys()
- typeBloc = 'HPORT'
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage
- if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associée est un port magnétique
- # ecriture du bloc du port magnétique
- self.texteCarmel3D+=" [HPORT\n" # début de bloc
- if usePrefix:
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)
- else:
- nomReel = nom
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage
- self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des propriétés du port magnétique
- self.texteCarmel3D+=" ]\n" # fin de bloc
-
-#-------------------------------------
-# Méthodes utilitaires
-# ------------------------------------
- def formateCOMPLEX(self,nbC):
- """prise en compte des differentes formes de description d un nombre complexe
- 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
- """
- if self.debug:
- print "formatage "
- print "type : ", type(nbC), "pour ", nbC
- nbformate =""
- if isinstance(nbC,(tuple,list)):
- if nbC[0] == "'RI'" :
- nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
- if nbC[0] == "'MP'" :
- nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
- else:
- nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
- if self.debug: print "nbformate : ", nbformate
- return nbformate
-
- def nomReelGroupeMaillage(self, nom, typeBloc=None):
- """Calcule et retourne le nom réel du groupe de maillage donné en entrée,
- en tenant compte de l'utilisation de préfixes ou pas, et cela pour le type
- de bloc du fichier PHYS spécifié.
- Cette routine vérifie aussi, en cas d'utilisation de préfixes, si le préfixe est en adéquation avec le type du bloc.
- """
- from string import join
- if self.debug: print "nom groupe original : "+nom+" avec usePrefix="+str(usePrefix)+" devient... "
- nomReel= None # nom affiché dans le fichier PHYS, sans préfixe a priori
- if usePrefix:
- # suppression du préfixe si présent
- partiesNom = nom.split(sepNomGroupeMaille) # séparation du nom du groupe en parties
- # les tests suivants ne génèrent une erreur que si le préfixe est obligatoire
- if len(partiesNom) < 2: # test d'erreur, pas de séparateur donc nom incorrect, i.e. sans préfixe c'est sûr
- print u"ERREUR! ce groupe de maille ("+nom+") n'a pas de préfixe indiquant le type de matériau ou de source associée"
- elif partiesNom[0] not in listePrefixesGroupeMaille: # préfixe non défini
- print u"ERREUR! ce groupe de maille ("+nom+") n'a pas de préfixe valable"
- else:
- # vérification de l'adéquation du préfixe avec le type de bloc demandé, si fourni
- if typeBloc is not None:
- if typeBloc not in dictPrefixesGroupeMaille: # test validité de typeBloc, devant être une clé du dictionnaire
- print u"ERREUR! ce type de bloc ("+str(typeBloc)+") n'est pas valable"
- elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de préfixe correct pour ce type de bloc
- print u"ERREUR! ce groupe de maille ("+nom+") n'a pas le préfixe correct pour être associé à un type "+str(typeBloc)
- else: # c'est bon
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans préfixe complet
- if self.debug: print u"ce groupe de maille ("+nom+") a un préfixe qui est supprimé automatiquement pour devenir : "+nomReel
- else: # c'est bon
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans préfixe complet
- if self.debug: print u"ce groupe de maille ("+nom+") a un préfixe qui est supprimé automatiquement pour devenir : "+nomReel
- if self.debug: print "... "+nomReel
- return nomReel
+# -*- coding: utf-8 -*-\r
+# Copyright (C) 2007-2012 EDF R&D\r
+#\r
+# This library is free software; you can redistribute it and/or\r
+# modify it under the terms of the GNU Lesser General Public\r
+# License as published by the Free Software Foundation; either\r
+# version 2.1 of the License.\r
+#\r
+# This library is distributed in the hope that it will be useful,\r
+# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
+# Lesser General Public License for more details.\r
+#\r
+# You should have received a copy of the GNU Lesser General Public\r
+# License along with this library; if not, write to the Free Software\r
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
+#\r
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com\r
+#\r
+"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.\r
+"""\r
+\r
+import traceback\r
+import types,string,re,os\r
+\r
+from generator_python import PythonGenerator\r
+\r
+# dictionnaire contenant la liste des materiaux :\r
+# cle = nom du materiau \r
+# valeur = nature du materiau ; correspond a un sous bloc du bloc MATERIALS du fichier de parametres Carmel3D\r
+#\r
+# les materiaux sont : \r
+# - des materiaux de reference connus fournis par THEMIS,\r
+# - ou des materiaux generiques theoriques \r
+#\r
+#\r
+dictNatureMaterRef={"DIELECTRIC":"DIELECTRIC",\r
+ "CONDUCTOR":"CONDUCTOR",\r
+ "ZSURFACIC":"ZSURFACIC",\r
+ "ZINSULATOR":"ZINSULATOR",\r
+ "NILMAT":"NILMAT",\r
+ "EM_ISOTROPIC":"EMISO",\r
+ "EM_ANISOTROPIC":"EMANISO",\r
+ "ACIER_CIMBLOT":"CONDUCTOR", \r
+ "ACIER_Noir":"CONDUCTOR", \r
+ "ACIER_PE":"CONDUCTOR", \r
+ "ALU":"CONDUCTOR", \r
+ "BRONZE":"CONDUCTOR", \r
+ "CUIVRE":"CONDUCTOR", \r
+ "FERRITE_Mn_Zn":"CONDUCTOR", \r
+ "FERRITE_Ni_Zn":"CONDUCTOR", \r
+ "INCONEL600":"CONDUCTOR", \r
+ "POTASSE":"CONDUCTOR",\r
+ "M6X2ISO1":"CONDUCTOR", \r
+ "AIR":"DIELECTRIC", \r
+ "FERRITEB30":"DIELECTRIC", \r
+ "E24":"DIELECTRIC",\r
+ "FEV470":"DIELECTRIC",\r
+ "FEV600":"DIELECTRIC",\r
+ "FEV800":"DIELECTRIC",\r
+ "FEV1000":"DIELECTRIC",\r
+ "HA600":"DIELECTRIC",\r
+ "M600_65":"DIELECTRIC",\r
+ "M6X":"EMANISO",\r
+ "M6X_lineaire":"EMANISO",\r
+ "M6X_homog":"EMANISO"\r
+ }\r
+\r
+# Groupes de mailles dont les types sont définis par des préfixes dans leur nom\r
+usePrefix = False # les noms ont des préfixes (True) ou non (False)\r
+# liste des préfixes des groupes de mailles, sans le caractère _ séparant le préfixe du reste du nom\r
+# Ce préfixe (et caractère _) doivent être supprimés dans le fichier .phys\r
+listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",\r
+ "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",\r
+ "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",\r
+ "PORT_OMEGA","POST_PHI","PB_GRID",\r
+ "SCUTE","SCUTN","ZS","ZJ","ZT")\r
+# liste des préfixes des groupes de mailles, sans le séparateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire\r
+dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'), \r
+ 'CONDUCTOR':('COND',), \r
+ 'STRANDED_INDUCTOR':('CURRENT', ), \r
+ 'EPORT':('EPORT', ), \r
+ 'HPORT':('HPORT', ), \r
+ 'ZSURFACIC':('ZS', ), \r
+ 'ZINSULATOR':('ZJ', ), \r
+ 'NILMAT':('NILMAT', )}\r
+# séparateur entre le préfixe et le reste du nom du groupe de maille\r
+sepNomGroupeMaille = '_'\r
+\r
+def entryPoint():\r
+ """\r
+ Retourne les informations necessaires pour le chargeur de plugins\r
+ Ces informations sont retournees dans un dictionnaire\r
+ """\r
+ return {\r
+ # Le nom du plugin\r
+ 'name' : 'CARMEL3D',\r
+ # La factory pour creer une instance du plugin\r
+ 'factory' : CARMEL3DGenerator,\r
+ }\r
+\r
+\r
+class CARMEL3DGenerator(PythonGenerator):\r
+ """\r
+ Ce generateur parcourt un objet de type JDC et produit\r
+ un texte au format eficas et \r
+ un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS') \r
+\r
+ """\r
+ # Les extensions de fichier permis?\r
+ extensions=('.comm',)\r
+\r
+#----------------------------------------------------------------------------------------\r
+ def gener(self,obj,format='brut',config=None):\r
+ \r
+ self.initDico()\r
+ \r
+ # Cette instruction genere le contenu du fichier de commandes (persistance)\r
+ self.text=PythonGenerator.gener(self,obj,format)\r
+\r
+ if self.debug:\r
+ print "self.text=",self.text\r
+\r
+ # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D\r
+ # si le jdc est valide (sinon cela n a pas de sens)\r
+ if obj.isvalid() : \r
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)\r
+ self.generBLOC_VERSION(obj)\r
+\r
+ # constitution du bloc MATERIALS du fichier PHYS (existe toujours)\r
+ self.generBLOC_MATERIALS()\r
+\r
+ # constitution du bloc SOURCES du fichier PHYS (existe toujours)\r
+ self.generBLOC_SOURCES()\r
+\r
+# print "texte carmel3d :\n",self.texteCarmel3D\r
+# print "dictMaterDielectric : ",self.dictMaterDielectric\r
+ if self.debug:\r
+ print "dictMaterConductor : ",self.dictMaterConductor\r
+ \r
+ return self.text\r
+\r
+\r
+#----------------------------------------------------------------------------------------\r
+# initialisations\r
+#----------------------------------------------------------------------------------------\r
+ \r
+ def initDico(self) :\r
+ \r
+ self.texteCarmel3D=""\r
+ self.debug = True # affichage de messages pour déboguage (.true.) ou non\r
+ self.dicoEtapeCourant=None\r
+ self.dicoMCFACTCourant=None\r
+ self.dicoCourant=None\r
+ self.dictGroupesMaillage = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[]} # association des noms de groupes de maillage avec les noms de matériaux ou de sources, en sauvegardant l'ordre du JdC en séparant les groupes associés à des matériaux de ceux associés à des sources\r
+ self.dictMaterConductor={}\r
+ self.dictMaterDielectric={}\r
+ self.dictMaterZsurfacic={}\r
+ self.dictMaterEmIso={}\r
+ self.dictMaterEmAnIso={}\r
+ self.dictMaterNilmat={}\r
+ self.dictMaterZinsulator={}\r
+ self.dictSourceStInd={}\r
+ self.dictSourceEport={}\r
+ self.dictSourceHport={}\r
+\r
+\r
+#----------------------------------------------------------------------------------------\r
+# ecriture\r
+#----------------------------------------------------------------------------------------\r
+\r
+ def writeDefault(self,fn) :\r
+ """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""\r
+ if self.debug: print "ecriture fic phys"\r
+ filePHYS = fn[:fn.rfind(".")] + '.phys'\r
+ f = open( str(filePHYS), 'wb')\r
+ f.write( self.texteCarmel3D)\r
+ f.close()\r
+\r
+#----------------------------------------------------------------------------------------\r
+# analyse de chaque noeud de l'arbre \r
+#----------------------------------------------------------------------------------------\r
+\r
+ def generMCSIMP(self,obj) :\r
+ """recuperation de l objet MCSIMP"""\r
+ if self.debug: print "MCSIMP", obj.nom, " ", obj.valeur\r
+ s=PythonGenerator.generMCSIMP(self,obj)\r
+ self.dicoCourant[obj.nom]=obj.valeurFormatee\r
+ return s\r
+\r
+ \r
+#----------------------------------------------------------------------------------------\r
+ def generMCFACT(self,obj) :\r
+ """recuperation de l objet MCFACT"""\r
+ dico={}\r
+ self.dicoMCFACTCourant=dico\r
+ self.dicoCourant=self.dicoMCFACTCourant\r
+ s=PythonGenerator.generMCFACT(self,obj)\r
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant\r
+ self.dicoMCFACTCourant=None\r
+ self.dicoCourant=self.dicoEtapeCourant\r
+ return s\r
+ \r
+#----------------------------------------------------------------------------------------\r
+ def generPROC_ETAPE(self,obj):\r
+ """analyse des PROC du catalogue ( VERSION )"""\r
+ dico={}\r
+ self.dicoEtapeCourant=dico\r
+ self.dicoCourant=self.dicoEtapeCourant\r
+ s=PythonGenerator.generPROC_ETAPE(self,obj)\r
+ obj.valeur=self.dicoEtapeCourant\r
+ if self.debug: print "PROC_ETAPE", obj.nom, " ", obj.valeur\r
+ s=PythonGenerator.generPROC_ETAPE(self,obj)\r
+ return s\r
+ \r
+#----------------------------------------------------------------------------------------\r
+ def generETAPE(self,obj):\r
+ """analyse des OPER du catalogue"""\r
+ dico={}\r
+ self.dicoEtapeCourant=dico\r
+ self.dicoCourant=self.dicoEtapeCourant\r
+ s=PythonGenerator.generETAPE(self,obj)\r
+ obj.valeur=self.dicoEtapeCourant\r
+ if self.debug: print "ETAPE :obj.nom =", obj.nom, " , obj.valeur= ", obj.valeur\r
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)\r
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)\r
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)\r
+ s=PythonGenerator.generETAPE(self,obj)\r
+ return s\r
+\r
+#----------------------------------------------------------------------------------------\r
+#----------------------------------------------------------------------------------------\r
+ def generMESHGROUP(self,obj):\r
+ """preparation de la ligne NAME referencant le groupe de mailles \r
+ associe le groupe de mailles au materiau ou a la source utilisateur\r
+ on sauvegarde aussi les noms des groupes de maillage\r
+ """\r
+ try:\r
+ if usePrefix:\r
+ nomGroupeMaillage = self.nomReelGroupeMaillage(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec préfixes enlevés\r
+ else:\r
+ nomGroupeMaillage = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept\r
+ # test: un et un seul nom de matériau ou source doit être associé à ce groupe de maillage, via les clés MATERIAL et SOURCE, respectivement.\r
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.\r
+ #assert len(obj.valeur.keys())==1,u"Un et un seul nom de matériau ou source doit être associé à ce groupe du maillage :"+nomGroupeMaillage\r
+ #\r
+ # on utilise le fait que obj.valeur est un dictionnaire\r
+ if self.debug: print "obj.valeur.keys()=", obj.valeur.keys()\r
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de présence de matériau et source à la fois\r
+ raise ValueError, u"ce groupe de maillage ("+nomGroupeMaillage+") est associé à au moins un matériau et au moins une source."\r
+ # association à un matériau\r
+ if 'MATERIAL' in obj.valeur.keys():\r
+ self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un matériau ou source, par son nom, i.e. nom du concept du matériau ou de la source\r
+ self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associé à un matériau, dans l'ordre du JdC\r
+ # association à une source\r
+ elif 'SOURCE' in obj.valeur.keys():\r
+ self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un matériau ou source, par son nom, i.e. nom du concept du matériau ou de la source\r
+ self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associé à une source, dans l'ordre du JdC\r
+ # erreur ni matériau ni source associée\r
+ else:\r
+ raise ValueError, u"ce groupe de maillage ("+nomGroupeMaillage+") n'est associé à aucun matériau ou source."\r
+ if self.debug:\r
+ print "self.dictGroupesMaillage=",self.dictGroupesMaillage\r
+ except:\r
+ pass\r
+\r
+\r
+ def generMATERIAL(self,obj):\r
+ """préparation du bloc correspondant à un matériau du fichier PHYS"""\r
+ texte=""\r
+ if self.debug: print "gener material obj valeur = ", obj.valeur\r
+ try :\r
+ nature=dictNatureMaterRef[obj.valeur['MAT_REF']]\r
+ if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)\r
+ if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)\r
+ if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)\r
+ if nature=="EMISO" : self.generMATERIAL_EMISO(obj)\r
+ if nature=="EMANISO" : self.generMATERIAL_EMANISO(obj)\r
+ if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)\r
+ if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)\r
+ except:\r
+ pass\r
+\r
+ def generMATERIAL_CONDUCTOR(self,obj):\r
+ # preparation du sous bloc CONDUCTOR\r
+ texte=""\r
+ # print "__________cond_________________"\r
+ # parcours des proprietes du sous bloc CONDUCTOR\r
+ for keyN1 in obj.valeur :\r
+ if keyN1=='MAT_REF': continue\r
+ # print "keyN1=", keyN1\r
+# print obj.valeur[keyN1]['TYPE_LAW']\r
+ texte+=" ["+keyN1+"\n"\r
+ # loi lineaire reelle\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :\r
+ texte+=" LAW LINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ # Ecriture des valeurs seulement pour un matériau homogène et isotrope,\r
+ # car sinon ces valeurs sont définies dans des fichiers annexes\r
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
+ if homogeneous and isotropic:\r
+ texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE_REAL"])+" 0\n"\r
+ # loi lineaire complexe\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_COMPLEX' :\r
+ # print "si avec linear complex"\r
+ texte+=" LAW LINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ # Ecriture des valeurs seulement pour un matériau homogène et isotrope,\r
+ # car sinon ces valeurs sont définies dans des fichiers annexes\r
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
+ if homogeneous and isotropic:\r
+ texte+=" VALUE "\r
+ # print "nbre a formater : ",obj.valeur[keyN1]["VALUE_COMPLEX"]\r
+ chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])\r
+ texte+= chC+"\n"\r
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation\r
+ # seuls les reels sont pris en compte\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='NONLINEAR' :\r
+ texte+=" LAW NONLINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ # Ecriture des valeurs seulement pour un matériau homogène et isotrope,\r
+ # car sinon ces valeurs sont définies dans des fichiers annexes\r
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
+ if homogeneous and isotropic:\r
+ texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE"])+" 0\n"\r
+ texte+=" [NONLINEAR \n"\r
+ texte+=" ISOTROPY TRUE\n"\r
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"\r
+ for keyN2 in obj.valeur[keyN1] :\r
+ if keyN2 != 'TYPE_LAW' and keyN2 != 'VALUE' and keyN2 != 'NATURE' :\r
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"\r
+ texte+=" ]"+"\n"\r
+ texte+=" ]"+"\n"\r
+\r
+ self.dictMaterConductor[obj.get_sdname()]=texte\r
+ # self.dictMaterConductor[obj.get_sdname()]=[texte,]\r
+# print texte\r
+ \r
+\r
+ def generMATERIAL_DIELECTRIC(self,obj):\r
+ # preparation du sous bloc DIELECTRIC\r
+ texte=""\r
+ # print "______________nocond_____________"\r
+ # parcours des proprietes du sous bloc DIELECTRIC\r
+ for keyN1 in obj.valeur :\r
+ if keyN1=='MAT_REF': continue\r
+ # print "type loi = ", obj.valeur[keyN1]['TYPE_LAW']\r
+ # debut du sous bloc de propriete du DIELECTRIC\r
+ texte+=" ["+keyN1+"\n"\r
+ # loi lineaire reelle\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :\r
+ texte+=" LAW LINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ # Ecriture des valeurs seulement pour un matériau homogène et isotrope,\r
+ # car sinon ces valeurs sont définies dans des fichiers annexes\r
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
+ if homogeneous and isotropic:\r
+ texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE_REAL"])+" 0\n"\r
+ # loi lineaire complexe\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_COMPLEX' :\r
+ texte+=" LAW LINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ # Ecriture des valeurs seulement pour un matériau homogène et isotrope,\r
+ # car sinon ces valeurs sont définies dans des fichiers annexes\r
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
+ if homogeneous and isotropic:\r
+ texte+=" VALUE "\r
+ chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])\r
+ texte+= chC+"\n"\r
+ \r
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation\r
+ # seuls les reels sont pris en compte\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='NONLINEAR' :\r
+ texte+=" LAW NONLINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ # Ecriture des valeurs seulement pour un matériau homogène et isotrope,\r
+ # car sinon ces valeurs sont définies dans des fichiers annexes\r
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
+ if homogeneous and isotropic:\r
+ texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE"])+" 0\n"\r
+ texte+=" [NONLINEAR \n"\r
+ texte+=" ISOTROPY TRUE\n"\r
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"\r
+ for keyN2 in obj.valeur[keyN1] :\r
+ if keyN2 != 'TYPE_LAW' and keyN2 != 'VALUE' and keyN2 != 'NATURE' :\r
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"\r
+ texte+=" ]"+"\n"\r
+ # fin du sous bloc de propriete\r
+ texte+=" ]"+"\n"\r
+ #print "texte = ", texte \r
+ self.dictMaterDielectric[obj.get_sdname()]=texte\r
+ \r
+ def generMATERIAL_ZSURFACIC(self,obj):\r
+ # preparation du sous bloc ZSURFACIC\r
+ texte=""\r
+ #print "______________zsurf_____________"\r
+ for keyN1 in obj.valeur :\r
+ if keyN1=='MAT_REF': continue\r
+ # print "keyN1=", keyN1\r
+ # print obj.valeur[keyN1]['TYPE_LAW']\r
+ texte+=" ["+keyN1+"\n"\r
+ # loi lineaire reelle\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :\r
+ texte+=" LAW LINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ texte+=" VALUE COMPLEX "+str(obj.valeur[keyN1]["VALUE_REAL"])+" 0\n"\r
+ # loi lineaire complexe\r
+ if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_COMPLEX' :\r
+ texte+=" LAW LINEAR\n"\r
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
+ texte+=" VALUE "\r
+ chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])\r
+ texte+= chC+"\n" \r
+ texte+=" ]"+"\n"\r
+ self.dictMaterZsurfacic[obj.get_sdname()]=texte\r
+\r
+ def generMATERIAL_EMISO(self,obj):\r
+ """preparation du sous bloc EM_ISOTROPIC_FILES.\r
+ Les fichiers sont indiqués par le chemin relatif, i.e. le nom du fichier seulement,\r
+ de façon à permettre de déplacer les dossiers contenant le modèle complet.\r
+ """\r
+ #texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
+ #texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
+ # Possibilité de forcer le chemin relatif (nom de fichier seulement) plutôt que le chemin absolu par défaut\r
+ from os.path import basename\r
+ texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"\r
+ texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"\r
+ # print "obj get sdname= ", obj.get_sdname()\r
+ # if obj.get_sdname() in self.dictMaterEmIso.keys() :\r
+ # self.dictMaterEmIso[obj.get_sdname()].append(texte) \r
+ # else :\r
+ self.dictMaterEmIso[obj.get_sdname()]=texte\r
+ \r
+ def generMATERIAL_EMANISO(self,obj):\r
+ """preparation du sous bloc EM_ANISOTROPIC_FILES.\r
+ Les fichiers sont indiqués par le chemin relatif, i.e. le nom du fichier seulement,\r
+ de façon à permettre de déplacer les dossiers contenant le modèle complet.\r
+ """\r
+ #texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
+ #texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
+ # Possibilité de forcer le chemin relatif (nom de fichier seulement) plutôt que le chemin absolu par défaut\r
+ from os.path import basename\r
+ texte =" CONDUCTIVITY MATER "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"\r
+ texte+=" PERMEABILITY MATER "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"\r
+ # print "obj get sdname= ", obj.get_sdname()\r
+ # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :\r
+ # self.dictMaterEmAnIso[obj.get_sdname()].append(texte) \r
+ # else :\r
+ self.dictMaterEmAnIso[obj.get_sdname()]=texte\r
+ \r
+ def generMATERIAL_NILMAT(self,obj):\r
+ # preparation du sous bloc NILMAT\r
+ texte=""\r
+ self.dictMaterNilmat[obj.get_sdname()]=texte\r
+ \r
+ def generMATERIAL_ZINSULATOR(self,obj):\r
+ """"preparation du sous bloc ZINSULATOR"""\r
+ texte=""\r
+ self.dictMaterZinsulator[obj.get_sdname()]=texte\r
+\r
+#-------------------------------------------------------------------\r
+\r
+ def generSOURCE(self,obj):\r
+ """preparation du bloc correspondant à une source du fichier PHYS"""\r
+ if self.debug: print "gener source obj valeur = ", obj.valeur\r
+ texte=""\r
+ try :\r
+ typesource=obj.valeur['TYPE_SOURCE']\r
+ if typesource=="STRANDED_INDUCTOR" : self.generSOURCE_STRANDED_INDUCTOR(obj)\r
+ if typesource=="HPORT" : self.generSOURCE_HPORT(obj)\r
+ if typesource=="EPORT" : self.generSOURCE_EPORT(obj)\r
+ except:\r
+ pass\r
+\r
+ def generSOURCE_STRANDED_INDUCTOR(self,obj):\r
+ """preparation du sous bloc STRANDED_INDUCTOR"""\r
+ texte=""\r
+ try :\r
+ texte+=" NTURNS "+ str(obj.valeur['NTURNS']) + "\n"\r
+ texte+=" CURJ " + self.formateCOMPLEX(obj.valeur['CURJ']) + "\n"\r
+ self.dictSourceStInd[obj.get_sdname()]=texte\r
+ if self.debug: print texte\r
+ except:\r
+ pass\r
+\r
+ def generSOURCE_HPORT(self,obj):\r
+ """preparation du sous bloc HPORT"""\r
+ texte=""\r
+ try :\r
+ texte+=" TYPE "+ str(obj.valeur['TYPE']) + "\n"\r
+ texte+=" AMP " + self.formateCOMPLEX(obj.valeur['AMP']) + "\n"\r
+ self.dictSourceHport[obj.get_sdname()]=texte\r
+ if self.debug: print texte\r
+ except:\r
+ pass\r
+\r
+ def generSOURCE_EPORT(self,obj):\r
+ """preparation du sous bloc EPORT"""\r
+ texte=""\r
+ try :\r
+ texte+=" TYPE "+ str(obj.valeur['TYPE']) + "\n"\r
+ texte+=" AMP " + self.formateCOMPLEX(obj.valeur['AMP']) + "\n"\r
+ self.dictSourceEport[obj.get_sdname()]=texte\r
+ if self.debug: print texte\r
+ except:\r
+ pass\r
+\r
+#---------------------------------------------------------------------------------------\r
+# traitement fichier PHYS\r
+#---------------------------------------------------------------------------------------\r
+\r
+ def generBLOC_VERSION(self,obj) :\r
+ # constitution du bloc VERSION du fichier PHYS\r
+ # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi\r
+ # dans le du catalogue\r
+ version=obj.addentite('VERSION',pos=None)\r
+ self.generPROC_ETAPE(obj.etapes[0])\r
+ self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"\r
+ for cle in obj.etapes[0].valeur :\r
+ self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"\r
+ self.texteCarmel3D+="]\n"\r
+ # destruction de l entite creee \r
+ obj.suppentite(version)\r
+\r
+#----------------------------------------------------------------------------------------\r
+ def generBLOC_MATERIALS(self) :\r
+ """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).\r
+ Le bloc MATERIALS existe toujours ! \r
+ """\r
+ if self.debug:\r
+ print "cle dico materconductor : " , self.dictMaterConductor.keys()\r
+ print "cle dico materdielectric : " , self.dictMaterDielectric.keys()\r
+ # constitution du bloc MATERIALS du fichier PHYS\r
+ self.texteCarmel3D+="[MATERIALS\n"\r
+ # tri alphabétique de tous les groupes de maillage associés à des sources (plus nécessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)\r
+ nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste\r
+ nomsGroupesMaillage.sort() # tri alphabétique, avec les préfixes éventuels\r
+ if self.debug:\r
+ print u"noms groupes de mailles associés à des matériaux (ordre JdC puis tri)=", self.dictGroupesMaillage['ordreMateriauxJdC'], nomsGroupesMaillage\r
+ # constitution du bloc CONDUCTOR du fichier PHYS si existe\r
+ if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)\r
+ # constitution du bloc DIELECTRIC du fichier PHYS si exixte\r
+ if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)\r
+ # constitution du bloc ZSURFACIC du fichier PHYS si exixte\r
+ if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)\r
+ # constitution du bloc NILMAT du fichier PHYS si exixte\r
+ if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)\r
+ # constitution du bloc ZINSULATOR du fichier PHYS si exixte\r
+ if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)\r
+ # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont placés en dernier dans le fichier PHYS\r
+ # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte\r
+ if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()\r
+ # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte\r
+ if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()\r
+ # fin du bloc MATERIALS du fichier PHYS\r
+ self.texteCarmel3D+="]\n" \r
+ \r
+ def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :\r
+ """Constitution du bloc CONDUCTOR du fichier PHYS"""\r
+ typeBloc = 'CONDUCTOR' # initialisation du type de bloc\r
+ dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des propriétés du bloc\r
+ if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type\r
+ # ecriture du bloc complet\r
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc\r
+ if usePrefix:\r
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
+ else:\r
+ nomReel = nom\r
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+ def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :\r
+ """Constitution du bloc DIELECTRIC du fichier PHYS"""\r
+ typeBloc = 'DIELECTRIC' # initialisation du type de bloc\r
+ dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des propriétés du bloc\r
+ if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type\r
+ # ecriture du bloc complet\r
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc\r
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+ def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :\r
+ """Constitution du bloc ZSURFACIC du fichier PHYS"""\r
+ typeBloc = 'ZSURFACIC' # initialisation du type de bloc\r
+ dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des propriétés du bloc\r
+ if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type\r
+ # ecriture du bloc complet\r
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc\r
+ if usePrefix:\r
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
+ else:\r
+ nomReel = nom\r
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+ def creaBLOC_EMISO(self) :\r
+ """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""\r
+ for cle in self.dictMaterEmIso.keys():\r
+ self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"\r
+ self.texteCarmel3D+= self.dictMaterEmIso[cle] \r
+ self.texteCarmel3D+=" ]\n"\r
+\r
+ def creaBLOC_EMANISO(self) :\r
+ """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""\r
+ for cle in self.dictMaterEmAnIso.keys():\r
+ self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"\r
+ self.texteCarmel3D+= self.dictMaterEmAnIso[cle] \r
+ self.texteCarmel3D+=" ]\n"\r
+\r
+ def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :\r
+ """Constitution du bloc ZINSULATOR du fichier PHYS"""\r
+ typeBloc = 'ZINSULATOR' # initialisation du type de bloc\r
+ dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des propriétés du bloc\r
+ if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type\r
+ # ecriture du bloc complet\r
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc\r
+ if usePrefix:\r
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
+ else:\r
+ nomReel = nom\r
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+ def creaBLOC_NILMAT(self, nomsGroupesMaillage) :\r
+ """Constitution du bloc NILMAT du fichier PHYS"""\r
+ typeBloc = 'NILMAT' # initialisation du type de bloc\r
+ dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des propriétés du bloc\r
+ if self.debug: print u'clés matériaux de type '+typeBloc+'=', dictProprietes.keys()\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du matériau associé est du bon type\r
+ # ecriture du bloc complet\r
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # début de bloc\r
+ if usePrefix:\r
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
+ else:\r
+ nomReel = nom\r
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des propriétés du type associé\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+#----------------------------------------------------------------------------------------\r
+ def generBLOC_SOURCES(self):\r
+ """constitution du bloc SOURCES du fichier PHYS"""\r
+ self.texteCarmel3D+="[SOURCES\n"\r
+ # tri alphabétique de tous les groupes de maillage associés à des sources\r
+ nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste\r
+ nomsGroupesMaillage.sort() # tri alphabétique, avec les préfixes éventuels\r
+ if self.debug:\r
+ print u'noms groupes de mailles associés à des sources (ordre JdC puis tri)=', self.dictGroupesMaillage['ordreSourcesJdC'], nomsGroupesMaillage\r
+ if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)\r
+ if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)\r
+ if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)\r
+ # fin du bloc SOURCES du fichier PHYS\r
+ self.texteCarmel3D+="]\n"\r
+\r
+\r
+ def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :\r
+ """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""\r
+ if self.debug: print u'clés sources STRANDED_INDUCTOR=', self.dictSourceStInd.keys()\r
+ typeBloc = 'STRANDED_INDUCTOR'\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associée est un inducteur bobiné\r
+ # ecriture du bloc de l'inducteur bobiné\r
+ self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # début de bloc\r
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des propriétés de l'inducteur bobiné\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+ \r
+ def creaBLOC_EPORT(self, nomsGroupesMaillage) :\r
+ """constitution du bloc EPORT du fichier PHYS"""\r
+ if self.debug: print u'clés sources EPORT=', self.dictSourceEport.keys()\r
+ typeBloc = 'EPORT'\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associée est un port électrique\r
+ # ecriture du bloc du port électrique\r
+ self.texteCarmel3D+=" [EPORT\n" # début de bloc\r
+ if usePrefix:\r
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
+ else:\r
+ nomReel = nom\r
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des propriétés du port électrique\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+ def creaBLOC_HPORT(self, nomsGroupesMaillage) :\r
+ """constitution du bloc HPORT du fichier PHYS"""\r
+ if self.debug: print u'clés sources HPORT=', self.dictSourceHport.keys()\r
+ typeBloc = 'HPORT'\r
+ for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
+ if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associée est un port magnétique\r
+ # ecriture du bloc du port magnétique\r
+ self.texteCarmel3D+=" [HPORT\n" # début de bloc\r
+ if usePrefix:\r
+ nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
+ else:\r
+ nomReel = nom\r
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (réel) du groupe du maillage\r
+ self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des propriétés du port magnétique\r
+ self.texteCarmel3D+=" ]\n" # fin de bloc\r
+\r
+#-------------------------------------\r
+# Méthodes utilitaires\r
+# ------------------------------------\r
+ def formateCOMPLEX(self,nbC):\r
+ """prise en compte des differentes formes de description d un nombre complexe\r
+ 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe\r
+ """\r
+ if self.debug:\r
+ print "formatage "\r
+ print "type : ", type(nbC), "pour ", nbC\r
+ nbformate =""\r
+ if isinstance(nbC,(tuple,list)):\r
+ if nbC[0] == "'RI'" :\r
+ nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2]) \r
+ if nbC[0] == "'MP'" :\r
+ nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2]) \r
+ else:\r
+ nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)\r
+ if self.debug: print "nbformate : ", nbformate\r
+ return nbformate\r
+ \r
+ def nomReelGroupeMaillage(self, nom, typeBloc=None):\r
+ """Calcule et retourne le nom réel du groupe de maillage donné en entrée,\r
+ en tenant compte de l'utilisation de préfixes ou pas, et cela pour le type\r
+ de bloc du fichier PHYS spécifié.\r
+ Cette routine vérifie aussi, en cas d'utilisation de préfixes, si le préfixe est en adéquation avec le type du bloc.\r
+ """\r
+ from string import join\r
+ if self.debug: print "nom groupe original : "+nom+" avec usePrefix="+str(usePrefix)+" devient... "\r
+ nomReel= None # nom affiché dans le fichier PHYS, sans préfixe a priori\r
+ if usePrefix:\r
+ # suppression du préfixe si présent\r
+ partiesNom = nom.split(sepNomGroupeMaille) # séparation du nom du groupe en parties\r
+ # les tests suivants ne génèrent une erreur que si le préfixe est obligatoire\r
+ if len(partiesNom) < 2: # test d'erreur, pas de séparateur donc nom incorrect, i.e. sans préfixe c'est sûr\r
+ print u"ERREUR! ce groupe de maille ("+nom+") n'a pas de préfixe indiquant le type de matériau ou de source associée"\r
+ elif partiesNom[0] not in listePrefixesGroupeMaille: # préfixe non défini\r
+ print u"ERREUR! ce groupe de maille ("+nom+") n'a pas de préfixe valable"\r
+ else: \r
+ # vérification de l'adéquation du préfixe avec le type de bloc demandé, si fourni \r
+ if typeBloc is not None:\r
+ if typeBloc not in dictPrefixesGroupeMaille: # test validité de typeBloc, devant être une clé du dictionnaire\r
+ print u"ERREUR! ce type de bloc ("+str(typeBloc)+") n'est pas valable"\r
+ elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de préfixe correct pour ce type de bloc\r
+ print u"ERREUR! ce groupe de maille ("+nom+") n'a pas le préfixe correct pour être associé à un type "+str(typeBloc)\r
+ else: # c'est bon\r
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans préfixe complet\r
+ if self.debug: print u"ce groupe de maille ("+nom+") a un préfixe qui est supprimé automatiquement pour devenir : "+nomReel\r
+ else: # c'est bon\r
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans préfixe complet\r
+ if self.debug: print u"ce groupe de maille ("+nom+") a un préfixe qui est supprimé automatiquement pour devenir : "+nomReel\r
+ if self.debug: print "... "+nomReel\r
+ return nomReel\r
