-# -*- coding: utf-8 -*-\r
-# Copyright (C) 2007-2013 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
-from Extensions.i18n import tr\r
-from generator_python import PythonGenerator\r
-\r
-# Groupes de mailles dont les types sont definis par des prefixes dans leur nom\r
-usePrefix = False # les noms ont des prefixes (True) ou non (False)\r
-# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom\r
-# Ce prefixe (et caractere _) doivent etre supprimes 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 prefixes des groupes de mailles, sans le separateur, 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
-# separateur entre le prefixe et le reste du nom du groupe de maille\r
-sepNomGroupeMaille = '_'\r
-\r
-# types de problemes\r
-HARMONIC = 'HARMONIC' # probleme frequentiel\r
-TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel\r
-\r
-# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()\r
-nomPlugin = 'CARMEL3DFV0'\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' : nomPlugin,\r
- # La factory pour creer une instance du plugin\r
- 'factory' : CARMEL3DFV0Generator,\r
- }\r
-\r
-\r
-class CARMEL3DFV0Generator(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 = %s" % 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
- try :\r
- # constitution du bloc VERSION du fichier PHYS (existe toujours)\r
- self.generBLOC_VERSION(obj)\r
- # constitution du bloc MATERIALS du fichier PHYS (existe toujours)\r
- self.generBLOC_MATERIALS()\r
- # constitution du bloc SOURCES du fichier PHYS (existe toujours)\r
- self.generBLOC_SOURCES()\r
- except ValueError, err:\r
- raise ValueError(str(err))\r
-\r
-# print "texte carmel3d :\n",self.texteCarmel3D\r
-# print "dictMaterDielectric : ",self.dictMaterDielectric\r
- if self.debug:\r
- print "dictMaterConductor : %s" % repr(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 deboguage (.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 materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources\r
- 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
- # on force le probleme a etre frequentiel, seul possible en l'etat des choses\r
- self.problem = HARMONIC\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: \r
- print "ecriture du fichier de parametres (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: \r
- print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": 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: \r
- print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(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: \r
- print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': 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
- def generMACRO_ETAPE(self,obj):\r
- dico={}\r
- self.dicoEtapeCourant=dico\r
- self.dicoCourant=self.dicoEtapeCourant\r
- import generator\r
- monGenerateur=generator.plugins[nomPlugin]()\r
- jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)\r
- if self.debug: \r
- print "jdc_aux_texte : %s" % jdc_aux_texte\r
-\r
- for cle in monGenerateur.dictMaterConductor:\r
- self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]\r
- for cle in monGenerateur.dictMaterDielectric:\r
- self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]\r
- for cle in monGenerateur.dictMaterZsurfacic:\r
- self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]\r
- for cle in monGenerateur.dictMaterEmIso:\r
- self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]\r
- for cle in monGenerateur.dictMaterEmAnIso:\r
- self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]\r
- for cle in monGenerateur.dictMaterNilmat:\r
- self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]\r
- for cle in monGenerateur.dictMaterZinsulator:\r
- self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]\r
- \r
- print "________FIN MACRO______________________________________"\r
- s=PythonGenerator.generMACRO_ETAPE(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 prefixes enleves\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 materiau ou source doit etre associe a ce groupe de maillage, via les cles 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,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage\r
- #\r
- # on utilise le fait que obj.valeur est un dictionnaire\r
- if self.debug: \r
- print "obj.valeur.keys()= %s" % obj.valeur.keys()\r
- if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois\r
- raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupeMaillage)\r
- # association a un materiau\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 materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source\r
- self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC\r
- # association a 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 materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source\r
- self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC\r
- # erreur ni materiau ni source associee\r
- else:\r
- raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau ou source." % nomGroupeMaillage)\r
- if self.debug:\r
- print "self.dictGroupesMaillage= %s" % repr(self.dictGroupesMaillage)\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
-\r
- def generMATERIAL(self,obj):\r
- """preparation du bloc correspondant a un materiau du fichier PHYS"""\r
- texte=""\r
- if self.debug: \r
- print "generation material obj.valeur = %s" % obj.valeur\r
- try :\r
- nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL\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=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)\r
- if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)\r
- if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)\r
- if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generMATERIAL_CONDUCTOR(self,obj):\r
- """preparation du sous bloc CONDUCTOR"""\r
- texte=""\r
- if self.debug: \r
- print "_____________cond_____________"\r
- # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)\r
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:\r
- print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()\r
- raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())\r
- else:\r
- # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)\r
- for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :\r
- # debut du sous bloc de propriete du DIELECTRIC\r
- texte+=" ["+keyN1+"\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 materiau homogene et isotrope,\r
- # car sinon ces valeurs sont definies 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
- # loi (lineaire ou non)\r
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"\r
- # valeur de la loi lineaire\r
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\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]['LAW']=='NONLINEAR' :\r
- texte+=" [NONLINEAR \n"\r
- texte+=" ISOTROPY TRUE\n"\r
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"\r
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC\r
- for keyN2 in obj.valeur[keyN1] :\r
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :\r
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"\r
- # fin du sous-bloc NONLINEAR\r
- texte+=" ]"+"\n"\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- if self.debug: \r
- print "texte = %s", texte\r
- self.dictMaterConductor[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc\r
-\r
- def generMATERIAL_DIELECTRIC(self,obj):\r
- """preparation du sous bloc DIELECTRIC"""\r
- texte=""\r
- if self.debug: \r
- print "______________nocond_____________"\r
- # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)\r
- if 'PERMEABILITY' not in obj.valeur or 'PERMITTIVITY' not in obj.valeur:\r
- print "ERREUR! Le matériau non conducteur (dielectric) de nom %s doit contenir les propriétés PERMEABILITY et PERMITTIVITY." % obj.get_sdname()\r
- raise ValueError, tr("ERREUR! Le materiau non conducteur (DIELECTRIC) de nom %s doit contenir les proprietes PERMEABILITY et PERMITTIVITY." % obj.get_sdname())\r
- else:\r
- # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)\r
- for keyN1 in ('PERMEABILITY','PERMITTIVITY') :\r
- # debut du sous bloc de propriete du DIELECTRIC\r
- texte+=" ["+keyN1+"\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 materiau homogene et isotrope,\r
- # car sinon ces valeurs sont definies 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
- # loi (lineaire ou non)\r
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"\r
- # valeur de la loi lineaire\r
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\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]['LAW']=='NONLINEAR' :\r
- texte+=" [NONLINEAR \n"\r
- texte+=" ISOTROPY TRUE\n"\r
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"\r
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC\r
- for keyN2 in obj.valeur[keyN1] :\r
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :\r
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"\r
- # fin du sous-bloc NONLINEAR\r
- texte+=" ]"+"\n"\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- if self.debug: \r
- print "texte = %s" % texte\r
- self.dictMaterDielectric[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc\r
-\r
- def generMATERIAL_ZSURFACIC(self,obj):\r
- """preparation du sous bloc ZSURFACIC"""\r
- texte=""\r
- if self.debug: \r
- print "______________zsurf_____________"\r
- # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)\r
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:\r
- print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()\r
- raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())\r
- else:\r
- # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)\r
- for keyN1 in obj.valeur :\r
- if keyN1=='TYPE': continue\r
- # print "type loi = ", obj.valeur[keyN1]['LAW']\r
- # debut du sous bloc de propriete du DIELECTRIC\r
- texte+=" ["+keyN1+"\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 materiau homogene et isotrope,\r
- # car sinon ces valeurs sont definies 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
- # loi (lineaire ou non)\r
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"\r
- # valeur de la loi lineaire\r
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- if self.debug: \r
- print "texte = %s", texte\r
- self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc\r
-\r
- def generMATERIAL_EMISO(self,obj):\r
- """preparation du sous bloc EM_ISOTROPIC_FILES.\r
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,\r
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.\r
- """\r
- texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
- texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
- # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut\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 indiques par le chemin absolu, i.e. le nom complet du JdC,\r
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.\r
- """\r
- texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
- texte+=" PERMEABILITY MATER "+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 a une source du fichier PHYS"""\r
- if self.debug: \r
- print "generation source obj valeur = %s" % obj.valeur\r
- texte=""\r
- try :\r
- # test de la presence des types de sources reconnus\r
- # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "STRANDED_INDUCTOR" in obj.valeur:\r
- self.generSOURCE_STRANDED_INDUCTOR(obj)\r
- elif "HPORT" in obj.valeur:\r
- self.generSOURCE_HPORT(obj)\r
- elif "EPORT" in obj.valeur:\r
- self.generSOURCE_EPORT(obj)\r
- else:\r
- print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generSOURCE_STRANDED_INDUCTOR(self,obj):\r
- """preparation du sous bloc STRANDED_INDUCTOR"""\r
- texte=""\r
- sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source\r
- try :\r
- texte+=" NTURNS %s\n" % str(sdict['NTURNS'])\r
- # test de la presence d'une forme de source reconnue\r
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "WAVEFORM_CONSTANT" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])\r
- print tr("ATTENTION! Une source constante \\r
- n'est possible qu'a frequence nulle \\r
- en regime frequentiel")\r
- elif "WAVEFORM_SINUS" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \\r
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}\r
- else:\r
- print tr("ERREUR! Une forme de la source du \\r
- type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")\r
- self.dictSourceStInd[obj.get_sdname()]=texte\r
- if self.debug: \r
- print texte\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generSOURCE_HPORT(self,obj):\r
- """preparation du sous bloc HPORT"""\r
- texte=""\r
- sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source\r
- try :\r
- texte+=" TYPE %s\n" % str(sdict['TYPE'])\r
- # test de la presence d'une forme de source reconnue\r
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "WAVEFORM_CONSTANT" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])\r
- print tr("ATTENTION! Une source constante n'est \\r
- possible qu'a frequence nulle en regime frequentiel")\r
- elif "WAVEFORM_SINUS" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \\r
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}\r
- else:\r
- print tr("ERREUR! Une forme de la source du type \\r
- WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")\r
- self.dictSourceHport[obj.get_sdname()]=texte\r
- if self.debug: \r
- print texte\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generSOURCE_EPORT(self,obj):\r
- """preparation du sous bloc EPORT"""\r
- texte=""\r
- sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source\r
- try :\r
- texte+=" TYPE %s\n" % str(sdict['TYPE'])\r
- # test de la presence d'une forme de source reconnue\r
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "WAVEFORM_CONSTANT" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])\r
- print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")\r
- elif "WAVEFORM_SINUS" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \\r
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}\r
- else:\r
- print tr("ERREUR! Une forme de la source du type \\r
- WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")\r
- self.dictSourceEport[obj.get_sdname()]=texte\r
- if self.debug: \r
- print texte\r
- except ValueError, err:\r
- raise ValueError, str(err)\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
- #print 'ERREUR : test erreur boite graphique BLOC_VERSION'\r
- #raise ValueError, 'test erreur boite graphique BLOC_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 dictionnaire materconductor : %s" % self.dictMaterConductor.keys()\r
- print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()\r
- # constitution du bloc MATERIALS du fichier PHYS\r
- self.texteCarmel3D+="[MATERIALS\n"\r
- # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)\r
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste\r
- nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels\r
- if self.debug:\r
- print "noms groupes de mailles associes a des materiaux \\r
- (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \\r
- {'v_1': self.dictGroupesMaillage['ordreMateriauxJdC'], \\r
- 'v_2': nomsGroupesMaillage}\r
- try: \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 places 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
- except ValueError, err:\r
- raise ValueError(str(err))\r
-\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 proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': 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 materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut 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 (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\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 proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': 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 materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc\r
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\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 proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': 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 materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut 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 (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\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 proprietes du bloc\r
- if self.debug: print 'cles materiaux 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 materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut 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 (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\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 proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': 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 materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut 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 (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\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 alphabetique de tous les groupes de maillage associes a des sources\r
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste\r
- nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels\r
- if self.debug:\r
- print 'noms groupes de mailles associes a des sources \\r
- (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \\r
- {'g_maillage_orig': self.dictGroupesMaillage['ordreSourcesJdC'], \\r
- 'g_maillage_trie': 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: \r
- print 'cles sources STRANDED_INDUCTOR= %s' % 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 associee est un inducteur bobine\r
- # ecriture du bloc de l'inducteur bobine\r
- self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc\r
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des proprietes de l'inducteur bobine\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: \r
- print 'cles sources EPORT= %s' % 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 associee est un port electrique\r
- # ecriture du bloc du port electrique\r
- self.texteCarmel3D+=" [EPORT\n" # debut 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 (reel) du groupe du maillage\r
- self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port electrique\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: \r
- print 'cles sources HPORT= %s' % 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 associee est un port magnetique\r
- # ecriture du bloc du port magnetique\r
- self.texteCarmel3D+=" [HPORT\n" # debut 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 (reel) du groupe du maillage\r
- self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port magnetique\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
-#-------------------------------------\r
-# Methodes 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_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': 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: \r
- print "nbformate : %s" % nbformate\r
- return nbformate\r
- \r
- def nomReelGroupeMaillage(self, nom, typeBloc=None):\r
- """Calcule et retourne le nom reel du groupe de maillage donne en entree,\r
- en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type\r
- de bloc du fichier PHYS specifie.\r
- Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.\r
- """\r
- from string import join\r
- if self.debug: \r
- print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \\r
- {'nom': nom, 'use_prefix': str(usePrefix)}\r
- nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori\r
- if usePrefix:\r
- # suppression du prefixe si present\r
- partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties\r
- # les tests suivants ne generent une erreur que si le prefixe est obligatoire\r
- if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur\r
- print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \\r
- indiquant le type de materiau ou de source associee", nom)\r
- elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini\r
- print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)\r
- else: \r
- # verification de l'adequation du prefixe avec le type de bloc demande, si fourni \r
- if typeBloc is not None:\r
- if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire\r
- print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))\r
- elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc\r
- print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \\r
- le prefixe correct pour etre associe a un type %(type_bloc)s", \\r
- {'nom': nom, 'type_bloc': str(typeBloc)})\r
- else: # c'est bon\r
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet\r
- if self.debug: \r
- print "ce groupe de maille (%(nom)s) a un prefixe qui \\r
- est supprime automatiquement pour devenir : %(nom_reel)s", \\r
- {'nom': nom, 'nom_reel': nomReel}\r
- else: # c'est bon\r
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet\r
- if self.debug: \r
- print "ce groupe de maille (%(nom)s) a un prefixe qui \\r
- est supprime automatiquement pour devenir : %(nom_reel)s", \\r
- {'nom': nom, 'nom_reel': nomReel}\r
- if self.debug: \r
- print "... %s", nomReel\r
- return nomReel\r
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 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 Extensions.i18n import tr
+from generator_python import PythonGenerator
+
+# Groupes de mailles dont les types sont definis par des prefixes dans leur nom
+usePrefix = False # les noms ont des prefixes (True) ou non (False)
+# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
+# Ce prefixe (et caractere _) doivent etre supprimes 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 prefixes des groupes de mailles, sans le separateur, 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', )}
+# separateur entre le prefixe et le reste du nom du groupe de maille
+sepNomGroupeMaille = '_'
+
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
+nomPlugin = 'CARMEL3DFV0'
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : nomPlugin,
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DFV0Generator,
+ }
+
+
+
+class CARMEL3DFV0Generator(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()
+
+ #self.debug = True
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s" % 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() :
+ try :
+ # 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()
+
+ except ValueError, err:
+ raise ValueError(str(err))
+
+# print "texte carmel3d :\n",self.texteCarmel3D
+# print "dictMaterDielectric : ",self.dictMaterDielectric
+ if self.debug:
+ print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
+ print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
+
+ return self.text
+
+
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+ self.texteCarmel3D=""
+ self.texteCarmel3D_PARAM=""
+ self.texteCarmel3D_PARAM_SOLV=""
+ self.texteCarmel3D_SH=""
+ self.texteCarmel3D_INFC=""
+ self.texteCarmel3D_CMD=""
+ self.texteCarmel3D_INGEND1=""
+ self.texteCarmel3D_INGEND2=""
+ self.texteCarmel3D_INGEND3=""
+ self.texteCarmel3D_INPOST=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupes = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[], 'ordreStrandJdC':[], 'ordreListeJdC':[], 'ordreDomaineJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMaterConductor={}
+ self.dictMaterDielectric={}
+ self.dictMaterZsurfacic={}
+ self.dictMaterEmIso={}
+ self.dictMaterEmAnIso={}
+ self.dictMaterNilmat={}
+ self.dictMaterZinsulator={}
+ self.dictSourceStInd={}
+ self.dictSourceEport={}
+ self.dictSourceHport={}
+ self.dictStrand={}
+ self.dictDomaine={}
+ self.dictPort={}
+ self.repertory=""
+ self.frequency=""
+ self.domaine=""
+ self.direction=""
+ self.section=""
+ self.forme=""
+ self.centre=""
+ self.echelle=""
+ self.visu=False
+ self.post_global=False
+ self.visu_format=""
+ self.visu_type=""
+ self.gendof=""
+ self.fcarmel=""
+ self.postprocess=""
+ self.formulation=""
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+ self.fichierMaillage = "" # chemin absolu ou relatif du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
+ self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
+ self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
+ self.materiauxGroupesTousHomogenes = True # Tous les groupes sont associés a priori à des matériaux tous homogènes mais pas forcément isotropes. On le vérifie ou modifie ci-dessous.
+ self.materiauxGroupesTousIsotropes = True # Tous les groupes sont associés a priori à des matériaux tous isotropes mais pas forcément homogènes. On le vérifie ou modifie ci-dessous.
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
+
+ # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
+ #file = fn[:fn.rfind(".")] # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
+ repertory=os.path.dirname(fn) # répertoire de l'étude, e.g., /home/toto/
+ file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
+ namefile=os.path.basename(file) # nom du projet e.g., foo
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (PHYS)"
+ filePHYS = file + '.phys'
+ typeBloc = 'PHYS_FILES'
+ f = open( str(filePHYS), 'w')
+ f.write( self.texteCarmel3D)
+ f.close()
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (PARAM)"
+ filePARAM = file + '.param'
+ f = open( str(filePARAM), 'w')
+ f.write('[VERSION \n'
+ ' NUM 1\n'
+ ' FILETYPE PARAM\n]\n'
+ '[PROBLEM\n'
+ ' NAME HARMONIC\n]\n'
+ )
+ typeBloc = 'CAR_FILES'
+ self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D_PARAM+=" NAME "+self.projet+".car"
+ self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
+ typeBloc = 'PHYS_FILES'
+ self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D_PARAM+=" NAME "+self.projet+".phys"
+ self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
+ self.texteCarmel3D_PARAM+="[FREQUENCY\n"
+ self.texteCarmel3D_PARAM+=" SINGLE %g \n" % (self.frequency )
+ self.texteCarmel3D_PARAM+="] \n"
+ f.write( self.texteCarmel3D_PARAM)
+ f.write(self.texteCarmel3D_PARAM_SOLV)
+ f.close()
+
+ # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
+ if self.debug:
+ print "ecriture du fichier de parametres (CMD)"
+ fileCMD =file + '.cmd'
+ f = open( str(fileCMD), 'w')
+ f.write(self.texteCarmel3D_CMD)
+ f.close()
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INGENDOF)"
+ fileINGEND = file + '.ingendof'
+ f = open(fileINGEND, 'w')
+ self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
+
+ nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
+ nomsGroupes.sort()
+
+ #if self.dictDomaine !={}:
+ try:
+ self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
+ except ValueError, err:
+ raise ValueError(str(err))
+ if self.dictPort != {} :
+ self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
+ if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
+ if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
+ f.write(self.texteCarmel3D_INGEND1)
+ f.write(self.texteCarmel3D_INGEND2)
+ f.write(self.texteCarmel3D_INGEND3)
+ f.close()
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INFCARMEL) "
+ fileINFC = file + '.infcarmel'
+ f = open(fileINFC, 'w')
+ self.texteCarmel3D_INFC+= self.projet+".param"
+ f.write(self.texteCarmel3D_INFC)
+ f.close()
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INPOSTPROCESS) "
+ fileINPOST = file + '.inpostprocess'
+ f = open(fileINPOST, 'w')
+ self.texteCarmel3D_INPOST+= self.projet+".param"
+ self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
+ self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
+ f.write(self.texteCarmel3D_INPOST)
+ f.close()
+
+ print "dictionnaire complet=%s" %self.dictGroupes
+ print "dictionnaire des ports =%s" %self.dictPort
+ if self.debug:
+ print "ecriture du fichier d'execution (SH)"
+ print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
+ RepCarmel= os.path.join(repertory,"lancer.sh")
+ f = open( str(RepCarmel), 'wb')
+ self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
+ if self.gendof=="TRUE":
+ self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
+ if self.echelle=="Millimetre":
+ self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
+ else:
+ self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
+ if self.fcarmel=="TRUE":
+ self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
+ self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe < " + self.projet + ".infcarmel\n"
+ if self.postprocess=="TRUE":
+ self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
+ self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
+ f.write(self.texteCarmel3D_SH)
+ f.close()
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": 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 %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
+ if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
+ if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(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 = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
+ if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
+ s=PythonGenerator.generETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins[nomPlugin]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s" % jdc_aux_texte
+
+ for cle in monGenerateur.dictMaterConductor:
+ self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
+ for cle in monGenerateur.dictMaterDielectric:
+ self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
+ for cle in monGenerateur.dictMaterZsurfacic:
+ self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
+ for cle in monGenerateur.dictMaterEmIso:
+ self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
+ for cle in monGenerateur.dictMaterEmAnIso:
+ self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
+ for cle in monGenerateur.dictMaterNilmat:
+ self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
+ for cle in monGenerateur.dictMaterZinsulator:
+ self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(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:
+ nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ else:
+ nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ self.dictGroupes[nomGroupe] = {}
+# nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['STRAND'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ if 'Domaine' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.get_sdname()]=texte
+ print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
+
+# else:
+# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMACRO_GROUPE(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 macros groupes
+ """
+ try:
+ #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
+ if usePrefix:
+ nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ else:
+ nomGroupe = obj.get_sdname() # nom du macro groupe
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ self.dictGroupes[nomGroupe] = {}
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError,tr("Ce MACRO_GROUPE %s ne peut pas contenir a la fois un MATERIAL et une SOURCE." % nomGroupe)
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'LISTE_MESHGROUP' in obj.valeur.keys():
+ listeStrandedInductorGeometry = True # indicateur du fait que tous les groupes de la liste sont des inducteurs bobinés ou topologiques, en morceaux ou entier (True), ou non (False). Utilisé pour savoir si le Domaine est nécessaire ou non.
+ listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes[nomGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
+ groupe = groupe.replace("'", "") # suppression des guillement simpes
+ groupe = groupe.replace('"', "") # suppression des guillement doubles
+ self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
+ if not self.dictGroupes[groupe].has_key('STRAND'): listeStrandedInductorGeometry = False # au moins un groupe de la liste n'est pas un inducteur bobiné ou topologique (morceau ou entier).
+ self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
+ if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
+ raise ValueError, tr(u"Le MACRO_GROUPE %s ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques." % nomGroupe)
+ # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
+ if 'Domaine' in obj.valeur.keys():
+ if listeStrandedInductorGeometry: # Domaine seulement en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.get_sdname()]=texte
+ else: # Erreur si Domaine et macro-groupe pas complètement inducteur
+ raise ValueError, tr(u"Ce MACRO_GROUPE %s contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques. Il ne doit pas contenir de Domaine." % nomGroupe)
+ else: # Domaine manquant
+ if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
+ raise ValueError, tr(u"Ce MACRO_GROUPE %s de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ print "self.dictDomaine=%s" %(self.dictDomaine)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+
+ def generSOLVEUR(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Type']
+ if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOLVEUR_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Methode_lineaire']
+ if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
+ if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMETHODE_ITERATIVE_BICGCR(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________iter_____________"
+
+ self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NAME BICGCR\n"
+ self.texteCarmel3D_PARAM_SOLV+=" [ITERATIVE_PARAM \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NITERMAX "+str(obj.valeur["Nombre_iterations_max"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" EPSILON "+str(obj.valeur["Precision"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
+ if self.debug:
+ print "texte = %s", texte
+
+
+ def generMETHODE_DIRECTE_MUMPS(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________directe_____________"
+
+ self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NAME MUMPS\n"
+ self.texteCarmel3D_PARAM_SOLV+=" [MUMPS_PARAMETER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" SYM "+str(obj.valeur["Type_de_matrice"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ICNTL "+str(obj.valeur["ICNTL_Control_Parameters"])+" "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
+ if self.debug:
+ print "texte = %s", texte
+
+
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
+ if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
+ if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
+ if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
+ if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
+ if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
+ if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
+ if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMATERIAL_CONDUCTOR(self,obj):
+ """preparation du sous bloc CONDUCTOR"""
+ texte=""
+ if self.debug:
+ print "_____________cond_____________"
+ # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
+ raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
+ else:
+ # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterConductor[obj.get_sdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
+
+ def generMATERIAL_DIELECTRIC(self,obj):
+ """preparation du sous bloc DIELECTRIC"""
+ texte=""
+ if self.debug:
+ print "______________nocond_____________"
+ # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ if 'PERMITTIVITY' not in obj.valeur:
+ print "obj.valeur=%s" %obj.valeur
+ obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
+
+ # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s" % texte
+ self.dictMaterDielectric[obj.get_sdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
+
+ def generMATERIAL_ZSURFACIC(self,obj):
+ """preparation du sous bloc ZSURFACIC"""
+ texte=""
+ if self.debug:
+ print "______________zsurf_____________"
+ # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
+ raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
+ else:
+ # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in obj.valeur :
+ if keyN1=='TYPE': continue
+ # print "type loi = ", obj.valeur[keyN1]['LAW']
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
+
+ def generMATERIAL_EMISO(self,obj):
+ """preparation du sous bloc EM_ISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ if "CONDUCTIVITY_File" in obj.valeur:
+ texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ if "PERMEABILITY_File" in obj.valeur:
+ texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
+ #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 indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ if "CONDUCTIVITY_File" in obj.valeur:
+ texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ if "PERMEABILITY_File" in obj.valeur:
+ texte+=" PERMEABILITY MATER "+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 a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s" % obj.valeur
+ texte=""
+ try :
+ # test de la presence des types de sources reconnus
+ # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "STRANDED_INDUCTOR" in obj.valeur:
+ self.generSOURCE_STRANDED_INDUCTOR(obj)
+ elif "HPORT" in obj.valeur:
+ self.generSOURCE_HPORT(obj)
+ elif "EPORT" in obj.valeur:
+ self.generSOURCE_EPORT(obj)
+ else:
+ print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_STRANDED_INDUCTOR(self,obj):
+ """preparation du sous bloc STRANDED_INDUCTOR"""
+ texte=""
+ sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ try :
+ texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
+ self.nturns=sdict['NTURNS']
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante \
+ n'est possible qu'a frequence nulle \
+ en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du \
+ type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceStInd[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_HPORT(self,obj):
+ """preparation du sous bloc HPORT"""
+ texte=""
+ sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ nomPort = obj.get_sdname()
+ self.dictPort[nomPort] = {}
+ self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante n'est \
+ possible qu'a frequence nulle en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du type \
+ WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceHport[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_EPORT(self,obj):
+
+
+ """preparation du sous bloc EPORT"""
+ texte=""
+ sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ nomPort = obj.get_sdname()
+ self.dictPort[nomPort] = {}
+ self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
+ print "sdict=%s" %(sdict)
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du type \
+ WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceEport[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+#
+ def generPARAM_CIRCULAIRE(self, obj):
+ if self.debug:
+ print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
+ self.centre=obj.valeur["Centre"]
+
+ def generPOST_COMMANDS(self, obj):
+ """Création du texte de commandes de post-traitement toto.cmd"""
+ if self.debug:
+ print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
+
+ if obj.valeur.has_key('GLOBAL'):
+ self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
+ if obj.valeur.has_key('VISU'):
+ self.texteCarmel3D_CMD+="[\nVISU"
+ # test de fichier de maillage bien lu
+ if self.fichierMaillage == "": raise ValueError, tr("ERREUR! Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au dessus du bloc POST_COMMANDS.")
+ self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
+ self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Format"]+"\n"
+ self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Type"]+"\n]\n"
+ if obj.valeur.has_key('CUTLINE'):
+ champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ self.texteCarmel3D_CMD+="[\nCUTLINE"
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["first_point"]))
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["last_point"]))
+ self.texteCarmel3D_CMD+="\n%d" % (obj.valeur["CUTLINE"]["number_of_points"], )
+ self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTLINE"]["name"]
+ # création du champ, renommé par rapport à l'interface
+ self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTLINE"]["field"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+ if obj.valeur.has_key('CUTPLANE'):
+ champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
+ self.texteCarmel3D_CMD+="[\nCUTPLANE"
+ self.texteCarmel3D_CMD+="\n%d" % (axes[obj.valeur["CUTPLANE"]["normal_vector"]], )
+ self.texteCarmel3D_CMD+="\n%f" % (obj.valeur["CUTPLANE"]["plane_position"], )
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTPLANE"]["number_of_points"]))
+ self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTPLANE"]["name"]
+ self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTPLANE"]["field"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+
+
+#---------------------------------------------------------------------------------------
+# 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)
+ #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
+ #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
+
+
+ def generBLOC_PARAMETERS(self,obj):
+ if self.debug:
+ print "generation parameters obj.valeur = %s" % obj.valeur
+
+ self.frequency=obj.valeur["FREQUENCY"]
+ self.repertory=obj.valeur["RepCarmel"]
+ self.fichierMaillage=obj.valeur["Fichier_maillage"]
+ self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
+ self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
+ self.echelle=obj.valeur["Echelle_du_maillage"]
+ self.gendof=obj.valeur["Realiser_topologie_gendof"]
+ self.fcarmel=obj.valeur["Resoudre_probleme"]
+ self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
+ self.formulation=obj.valeur["Formulation"]
+#----------------------------------------------------------------------------------------
+ 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 dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
+ print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
+ # constitution du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="[MATERIALS\n"
+ # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
+ nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
+ nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
+ if self.debug:
+ print "noms groupes de mailles associes a des materiaux \
+ (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
+ {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
+ 'v_2': nomsGroupes}
+ try: # mise à jour du fichier .phys selon les matériaux trouvés
+ # constitution du bloc CONDUCTOR du fichier PHYS si existe
+ if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
+ # constitution du bloc DIELECTRIC du fichier PHYS si exixte
+ if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
+ # constitution du bloc ZSURFACIC du fichier PHYS si exixte
+ if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
+ # constitution du bloc NILMAT du fichier PHYS si exixte
+ if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
+ # constitution du bloc ZINSULATOR du fichier PHYS si exixte
+ if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
+ # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
+ # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmIso != {} and self.materiauxGroupesTousIsotropes and not self.materiauxGroupesTousHomogenes : self.creaBLOC_EMISO() # bloc isotrope si au moins un matériau isotrope et non homogene
+ # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
+ except ValueError, err:
+ raise ValueError(str(err))
+
+
+ # fin du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+
+ def creaBLOC_CONDUCTOR(self, nomsGroupes) :
+ """Constitution du bloc CONDUCTOR du fichier PHYS"""
+ typeBloc = 'CONDUCTOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
+ print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
+ raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom))
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
+ or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
+ or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_DIELECTRIC(self, nomsGroupes) :
+ """Constitution du bloc DIELECTRIC du fichier PHYS"""
+ typeBloc = 'DIELECTRIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
+ print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
+ raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom))
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_ZSURFACIC(self, nomsGroupes) :
+ """Constitution du bloc ZSURFACIC du fichier PHYS"""
+ typeBloc = 'ZSURFACIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
+ 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, nomsGroupes) :
+ """Constitution du bloc ZINSULATOR du fichier PHYS"""
+ typeBloc = 'ZINSULATOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
+ if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_NILMAT(self, nomsGroupes) :
+ """Constitution du bloc NILMAT du fichier PHYS"""
+ typeBloc = 'NILMAT' # initialisation du type de bloc
+ dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+#----------------------------------------------------------------------------------------
+ def generBLOC_SOURCES(self):
+ """constitution du bloc SOURCES du fichier PHYS"""
+ self.texteCarmel3D+="[SOURCES\n"
+# # tri alphabetique de tous les groupes de maillage associes a des sources
+ nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
+ nomsGroupes.sort()
+ # print "RESULTAT APRES FUSION self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
+
+ if self.debug:
+ print 'noms groupes de mailles associes a des sources \
+ (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
+ {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
+ 'g_maillage_trie': nomsGroupes}
+ if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
+ if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
+ if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
+ # fin du bloc SOURCES du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+ def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
+ """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
+ if self.debug:
+ print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
+ typeBloc = 'STRANDED_INDUCTOR'
+# print "liste des NOM=%s" %(nom)
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
+ # ecriture du bloc de l'inducteur bobine
+ self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EPORT(self, nomsGroupes) :
+ """constitution du bloc EPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
+ typeBloc = 'EPORT'
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
+ # ecriture du bloc du port electrique
+ self.texteCarmel3D+=" [EPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_HPORT(self, nomsGroupes) :
+ """constitution du bloc HPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
+ typeBloc = 'HPORT'
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
+ # ecriture du bloc du port magnetique
+ self.texteCarmel3D+=" [HPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
+ """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
+
+ texte=""
+ self.direction=obj.valeur["Direction"]
+ self.section=obj.valeur["Section"]
+ self.forme=obj.valeur["Forme"]
+# texte+="\n%s" %(self.domaine)
+
+ if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
+ else:
+ texte+="\n1"
+ texte+="\n%s" % ' '.join(map(str, self.direction))
+ texte+="\n%g" % (self.section)
+ self.dictStrand[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+
+ def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
+ texte=""
+ self.centre=obj.valeur["Centre"]
+ texte+="\n2"
+ texte+="\n%s" % ' '.join(map(str,self.direction))
+ texte+="\n%s" % ' '.join(map(str, self.centre))
+ texte+="\n%g" % (self.section)
+ self.dictStrand[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+
+
+ def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
+ """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
+ Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
+ """
+ if self.debug:
+ print 'dictGroupes=', self.dictGroupes
+ print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
+ print "nomsGroupes=%s" %(nomsGroupes)
+ nomsSources=self.dictGroupes['ordreDomaineJdC']
+ nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
+ if self.debug: print"nomsSources=%s" %nomsSources
+ for nom in nomsSources:
+ if self.debug: print "nomSource courant=",nom
+ if self.dictGroupes[nom].has_key('SOURCE'):
+ if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ else:
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
+ strand = self.dictGroupes[nom]['STRAND']
+ if self.debug: print "un seul morceau : nomStrand courant=", strand
+ self.texteCarmel3D_INGEND2+= self.dictStrand[strand]
+ if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
+ listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
+ for strand in listeStrand:
+ #strand = strand.replace("'", "") # suppression des guillemets simples
+ if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
+ if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
+ self.texteCarmel3D_INGEND2+= self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
+
+ def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
+ if self.debug:
+ print "self.dictSourceEport=", self.dictSourceEport
+ print "self.dictSourceHport=", self.dictSourceHport
+ nomsSources=self.dictGroupes['ordreDomaineJdC']
+ nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
+
+ for nom in nomsSources:
+ port=self.dictGroupes[nom]['SOURCE']
+ if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ port=self.dictGroupes[nom]['SOURCE']
+
+ if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
+ if self.dictPort[port]['EPORT']=="VOLTAGE":
+ self.texteCarmel3D_INGEND2+= "\n1"
+ else:
+ self.texteCarmel3D_INGEND2+= "\n2"
+ if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
+ if self.dictPort[port]['HPORT']=="VOLTAGE":
+ self.texteCarmel3D_INGEND2+= "\n1"
+ else:
+ self.texteCarmel3D_INGEND2+= "\n2"
+
+#-------------------------------------
+# Methodes 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_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': 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 : %s" % nbformate
+ return nbformate
+
+ def nomReelGroupe(self, nom, typeBloc=None):
+ """Calcule et retourne le nom reel du groupe de maillage donne en entree,
+ en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
+ de bloc du fichier PHYS specifie.
+ Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
+ """
+ from string import join
+ if self.debug:
+ print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
+ {'nom': nom, 'use_prefix': str(usePrefix)}
+ nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
+ if usePrefix:
+ # suppression du prefixe si present
+ partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
+ # les tests suivants ne generent une erreur que si le prefixe est obligatoire
+ if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
+ print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
+ indiquant le type de materiau ou de source associee", nom)
+ elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
+ print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
+ else:
+ # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
+ if typeBloc is not None:
+ if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
+ print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
+ elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
+ print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
+ le prefixe correct pour etre associe a un type %(type_bloc)s", \
+ {'nom': nom, 'type_bloc': str(typeBloc)})
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ if self.debug:
+ print "... %s", nomReel
+ return nomReel
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 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 xml.etree.cElementTree as ET
+import traceback
+import types,string,re,os
+from Extensions.i18n import tr
+from generator_python import PythonGenerator
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
+nomPlugin = 'CARMEL3DTV0'
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : nomPlugin,
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DTV0Generator,
+ }
+
+
+
+class CARMEL3DTV0Generator(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()
+
+ #self.debug = True
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s" % 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() :
+ try :
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)
+ self.generBLOC_VERSION(obj)
+
+ except ValueError, err:
+ raise ValueError(str(err))
+
+ return self.text
+
+
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+ self.texteCarmel3D=""
+ self.texteCarmel3D_SH=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupes = {} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMacroGroupes = {} # macro-groupe et leurs propriétés
+ self.listSymetrie=[]
+ self.dictMouvement= {'ordre':[]} # dictionnaire contenant les mouvements, avec liste incluse pour l'ordre
+ self.nombreMouvements = 0 # nombre de mouvements définis, servant de compteur aussi
+ self.dictMaterial={}
+ self.dictSource={}
+ self.dictStrand={}
+ self.dictGroupeMilieux={"ordreSource":[], "ordreId":[]}
+ self.dictDomaine={}
+ # Parametre du maillage
+ self.identification = ""
+ self.fichierMaillage = ""
+ self.echelleMaillage = ""
+ # Parametre de Precision
+ self.precond=""
+ self.precisionLineaire=""
+ self.kEpsilonDistance=""
+ self.kdistanceRef=""
+ self.nbIterationMax=""
+ self.methodeNonLineaire = ""
+ self.kEpsilonNonLinearite=""
+ self.kCoefficientRelaxation=""
+ self.jauge=""
+ self.NBoucleTemps=""
+ self.dt=""
+ # Paramètres divers
+ self.typeSolveur = "" # type de solveur, linéaire (Solveur_lineaire) ou non-linéaire (Solveur_non_lineaire)
+ #Post traitement
+ self.carteChamp=""
+ self.carteCourantInduit=""
+ self.carteForce=""
+ self.perteJoule=""
+ self.fluxInducteur=""
+ self.courantInducteur=""
+ self.tensionInducteur=""
+ self.energie=""
+ self.ForceCouple=""
+ self.fluxSpire=""
+ self.fluxGroupe=""
+ self.ddpElect=""
+ self.ddpMagn=""
+ self.fluxMagn=""
+ self.fluxJinduitTotal=""
+ self.potFlottant = ""
+
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+
+ def indent(self, elem, level=0, more_sibs=False, espace=4*' '):
+ """Transformation du XML créé par le module interne xml.etree.ElementTree afin d'écrire les indentations et retours à la ligne corrects.
+ D'après un script original de Fredrik Lundh en 2004 (http://effbot.org/zone/element-lib.htm#prettyprint),
+ modifié par Joshua Richardson en 2012 (http://stackoverflow.com/questions/749796/pretty-printing-xml-in-python)
+ et par Loic Chevallier en 2014 (ajout du reglage de l'indentation).
+ L'indentation est de 4 espaces par défaut (cf. argument optionel : espace)
+ Utilisation : self.indent(root), avant écriture dans un fichier de root = ET.Element("configuration") ou de tree = ET.ElementTree(root)
+ où ET = xml.etree.ElementTree
+ """
+ i = "\n"
+ if level:
+ i += (level-1) * espace
+ num_kids = len(elem)
+ if num_kids:
+ if not elem.text or not elem.text.strip():
+ elem.text = i + espace
+ if level:
+ elem.text += espace
+ count = 0
+ for kid in elem:
+ self.indent(kid, level+1, count < num_kids - 1)
+ count += 1
+ if not elem.tail or not elem.tail.strip():
+ elem.tail = i
+ if more_sibs:
+ elem.tail += espace
+ else:
+ if level and (not elem.tail or not elem.tail.strip()):
+ elem.tail = i
+ if more_sibs:
+ elem.tail += espace
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
+
+ file = fn[:fn.rfind(".")] # emplacement du ficher .comm (chemin complet)
+ namefile=os.path.basename(file) # nom du fichier.comm
+ repertory=os.path.dirname(file) # répertoire contenant le fichier .comm (emplacement absolu)
+
+ # correspondances globales
+ correspondance_booleen = {'oui':'true', 'non':'false'}
+
+ fileXML = os.path.join(repertory, 'configuration.xml') # nom du fichier de configuration XML (chemin complet)
+ if self.debug:
+ print "\necriture du fichier XML : ", fileXML
+ print "self.dictMaterial = ",self.dictMaterial
+ print "self.dictSource = ",self.dictSource
+ print "self.dictGroupes = ",self.dictGroupes
+ print "self.dictMacroGroupes = ",self.dictMacroGroupes
+
+ root = ET.Element("configuration")
+
+ #Bloc <Maillage></Maillage>
+ Maillage = ET.SubElement(root, "Maillage")
+ identification = ET.SubElement(Maillage, "identification")
+ identification.text = self.identification
+ fichierMaillage = ET.SubElement(Maillage, "fichierMaillage")
+ fichierMaillage.text = self.fichierMaillage
+ echelleMaillage = ET.SubElement(Maillage, "echelleMaillage")
+ correspondance_echelleMaillage = {"Metre":1.0, "Millimetre":1.0e-3}
+ echelleMaillage.text = "%f" % (correspondance_echelleMaillage[self.echelleMaillage], )
+
+ #Bloc <ParametrePrecision></ParametrePrecision>
+ ParametrePrecision = ET.SubElement(root, "ParametrePrecision")
+ TypeSolveurLineaire = ET.SubElement(ParametrePrecision, "TypeSolveurLineaire")
+ if self.precond=="Crout":
+ TypeSolveurLineaire.text = "1"
+ if self.precond=="Jacobi":
+ TypeSolveurLineaire.text = "2"
+ if self.precond=="MUMPS":
+ TypeSolveurLineaire.text = "3"
+ kEpsilonGCP = ET.SubElement(ParametrePrecision, "kEpsilonGCP")
+ kEpsilonGCP.text = "%s" %(self.kEpsilonGCP)
+ nbIterationMax = ET.SubElement(ParametrePrecision, "nbIterationMax")
+ nbIterationMax.text = "%s" %(self.nbIterationMax)
+ if self.typeSolveur == 'Solveur_non_lineaire': # écriture des paramètres du solveur non-linéaire seulement si défini dans l'étude
+ methodeNonLineaire = ET.SubElement(ParametrePrecision, "methodeNonLineaire")
+ methodeNonLineaire.text = "%s" %(self.methodeNonLineaire)
+ kEpsilonNonLinearite = ET.SubElement(ParametrePrecision, "kEpsilonNonLinearite")
+ kEpsilonNonLinearite.text = "%s" %(self.kEpsilonNonLinearite)
+ kCoefficientRelaxation = ET.SubElement(ParametrePrecision, "kCoefficientRelaxation")
+ kCoefficientRelaxation.text = "%s" %(self.kCoefficientRelaxation)
+ kEpsilonDistance = ET.SubElement(ParametrePrecision, "kEpsilonDistance")
+ kEpsilonDistance.text = "%s" %(self.kEpsilonDistance)
+ kdistanceRef = ET.SubElement(ParametrePrecision, "kdistanceRef")
+ kdistanceRef.text = "%s" %(self.kdistanceRef)
+ jauge = ET.SubElement(ParametrePrecision, "jauge")
+ jauge.text = "%s" %(correspondance_booleen[self.jauge], )
+ NBoucleTemps = ET.SubElement(ParametrePrecision, "NBoucleTemps")
+ NBoucleTemps.text = "%s" %(self.NBoucleTemps)
+ dt = ET.SubElement(ParametrePrecision, "dt")
+ dt.text = "%s" %(self.dt)
+
+ #Bloc <Milieux></Milieux>
+ i=0
+ j=0
+ p=0
+ k=0
+ listeMilieux = [] # liste des milieux, dans l'ordre de création
+ Milieux=ET.SubElement(root, "Milieux") # création du bloc <Milieux>...</Milieux>
+ for nom in self.dictGroupes: # on parcoure tous les groupes MESHGROUP
+ if self.dictGroupes[nom].has_key('MATERIAL') \
+ or self.dictGroupes[nom].has_key('SOURCE') \
+ or self.dictGroupes[nom].has_key('AIMANT') \
+ or self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY') : # si MESHGROUP ou MACRO_GROUPE associé à au moins un matériau, source ou géométrie d'inducteur bobiné, c'est un milieu
+ milieu=ET.SubElement(Milieux,"milieu" ) # création d'un nouveau milieu
+ listeMilieux.append(nom) # mise à jour de la liste des milieux
+ i = i+1 # incrément du numéro de milieu
+ self.dictGroupes[nom]['idMilieu'] = i # affectation de l'id à ce groupe
+ milieu.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ milieu.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+ nomGroupeMaillage = ET.SubElement(milieu, "nomGroupeMaillage") # nom du groupe de maillage
+ nomGroupeMaillage.text = nom
+ if self.dictGroupes[nom].has_key('MATERIAL'): # matériau trouvé pour ce milieu
+ material = self.dictGroupes[nom]['MATERIAL'] # on récupère le nom de la propriété du matériau, clé de self.dictMaterial
+ permeabiliteLineaire=ET.SubElement(milieu, "permeabiliteLineaire")
+ permeabiliteLineaire.text="%s"%(self.dictMaterial[material]["PERMEABILITY"]["VALUE"])
+ if self.dictMaterial[material]["PERMEABILITY"]["LAW"]=="NONLINEAR":
+ coefficientsMarrocco=ET.SubElement(milieu, "coefficientsMarrocco")
+ epsilon = self.dictMaterial[material]["PERMEABILITY"]["EPSILON"]
+ c = self.dictMaterial[material]["PERMEABILITY"]["C"]
+ alpha = self.dictMaterial[material]["PERMEABILITY"]["ALPHA"]
+ tau = self.dictMaterial[material]["PERMEABILITY"]["TAU"]
+ coefficientsMarrocco.text = '%g, %g, %g, %g' % (epsilon, c, alpha, tau)
+ if self.dictMaterial[material].has_key('CONDUCTIVITY'):
+ conductivite=ET.SubElement(milieu, "conductivite")
+ conductivite.text="%s" %(self.dictMaterial[material]["CONDUCTIVITY"]["VALUE"])
+ if self.dictMaterial[material].has_key('AIMANT'):
+ norme=ET.SubElement(milieu, "norme")
+ norme.text="%s" %(self.dictMaterial[material]["AIMANT"]["VALUE"])
+ if self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY'): # géométrie d'inducteur bobiné trouvée pour ce milieu
+ strand=self.dictGroupes[nom]['STRANDED_INDUCTOR_GEOMETRY'] # on récupère le nom de la géométrie d'inducteur bobiné, clé de self.dictStrand
+ axe = ET.SubElement(milieu, "axe")
+ axe.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Direction"]))
+ if self.dictStrand[strand]["Forme"]=="Circulaire":
+ coordonneesPolaires=ET.SubElement(milieu, "coordonneesPolaires")
+ coordonneesPolaires.text="true"
+ origineReperePolaire=ET.SubElement(milieu, "origineReperePolaire")
+ origineReperePolaire.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Centre"]))
+ section=ET.SubElement(milieu, "section")
+ section.text="%g" %(self.dictStrand[strand]["Section"], )
+ if self.dictGroupes[nom].has_key('SOURCE'): # source trouvée pour ce milieu
+ Source = self.dictGroupes[nom]['SOURCE'] # on récupère le nom de la source, clé de self.dictSource
+ self.dictSource[Source]['milieux'].append(nom) # ajout du nom du groupe à cette source
+ if self.dictSource[Source].has_key('STRANDED_INDUCTOR'):
+ nbSpires=ET.SubElement(milieu, "nbSpires")
+ nbSpires.text="%g" %(self.dictSource[Source]["STRANDED_INDUCTOR"]["NTURNS"])
+
+ #Bloc <ConditionsLimitesChamps>...</ConditionsLimitesChamps>
+ ConditionsLimitesChamps = ET.SubElement(root, "ConditionsLimitesChamps")
+ for nomCondition in self.dictGroupes:
+ if self.dictGroupes[nomCondition].has_key('CONDITION_LIMITE'): # condition aux limites associée à ce groupe, hors symétrie et mouvement
+ if self.dictGroupes[nomCondition].has_key('LISTE'): # MACRO_GROUPE
+ for i in range(len(self.dictGroupes[nomCondition]['LISTE'])):
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(self.dictGroupes[nomCondition]['LISTE'][i])
+ else: # MESHGROUP
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(nomCondition)
+
+ for i in range(len(self.listSymetrie)): # symétries, définies dans le bloc des conditions aux limites
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamp")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text="%s" %(self.listSymetrie[i]["Type"])
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(self.listSymetrie[i]["Face1"])
+ if 'Face2' in self.listSymetrie[i] :
+ GroupeNoeud2=ET.SubElement(conditionLimite, "groupeNoeud2")
+ GroupeNoeud2.text="%s" %(self.listSymetrie[i]["Face2"])
+ if 'Mouvement_associe' in self.listSymetrie[i]:
+ MouvementAssocie=ET.SubElement(conditionLimite, "mouvementAssocie")
+ nomMouvementAssocie = self.listSymetrie[i]['Mouvement_associe'].nom # on récupère le nom du mouvement associé, car on a stocké le concept tout entier
+ MouvementAssocie.text="%i"%(self.dictMouvement[nomMouvementAssocie]['ordre'], )
+ if 'Groupe_Points' in self.listSymetrie[i] :
+ GroupePoints=ET.SubElement(conditionLimite, "groupePoints")
+ GroupePoints.text="%s" %(self.listSymetrie[i]['Groupe_Points'])
+
+ #Bloc <TermeSourceElectrique>...</TermeSourceElectrique>
+ TermeSourceElectrique=ET.SubElement(root, "TermeSourceElectrique")
+ i=0 # ?
+ if self.debug: print 'self.dictSource = ', self.dictSource
+ for source in self.dictSource.keys(): # parcours des sources
+ if len(self.dictSource[source]['milieux']) > 0: # on continue si au moins un groupe de maillage, i.e., milieux est associé à cette source
+ if self.dictSource[source].has_key('STRANDED_INDUCTOR'): # inducteur bobiné
+ inducteur=ET.SubElement(TermeSourceElectrique, "inducteur")
+ listeMilieux=ET.SubElement(inducteur, "listeMilieux") # création de la liste des milieux
+ idListeMilieux = [] # indices des milieux concernés
+ for milieu in self.dictSource[source]['milieux']: # construction de la liste des milieux
+ idListeMilieux.append(self.dictGroupes[milieu]['idMilieu'])
+ listeMilieux.text = "%s" % ','.join(map(str,idListeMilieux))
+ if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="CURRENT": # source de type courant imposé
+ couplageTension=ET.SubElement(inducteur, "couplageTension")
+ couplageTension.text = "false"
+ courant=ET.SubElement(inducteur, "courant")
+ if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
+ courant.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
+ if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
+ amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
+ frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
+ phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
+ courant.text="%g, %g, %g" % (amplitude, frequence, phase)
+ courant.set('forme', 'sinus') # attribut forme="sinus"
+ if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="VOLTAGE": # source de type tension imposée
+ couplageTension=ET.SubElement(inducteur, "couplageTension")
+ couplageTension.text = "true"
+ tension=ET.SubElement(inducteur, "tension")
+ if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
+ tension.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
+ if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
+ amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
+ frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
+ phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
+ tension.text="%g, %g, %g" % (amplitude, frequence, phase)
+ tension.set('forme', 'sinus') # attribut forme="sinus"
+ if self.dictSource[source]["STRANDED_INDUCTOR"].has_key('Resistance'):
+ resistance=ET.SubElement(inducteur, "resistance")
+ resistance.text="%g" %(self.dictSource[source]["STRANDED_INDUCTOR"]['Resistance'])
+
+ #definir Terme Source Magnetique
+ #definirTermeSourceMagnetique=ET.SubElement(root, "definirTermeSourceMagnetique")
+ #nombreTermeSourceMagnetique=ET.SubElement(definirTermeSourceMagnetique, "nombreTermeSourceMagnetique")
+ #nombreTermeSourceMagnetique.text="0"
+
+ #definir Aimants
+ #definirAimants=ET.SubElement(root, "definirAimants")
+ #nombreAimants=ET.SubElement(definirAimants, "nombreAimants")
+ #nombreAimants.text="0"
+
+ #Bloc <Mouvements>...</Mouvements>
+ i = 0
+ Mouvements=ET.SubElement(root, "Mouvements")
+ for nom in self.dictMouvement['ordre']: # parcours de la liste des noms de mouvement définis, dans l'ordre
+ i = i+1
+ mouvement = ET.SubElement(Mouvements, "mouvement") # création de ce mouvement
+ mouvement.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ mouvement.set("name", nom ) # ajout de l'attribut name, inutilisé
+ milieuGlissement = ET.SubElement(mouvement, "milieuGlissement")
+ nomMilieuGlissement = self.dictMouvement[nom]['valeurs']['Milieu_glissement'].nom # concept stocké -> nom du concept
+ milieuGlissement.text="%i" % (self.dictGroupes[nomMilieuGlissement]['idMilieu'], ) # numéro du milieu défini par son nom, selon tableaux remplis précédemment
+ surfaceGlissement = ET.SubElement(mouvement, "surfaceGlissement")
+ surfaceGlissement.text= self.dictMouvement[nom]['valeurs']['Surface_glissement'].nom # concept stocké -> nom du concept
+ deltaMaillage = ET.SubElement(mouvement, "deltaMaillage")
+ deltaMaillage.text="%g" % (self.dictMouvement[nom]['valeurs']['Delta_maillage'], )
+ nbPermutPas = ET.SubElement(mouvement, "nbPermutPas")
+ nbPermutPas.text="%i" % (self.dictMouvement[nom]['valeurs']['Nombre_pas_permutation'], )
+ axeRotation = ET.SubElement(mouvement, "axeRotation")
+ axeRotation.text= self.dictMouvement[nom]['valeurs']['Axe_rotation']
+
+ #definir Force Couple
+ #definirForceCouple=ET.SubElement(root, "definirForceCouple")
+ #nombreForceCouple=ET.SubElement(definirForceCouple, "nombreForceCouple")
+ #nombreForceCouple.text="0"
+
+ #bloc <SpiresExploratrices></SpiresExploratrices>
+ i = 0 # compteur de spires
+ spiresExploratrices = False # pas de spires exploratrices a priori
+ for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
+ spiresExploratrices = True
+ if spiresExploratrices: # on a trouvé au moins une spire exploratrice
+ SpiresExploratrices=ET.SubElement(root, "SpiresExploratrices") # création du bloc XML adéquat
+ for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
+ spire = ET.SubElement(SpiresExploratrices, "spireExploratrice") # création du bloc XML pour cette spire
+ spire.text = nom # le nom du groupe de noeud est directement écrit
+ i = i+1 # incrément du numéro de spire
+ spire.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ spire.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+
+ #bloc <PotentielsFlottants></PotentielsFlottants>
+ i = 0 # compteur de potentiels flottants
+ potentielsFlottants = False # pas de potentiel flottant a priori
+ for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
+ potentielsFlottants = True
+ if potentielsFlottants: # on a trouvé au moins un potentiel flottant
+ PotentielsFlottants=ET.SubElement(root, "PotentielsFlottants") # création du bloc XML adéquat
+ for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
+ potentielFlottant = ET.SubElement(PotentielsFlottants, "potentielFlottant") # création du bloc XML pour ce potentiel flottant
+ potentielFlottant.text = nom # le nom du groupe de noeud est directement écrit
+ i = i+1 # incrément du numéro de spire
+ potentielFlottant.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ potentielFlottant.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+
+
+ #Definir Post traitement
+ postraitement=ET.SubElement(root, "postraitement")
+ carteChamp=ET.SubElement(postraitement, "carteChamp")
+ if type(self.carteChamp)==float:
+ carteChamp.text="%s" %(self.carteChamp)
+ else: carteChamp.text="%s" % ','.join(map(str,self.carteChamp))
+ carteCourantInduit=ET.SubElement(postraitement, "carteCourantInduit")
+ if type(self.carteCourantInduit)==float:
+ carteCourantInduit.text="%s" %(self.carteCourantInduit)
+ else: carteCourantInduit.text="%s" % ','.join(map(str,self.carteCourantInduit))
+ carteForce=ET.SubElement(postraitement, "carteForce")
+ if type(self.carteForce)==float:
+ carteForce.text="%s" %(self.carteForce)
+ else: carteForce.text="%s" % ','.join(map(str,self.carteForce))
+ perteJoule=ET.SubElement(postraitement, "perteJoule")
+ perteJoule.text="%s" %(correspondance_booleen[self.perteJoule])
+ fluxInducteur=ET.SubElement(postraitement, "fluxInducteur")
+ fluxInducteur.text="%s" %(correspondance_booleen[self.fluxInducteur])
+ courantInducteur=ET.SubElement(postraitement, "courantInducteur")
+ courantInducteur.text="%s" %(correspondance_booleen[self.courantInducteur])
+ tensionInducteur=ET.SubElement(postraitement, "tensionInducteur")
+ tensionInducteur.text="%s" %(correspondance_booleen[self.tensionInducteur])
+ energie=ET.SubElement(postraitement, "energie")
+ energie.text="%s" %(correspondance_booleen[self.energie])
+ ForceCouple=ET.SubElement(postraitement, "ForceCouple")
+ ForceCouple.text="%s" %(correspondance_booleen[self.ForceCouple])
+ fluxSpire=ET.SubElement(postraitement, "fluxSpire")
+ fluxSpire.text="%s" %(correspondance_booleen[self.fluxSpire])
+ fluxGroupe=ET.SubElement(postraitement, "fluxGroupe")
+ fluxGroupe.text="%s" %(correspondance_booleen[self.fluxGroupe])
+ ddpElect=ET.SubElement(postraitement, "ddpElect")
+ ddpElect.text="%s" %(correspondance_booleen[self.ddpElect])
+ ddpMagn=ET.SubElement(postraitement, "ddpMagn")
+ ddpMagn.text="%s" %(correspondance_booleen[self.ddpMagn])
+ fluxMagn=ET.SubElement(postraitement, "fluxMagn")
+ fluxMagn.text="%s" %(correspondance_booleen[self.fluxMagn])
+ fluxJinduitTotal=ET.SubElement(postraitement, "fluxJinduitTotal")
+ fluxJinduitTotal.text="%s" %(correspondance_booleen[self.fluxJinduitTotal])
+ potentielFlottant=ET.SubElement(postraitement, "potFlottant")
+ potentielFlottant.text="%s" %(correspondance_booleen[self.potFlottant])
+
+ self.indent(root) # indentations et retours à la ligne, à l'aide d'une fonction maison, car xml.etree.ElementTree ne sait pas faire et le module lxml n'est pas disponible dans Salomé
+
+ tree = ET.ElementTree(root)
+
+ tree.write(fileXML, encoding="UTF-8")
+
+ # print "le dico complet=%s" %(self.dictGroupes)
+
+ if self.debug:
+ print "ecriture du fichier d'execution (SH)"
+ RepCarmel=os.path.join(repertory,"lancer.sh")
+ f = open( RepCarmel, 'wb')
+ self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
+ self.texteCarmel3D_SH+='./carmel << FIN\n'
+ correspondance_resolution = {"(T-)Omega seulement":"1\n","A(-Phi) seulement":"2\n", "(T-)Omega puis A(-Phi)":"1\n2\n", "A(-Phi) puis (T-)Omega":"2\n1\n"}
+ self.texteCarmel3D_SH+= correspondance_resolution[self.formulation]
+ self.texteCarmel3D_SH+='0\nFIN\n'
+ f.write(self.texteCarmel3D_SH)
+ f.close()
+
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": 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 %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
+ if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
+ if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
+ if obj.nom=="SYMETRIE" : self.generBLOC_SYMETRIE(obj)
+ if obj.nom=="POST_TRAITEMENT" : self.generPOST_TRAITEMENT(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 = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
+ if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
+ if obj.nom=="MOUVEMENT" : self.generMOUVEMENT(obj)
+ s=PythonGenerator.generETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ """Utilisé par INCLUDE"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins[nomPlugin]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s" % jdc_aux_texte
+
+ # sauvegarde de tous les matériaux trouvés dans les bibliothèques INCLUDE
+ for cle in monGenerateur.dictMaterial:
+ self.dictMaterial[cle] = monGenerateur.dictMaterial[cle]
+ # sauvegarde de toutes les sources trouvées dans les bibliothèques INCLUDE
+ for cle in monGenerateur.dictSource:
+ self.dictSource[cle] = monGenerateur.dictSource[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(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:
+ nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+
+ # on utilise le fait que obj.valeur est un dictionnaire
+ self.dictGroupes[nomGroupe] = {}
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ #if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ # raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['STRANDED_INDUCTOR_GEOMETRY'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ if 'CONDITION_LIMITE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['CONDITION_LIMITE'] = obj.valeur['CONDITION_LIMITE']
+ # self.dictGroupes['ordreConditionJdC'].append(nomGroupe)
+ if 'Domaine' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ # self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.get_sdname()]=texte
+ print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
+ if 'Potentiel_Flottant' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['Potentiel_Flottant'] = True
+ if 'Spire_Exploratrice' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['Spire_Exploratrice'] = True
+
+# else:
+# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMACRO_GROUPE(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 macros groupes
+ """
+ try:
+ nomMacroGroupe = obj.get_sdname() # nom du macro groupe
+ print "liste des noms sans prefixes %s" %(nomMacroGroupe)
+ self.dictMacroGroupes[nomMacroGroupe] = obj.valeur # sauvegarde des propriétés du macro-groupe
+
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ # association a une source
+ if 'LISTE_MESHGROUP' in obj.valeur.keys(): # test de liste définie dans la macro-groupe, sinon erreur
+ listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictMacroGroupes[nomMacroGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
+ groupe = groupe.replace("'", "") # suppression des guillement simples
+ groupe = groupe.replace('"', "") # suppression des guillement doubles
+ self.dictMacroGroupes[nomMacroGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
+ else:
+ raise ValueError, tr("Ce MACRO_GROUPE %s doit contenir une liste de groupes LISTE_MESHGROUP." % nomMacroGroupe)
+
+ for nomGroupe in self.dictMacroGroupes[nomMacroGroupe]['LISTE']: # liste des groupes MESHGROUP de ce macro-groupe. On leur associe les propriétés du MACRO_GROUPE
+ for propriete in ('SOURCE', 'MATERIAL', 'STRANDED_INDUCTOR_GEOMETRY'): # liste des propriétés automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
+ if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
+ if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete].nom: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
+ print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
+ raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe ))
+ else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
+ self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete].nom # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
+ for propriete in ('CONDITION_LIMITE', ): # liste des propriétés définies à l'avance automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
+ if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
+ if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete]: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
+ print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
+ raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe ))
+ else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
+ self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete] # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
+ except ValueError, err:
+ raise ValueError, str(err)
+
+
+ def generSOLVEUR(self, obj):
+ if self.debug:
+ print "generation solveur obj.valeur = %s" % obj.valeur
+ try :
+ self.typeSolveur = obj.valeur['Type']
+ if self.typeSolveur == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
+ if self.typeSolveur == "Solveur_non_lineaire" :
+ self.generSOLVEUR_LINEAIRE(obj)
+ self.generSOLVEUR_NON_LINEAIRE(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOLVEUR_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Methode_lineaire']
+ if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
+ if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMETHODE_ITERATIVE_BICGCR(self, obj):
+ if self.debug:
+ print "generation methode iterative BICGCR obj.valeur = %s" % obj.valeur
+ self.kEpsilonGCP = obj.valeur["Precision"]
+ self.precond=obj.valeur["Preconditionneur"]
+ self.nbIterationMax=obj.valeur["Nombre_iterations_max"]
+
+
+ def generMETHODE_DIRECTE_MUMPS(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________directe_____________"
+
+ def generSOLVEUR_NON_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation solveur_non_lineaire obj.valeur = %s" % obj.valeur
+ correspondance_methodeNonLineaire = {"Methode de Newton":2,"Methode de substitution":1} # correspondance sur la méthode non-linéaire entre le catalogue et le XML
+ self.methodeNonLineaire = correspondance_methodeNonLineaire[obj.valeur["Methode_non_lineaire"]]
+ self.kEpsilonNonLinearite=obj.valeur["PrecisionNonLineaire"]
+ self.kCoefficientRelaxation=obj.valeur["Coefficient_de_Relaxation"]
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nomMaterial = obj.get_sdname()
+ self.dictMaterial[nomMaterial]=obj.valeur
+ print"self.dictMaterial=%s" %(self.dictMaterial)
+ except ValueError, err:
+ raise ValueError, str(err)
+#-------------------------------------------------------------------
+
+ def generSOURCE(self,obj):
+ """preparation du bloc correspondant a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s" % obj.valeur
+ texte=""
+ try :
+ nomSource = obj.get_sdname()
+ self.dictSource[nomSource]=obj.valeur # dictionnaire
+ self.dictSource[nomSource]['milieux'] = [] # liste ordonnée des groupes associés à cette source
+ print"mon dico des sources=%s" %(self.dictSource)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generPOST_COMMANDS(self, obj):
+ if self.debug:
+ print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
+
+
+
+ self.visu = False
+ self.post_global = False
+ if obj.valeur.has_key('GLOBAL'):
+ self.post_global = True
+ if obj.valeur.has_key('VISU'):
+ self.visu = True
+ self.visu_format=obj.valeur["VISU"]["VISU_Format"]
+ # self.visu_type=obj.valeur["VISU"]["VISU_Type"]
+
+
+#---------------------------------------------------------------------------------------
+# 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)
+ #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
+ #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
+
+
+ def generBLOC_PARAMETERS(self,obj):
+ if self.debug:
+ print "generation parameters obj.valeur = %s" % obj.valeur
+
+ self.identification = obj.valeur["Identification_du_Modele"]
+ self.fichierMaillage = obj.valeur["Fichier_maillage"]
+ self.echelleMaillage = obj.valeur["Echelle_du_maillage"]
+
+ self.kEpsilonDistance=obj.valeur["kEpsilonDistance"]
+ self.kdistanceRef=obj.valeur["kdistanceRef"]
+ self.jauge=obj.valeur["Jauge"]
+ self.NBoucleTemps=obj.valeur["Nb_pas_de_temps"]
+ self.dt=obj.valeur["Pas_de_temps"]
+
+ self.repertory=obj.valeur["RepCarmel"]
+ self.fcarmel=obj.valeur["Resoudre_probleme"]
+ self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
+ self.formulation=obj.valeur["Formulation"]
+
+ def generBLOC_SYMETRIE(self, obj):
+ if self.debug:
+ print "generation de la symetrie obj.valeur = %s" % obj.valeur
+
+ try:
+ self.listSymetrie.append(obj.valeur)
+ print"ma liste symetrie =%s" %(self.listSymetrie)
+ except ValueError, err:
+ raise ValueError, str(err)
+#----------------------------------------------------------------------------------------
+
+ def generMOUVEMENT(self, obj):
+ if self.debug:
+ print "generation du mouvement obj.valeur = %s" % obj.valeur
+
+ try:
+ nom = obj.get_sdname()
+ self.nombreMouvements = self.nombreMouvements+1
+ self.dictMouvement[nom] = {'ordre': self.nombreMouvements, 'valeurs': obj.valeur}
+ self.dictMouvement['ordre'].append(nom)
+ if self.debug:
+ print "self.dictMouvement =%s" %(self.dictMouvement)
+ print "self.nombreMouvements =%i" %(self.nombreMouvements)
+ except ValueError, err:
+ raise valueError, str(err)
+#----------------------------------------------------------------------------------------
+ def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
+ """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
+ if self.debug:
+ print "generation strand obj valeur = %s" % obj.valeur
+ try :
+ nomStrand = obj.get_sdname()
+ self.dictStrand[nomStrand]=obj.valeur
+ print"mon dico des stranded inductor geometry=%s" %(self.dictStrand)
+
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generPOST_TRAITEMENT(self, obj):
+ if self.debug:
+ print "generation post traitement obj.valeur = %s" % obj.valeur
+ self.carteChamp=obj.valeur["Cartes_des_champs"]
+ self.carteCourantInduit=obj.valeur["Cartes_des_courants_induits"]
+ self.carteForce=obj.valeur["Cartes_des_forces"]
+ self.perteJoule=obj.valeur["Pertes_Joules"]
+ self.fluxInducteur=obj.valeur["Flux_par_inducteur"]
+ self.courantInducteur=obj.valeur["Courants_par_inducteur"]
+ self.tensionInducteur=obj.valeur["Tensions_par_inducteur"]
+ self.energie=obj.valeur["Energie"]
+ self.ForceCouple=obj.valeur["Forces_et_couple"]
+ self.fluxSpire=obj.valeur["Flux_par_spire"]
+ self.fluxGroupe=obj.valeur["Flux_par_groupe"]
+ self.ddpElect=obj.valeur["Tensions_electriques"]
+ self.ddpMagn=obj.valeur["DDP_magnetiques"]
+ self.fluxMagn=obj.valeur["Flux_magnetiques"]
+ self.fluxJinduitTotal=obj.valeur["Flux_J_induit"]
+ self.potFlottant=obj.valeur["Potentiel_Flottant"]
+
+#-------------------------------------
+# Methodes 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_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': 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 : %s" % nbformate
+ return nbformate
+
+
