-# -*- 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
-"""\r
- Ce module contient le plugin generateur de fichier au format \r
- 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={"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
- "COND_LINEAR":"CONDUCTOR",\r
- "M6X2ISO1":"CONDUCTOR", \r
- "AIR":"NOCOND", \r
- "FERRITEB30":"NOCOND", \r
- "E24":"NOCOND",\r
- "FEV470":"NOCOND",\r
- "FEV600":"NOCOND",\r
- "FEV800":"NOCOND",\r
- "FEV1000":"NOCOND",\r
- "HA600":"NOCOND",\r
- "M600_65":"NOCOND",\r
- "NOCOND_LINEAR":"NOCOND",\r
- "NOCOND_NL_MAR":"NOCOND",\r
- "NOCOND_NL_MARSAT":"NOCOND",\r
- "M6X":"EMANISO",\r
- "M6X_lineaire":"EMANISO",\r
- "M6X_homog":"EMANISO",\r
- "EM_ISOTROPIC":"EMISO",\r
- "EM_ANISOTROPIC":"EMANISO",\r
- "ZSURFACIC":"ZSURFACIC",\r
- "ZINSULATOR":"ZINSULATOR",\r
- "NILMAT":"NILMAT"\r
- }\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 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
- # 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 s il existe\r
- if self.source == "oui" : self.generBLOC_SOURCES()\r
-\r
-# print "texte carmel3d :\n",self.texteCarmel3D\r
- print "dictName : ",self.dictName\r
- print "dictMaterConductor : ",self.dictMaterConductor\r
-# print "dictMaterNocond : ",self.dictMaterNocond\r
- \r
- return self.text\r
-\r
-\r
-#----------------------------------------------------------------------------------------\r
-# initialisations\r
-#----------------------------------------------------------------------------------------\r
- \r
- def initDico(self) :\r
- \r
- self.texteCarmel3D=""\r
- self.source="non"\r
- self.dicoEtapeCourant=None\r
- self.dicoMCFACTCourant=None\r
- self.dicoCourant=None\r
- self.dictName={"grm_def":" NAME gr_maille_a_saisir\n"}\r
- self.dictMaterConductor={}\r
- self.dictMaterNocond={}\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
- '''\r
- Ecrit le fichier de parametres (PHYS) pour le code Carmel3D\r
- '''\r
- #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
- """\r
- recuperation de l objet MCSIMP\r
- """\r
- \r
- # print "MCSIMP", obj.nom, " ", obj.valeur\r
- \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
- """\r
- recuperation de l objet MCFACT\r
- """\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
-#----------------------------------------------------------------------------------------\r
- def generPROC_ETAPE(self,obj):\r
- # analyse des PROC du catalogue ( VERSION ) \r
- \r
- dico={}\r
- self.dicoEtapeCourant=dico\r
- self.dicoCourant=self.dicoEtapeCourant\r
- s=PythonGenerator.generPROC_ETAPE(self,obj)\r
- obj.valeur=self.dicoEtapeCourant\r
- \r
- # print "PROC_ETAPE", obj.nom, " ", obj.valeur\r
- \r
- s=PythonGenerator.generPROC_ETAPE(self,obj)\r
- return s\r
-\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
-\r
- print "ETAPE :obj.nom =", obj.nom, " , obj.valeur= ", obj.valeur\r
-\r
- if obj.nom=="MESH_GROUPE" : self.generMESHGROUPE(obj)\r
- if obj.nom=="MATERIALS" : self.generMATERIALS(obj)\r
- if obj.nom=="SOURCES" : self.generSOURCES(obj)\r
-\r
- s=PythonGenerator.generETAPE(self,obj)\r
- return s\r
-\r
-#----------------------------------------------------------------------------------------\r
-#----------------------------------------------------------------------------------------\r
- def generMESHGROUPE(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
- try :\r
- texteName=" NAME "+obj.get_sdname()+"\n"\r
- for cle in obj.valeur :\r
- print "cle : ", cle\r
- print "cle sd : ", obj.valeur[cle].nom\r
- print "cle dico : ",self.dictName.keys()\r
- if obj.valeur[cle].nom in self.dictName :\r
- self.dictName[obj.valeur[cle].nom] += (texteName,)\r
- else: \r
- self.dictName[obj.valeur[cle].nom]=(texteName,) \r
-\r
- print "dans gener_mesh 2 dictName : ",self.dictName\r
- except:\r
- pass\r
-\r
-\r
- def generMATERIALS(self,obj):\r
- # preparation du bloc MATERIALS du fichier PHYS \r
- texte=""\r
- # print "gener materials obj valeur = ", obj.valeur\r
- try :\r
- nature=dictNatureMaterRef[obj.valeur['MAT_REF']]\r
- if nature=="CONDUCTOR" : self.generMATERIALSCONDUCTOR(obj)\r
- if nature=="NOCOND" : self.generMATERIALSNOCOND(obj)\r
- if nature=="ZSURFACIC" : self.generMATERIALSZSURFACIC(obj)\r
- if nature=="EMISO" : self.generMATERIALSEMISO(obj)\r
- if nature=="EMANISO" : self.generMATERIALSEMANISO(obj)\r
- if nature=="NILMAT" : self.generMATERIALSNILMAT(obj)\r
- if nature=="ZINSULATOR" : self.generMATERIALSZINSULATOR(obj)\r
- except:\r
- pass\r
-\r
- def generMATERIALSCONDUCTOR(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+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\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
-# print "si avec linear complex"\r
- texte+=" LAW LINEAR\n"\r
- texte+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\n"\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+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\n"\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
-\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 generMATERIALSNOCOND(self,obj):\r
- # preparation du sous bloc NOCOND\r
- texte=""\r
- # print "______________nocond_____________"\r
- # parcours des proprietes du sous bloc NOCOND\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 NOCOND\r
- texte+=" ["+keyN1+"\n"\r
- # loi lineaire reelle\r
- if obj.valeur[keyN1]['TYPE_LAW']=='LINEAR_REAL' :\r
- texte+=" LAW LINEAR\n"\r
- texte+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\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+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\n"\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+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\n"\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
-\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- #print "texte = ", texte \r
- self.dictMaterNocond[obj.get_sdname()]=texte\r
- \r
- def generMATERIALSZSURFACIC(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+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\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+=" HOMOGENOUS TRUE\n"\r
- texte+=" ISOTROPIC TRUE\n"\r
- texte+=" VALUE "\r
- chC= self.formateCOMPLEX(obj.valeur[keyN1]["VALUE_COMPLEX"])\r
- texte+= chC+"\n"\r
- \r
- texte+=" ]"+"\n"\r
-\r
- self.dictMaterZsurfacic[obj.get_sdname()]=texte\r
-\r
- def generMATERIALSEMISO(self,obj):\r
- # preparation du sous bloc EMISO\r
- texte=""\r
- texte+=" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
- texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
-\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 generMATERIALSEMANISO(self,obj):\r
- # preparation du sous bloc EMANISO\r
- texte=""\r
- texte+=" CONDUCTIVITY "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
- texte+=" PERMEABILITY "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
-\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 generMATERIALSNILMAT(self,obj):\r
- # preparation du sous bloc NILMAT\r
- texte=""\r
- self.dictMaterNilmat[obj.get_sdname()]=texte\r
- \r
- def generMATERIALSZINSULATOR(self,obj):\r
- # preparation du sous bloc ZINSULATOR\r
- texte=""\r
- self.dictMaterZinsulator[obj.get_sdname()]=texte\r
-\r
-#-------------------------------------------------------------------\r
-\r
- def generSOURCES(self,obj):\r
- # preparation du bloc SOURCES du fichier PHYS \r
- # print "gener sources obj valeur = ", obj.valeur\r
- texte=""\r
- try :\r
- self.source="oui"\r
- typesource=obj.valeur['TYPE_SOURCE']\r
- if typesource=="STRANDED_INDUCTOR" : self.generSOURCES_ST_IND(obj)\r
- if typesource=="HPORT" : self.generSOURCES_H_PORT(obj)\r
- if typesource=="EPORT" : self.generSOURCES_E_PORT(obj)\r
- except:\r
- pass\r
-\r
- def generSOURCES_ST_IND(self,obj):\r
- # preparation du sous bloc STRANDED INDUCTOR \r
- texte=""\r
- try :\r
- texte+=" NTURNS "+ str(obj.valeur['NTURNS']) + "\n"\r
- texte+=" CURJ POLAR " + str(obj.valeur['CURJ']) +" " +str(obj.valeur['POLAR'])+"\n" \r
- self.dictSourceStInd[obj.get_sdname()]=texte\r
- # print texte\r
- except:\r
- pass\r
-\r
- def generSOURCES_H_PORT(self,obj):\r
- # preparation du sous bloc HPORT \r
- texte=""\r
- try :\r
- texte+=" TYPE "+ str(obj.valeur['TYPE']) + "\n"\r
- texte+=" AMP POLAR " + str(obj.valeur['AMP']) +" " +str(obj.valeur['POLAR'])+"\n" \r
- self.dictSourceHport[obj.get_sdname()]=texte\r
- # print texte\r
- except:\r
- pass\r
-\r
- def generSOURCES_E_PORT(self,obj):\r
- # preparation du sous bloc EPORT \r
- texte=""\r
- try :\r
- texte+=" TYPE "+ str(obj.valeur['TYPE']) + "\n"\r
- texte+=" AMP POLAR " + str(obj.valeur['AMP']) +" " +str(obj.valeur['POLAR'])+"\n" \r
- self.dictSourceEport[obj.get_sdname()]=texte\r
- # 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
- '''\r
- Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D\r
- (bloc MATERIALS) \r
- le bloc MATERIALS existe toujours ! \r
- '''\r
- #print "cle dico materconductor : " , self.dictMaterConductor.keys()\r
- #print "cle dico materdielectric : " , self.dictMaterNocond.keys()\r
- \r
- # constitution du bloc MATERIALS du fichier PHYS\r
- self.texteCarmel3D+="[MATERIALS\n"\r
-\r
- # constitution du bloc CONDUCTOR du fichier PHYS si existe\r
- if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR()\r
- \r
- # constitution du bloc NOCOND du fichier PHYS si exixte\r
- if self.dictMaterNocond != {} : self.creaBLOC_NOCOND()\r
- \r
- # constitution du bloc ZSURFACIC du fichier PHYS si exixte\r
- if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC()\r
- \r
- # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte\r
- if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()\r
- \r
- # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte\r
- if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()\r
- \r
- # constitution du bloc NILMAT du fichier PHYS si exixte\r
- if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT()\r
- \r
- # constitution du bloc ZINSULATOR du fichier PHYS si exixte\r
- if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR()\r
- \r
- # fin du bloc MATERIALS du fichier PHYS\r
- self.texteCarmel3D+="]\n"\r
- \r
- \r
- def creaBLOC_CONDUCTOR(self) :\r
- # constitution du bloc CONDUCTOR du fichier PHYS\r
- \r
- for cle in self.dictMaterConductor.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [CONDUCTOR\n"\r
- print "Attention : groupe de maille non defini pour materiau : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+= self.dictMaterConductor[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [CONDUCTOR\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+= self.dictMaterConductor[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- \r
-\r
-\r
- def creaBLOC_NOCOND(self) :\r
- # constitution du bloc NOCOND du fichier PHYS\r
- \r
- for cle in self.dictMaterNocond.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [NOCOND\n"\r
- print "Attention : groupe de maille non defini pour materiau : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+= self.dictMaterNocond[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [NOCOND\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+= self.dictMaterNocond[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
-\r
- def creaBLOC_ZSURFACIC(self) :\r
- # constitution du bloc ZSURFACIC du fichier PHYS\r
- \r
- for cle in self.dictMaterZsurfacic.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [ZSURFACIC\n"\r
- print "Attention : groupe de maille non defini pour materiau : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+= self.dictMaterZsurfacic[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [ZSURFACIC\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+= self.dictMaterZsurfacic[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
- def creaBLOC_EMISO(self) :\r
- # constitution du bloc EMISO du fichier PHYS\r
- \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 EMANISO du fichier PHYS\r
- \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) :\r
- # constitution du bloc ZINSULATOR du fichier PHYS\r
- \r
- for cle in self.dictMaterZinsulator.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [ZINSULATOR\n"\r
- print "Attention : groupe de maille non defini pour materiau : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [ZINSULATOR\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+=" ]\n"\r
-\r
- def creaBLOC_NILMAT(self) :\r
- # constitution du bloc NILMAT du fichier PHYS\r
- \r
- for cle in self.dictMaterNilmat.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [NILMAT\n"\r
- print "Attention : groupe de maille non defini pour materiau : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [NILMAT\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+=" ]\n"\r
-\r
-#----------------------------------------------------------------------------------------\r
- def generBLOC_SOURCES(self):\r
- \r
- # constitution du bloc SOURCES du fichier PHYS\r
- self.texteCarmel3D+="[SOURCES\n"\r
-\r
- if self.dictSourceStInd != {} : self.creaBLOC_ST_IND()\r
-\r
- if self.dictSourceEport != {} : self.creaBLOC_EPORT()\r
-\r
- if self.dictSourceHport != {} : self.creaBLOC_HPORT()\r
-\r
- # fin du bloc SOURCES du fichier PHYS\r
- self.texteCarmel3D+="]\n"\r
-\r
-\r
- def creaBLOC_ST_IND(self) :\r
- # constitution du bloc STRANDED INDUCTOR du fichier PHYS\r
- \r
- for cle in self.dictSourceStInd.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [STRANDED INDUCTOR\n"\r
- print "Attention : groupe de maille non defini pour source : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+= self.dictSourceStInd[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [STRANDED INDUCTOR\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+= self.dictSourceStInd[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
- def creaBLOC_EPORT(self) :\r
- # constitution du bloc EPORT du fichier PHYS\r
- \r
- for cle in self.dictSourceEport.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [EPORT\n"\r
- print "Attention : groupe de maille non defini pour source : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+= self.dictSourceEport[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [EPORT\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+= self.dictSourceEport[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
- def creaBLOC_HPORT(self) :\r
- # constitution du bloc HPORT du fichier PHYS\r
- \r
- for cle in self.dictSourceHport.keys():\r
- if cle not in self.dictName.keys():\r
- self.texteCarmel3D+=" [HPORT\n"\r
- print "Attention : groupe de maille non defini pour source : ",cle\r
- print "fichier phys incomplet "\r
- self.texteCarmel3D+=str(self.dictName["grm_def"])\r
- self.texteCarmel3D+= self.dictSourceHport[cle] \r
- self.texteCarmel3D+=" ]\n"\r
- else : \r
- for elt_tup in self.dictName[cle] :\r
- self.texteCarmel3D+=" [HPORT\n"\r
- self.texteCarmel3D+=str(elt_tup)\r
- self.texteCarmel3D+= self.dictSourceHport[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
-#----------------------------------------------------------------------------\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
- # 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
- \r
- if nbC[0] == "'MP'" :\r
- nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2]) \r
-\r
- else :\r
- nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)\r
-\r
- # print "nbformate : ", nbformate\r
- return nbformate\r
-\r
+# -*- 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
