generator/generator_CARMEL3D_temporel.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """Ce module contient le plugin generateur de fichier au format  Code_Carmel3D pour EFICAS.
  21 """
  22
  23 import xml.etree.cElementTree as ET
  24 import traceback
  25 import types,string,re,os
  26 from Extensions.i18n import tr
  27 from generator_python import PythonGenerator
  28
  29 # types de problemes
  30 HARMONIC = 'HARMONIC' # probleme frequentiel
  31 TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
  32
  33 # nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
  34 nomPlugin = 'CARMEL3DTV0'
  35
  36 def entryPoint():
  37    """
  38       Retourne les informations necessaires pour le chargeur de plugins
  39       Ces informations sont retournees dans un dictionnaire
  40    """
  41    return {
  42         # Le nom du plugin
  43           'name' : nomPlugin,
  44         # La factory pour creer une instance du plugin
  45           'factory' : CARMEL3DTV0Generator,
  46           }
  47
  48
  49
  50 class CARMEL3DTV0Generator(PythonGenerator):
  51    """
  52       Ce generateur parcourt un objet de type JDC et produit
  53       un texte au format eficas et
  54       un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
  55
  56    """
  57    # Les extensions de fichier permis?
  58    extensions=('.comm',)
  59
  60 #----------------------------------------------------------------------------------------
  61    def gener(self,obj,format='brut',config=None):
  62
  63       self.initDico()
  64
  65       #self.debug = True
  66
  67       # Cette instruction genere le contenu du fichier de commandes (persistance)
  68       self.text=PythonGenerator.gener(self,obj,format)
  69
  70       if self.debug:
  71          print "self.text = %s" % self.text
  72
  73       # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
  74       # si le jdc est valide (sinon cela n a pas de sens)
  75       if obj.isvalid() :
  76            try :
  77              # constitution du bloc VERSION du fichier PHYS (existe toujours)
  78              self.generBLOC_VERSION(obj)
  79
  80            except ValueError, err:
  81              raise ValueError(str(err))
  82
  83       return self.text
  84
  85
  86
  87
  88 #----------------------------------------------------------------------------------------
  89 # initialisations
  90 #----------------------------------------------------------------------------------------
  91
  92    def initDico(self) :
  93       self.texteCarmel3D=""
  94       self.texteCarmel3D_SH=""
  95       self.debug = True # affichage de messages pour deboguage (.true.) ou non
  96       self.dicoEtapeCourant=None
  97       self.dicoMCFACTCourant=None
  98       self.dicoCourant=None
  99       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
 100       self.dictMacroGroupes = {} # macro-groupe et leurs propriétés
 101       self.listSymetrie=[]
 102       self.dictMouvement= {'ordre':[]} # dictionnaire contenant les mouvements, avec liste incluse pour l'ordre
 103       self.nombreMouvements = 0 # nombre de mouvements définis, servant de compteur aussi
 104       self.dictMaterial={}
 105       self.dictSource={}
 106       self.dictStrand={}
 107       self.dictGroupeMilieux={"ordreSource":[], "ordreId":[]}
 108       self.dictDomaine={}
 109       # Parametre du maillage
 110       self.identification = ""
 111       self.fichierMaillage = ""
 112       self.echelleMaillage = ""
 113       # Parametre de Precision
 114       self.precond=""
 115       self.precisionLineaire=""
 116       self.kEpsilonDistance=""
 117       self.kdistanceRef=""
 118       self.nbIterationMax=""
 119       self.methodeNonLineaire = ""
 120       self.kEpsilonNonLinearite=""
 121       self.kCoefficientRelaxation=""
 122       self.jauge=""
 123       self.NBoucleTemps=""
 124       self.dt=""
 125       # Paramètres divers
 126       self.typeSolveur = "" # type de solveur, linéaire (Solveur_lineaire) ou non-linéaire (Solveur_non_lineaire)
 127       #Post traitement
 128       self.carteChamp=""
 129       self.carteCourantInduit=""
 130       self.carteForce=""
 131       self.perteJoule=""
 132       self.fluxInducteur=""
 133       self.courantInducteur=""
 134       self.tensionInducteur=""
 135       self.energie=""
 136       self.ForceCouple=""
 137       self.fluxSpire=""
 138       self.fluxGroupe=""
 139       self.ddpElect=""
 140       self.ddpMagn=""
 141       self.fluxMagn=""
 142       self.fluxJinduitTotal=""
 143       self.potFlottant = ""
 144
 145       # on force le probleme a etre frequentiel, seul possible en l'etat des choses
 146       self.problem = HARMONIC
 147
 148    def indent(self, elem, level=0, more_sibs=False, espace=4*' '):
 149         """Transformation du XML créé par le module interne xml.etree.ElementTree afin d'écrire les indentations et retours à la ligne corrects.
 150         D'après un script original de Fredrik Lundh en 2004 (http://effbot.org/zone/element-lib.htm#prettyprint),
 151         modifié par Joshua Richardson en 2012 (http://stackoverflow.com/questions/749796/pretty-printing-xml-in-python)
 152         et par Loic Chevallier en 2014 (ajout du reglage de l'indentation).
 153         L'indentation est de 4 espaces par défaut (cf. argument optionel : espace)
 154         Utilisation : self.indent(root), avant écriture dans un fichier de root = ET.Element("configuration") ou de tree = ET.ElementTree(root)
 155         où ET = xml.etree.ElementTree
 156         """
 157         i = "\n"
 158         if level:
 159             i += (level-1) * espace
 160         num_kids = len(elem)
 161         if num_kids:
 162             if not elem.text or not elem.text.strip():
 163                 elem.text = i + espace
 164                 if level:
 165                     elem.text += espace
 166             count = 0
 167             for kid in elem:
 168                 self.indent(kid, level+1, count < num_kids - 1)
 169                 count += 1
 170             if not elem.tail or not elem.tail.strip():
 171                 elem.tail = i
 172                 if more_sibs:
 173                     elem.tail += espace
 174         else:
 175             if level and (not elem.tail or not elem.tail.strip()):
 176                 elem.tail = i
 177                 if more_sibs:
 178                     elem.tail += espace
 179
 180 #----------------------------------------------------------------------------------------
 181 # ecriture
 182 #----------------------------------------------------------------------------------------
 183
 184    def writeDefault(self,fn) :
 185         """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
 186
 187         file =  fn[:fn.rfind(".")]  # emplacement du ficher .comm (chemin complet)
 188         namefile=os.path.basename(file) # nom du fichier.comm
 189         repertory=os.path.dirname(file) # répertoire contenant le fichier .comm (emplacement absolu)
 190
 191         # correspondances globales
 192         correspondance_booleen = {'oui':'true', 'non':'false'}
 193
 194         fileXML = os.path.join(repertory, 'configuration.xml') # nom du fichier de configuration XML (chemin complet)
 195         if self.debug:
 196             print "\necriture du fichier XML : ", fileXML
 197             print "self.dictMaterial = ",self.dictMaterial
 198             print "self.dictSource = ",self.dictSource
 199             print "self.dictGroupes = ",self.dictGroupes
 200             print "self.dictMacroGroupes = ",self.dictMacroGroupes
 201
 202         root = ET.Element("configuration")
 203
 204         #Bloc <Maillage></Maillage>
 205         Maillage = ET.SubElement(root, "Maillage")
 206         identification = ET.SubElement(Maillage, "identification")
 207         identification.text = self.identification
 208         fichierMaillage = ET.SubElement(Maillage, "fichierMaillage")
 209         fichierMaillage.text = self.fichierMaillage
 210         echelleMaillage = ET.SubElement(Maillage, "echelleMaillage")
 211         correspondance_echelleMaillage = {"Metre":1.0, "Millimetre":1.0e-3}
 212         echelleMaillage.text = "%f" % (correspondance_echelleMaillage[self.echelleMaillage], )
 213
 214         #Bloc <ParametrePrecision></ParametrePrecision>
 215         ParametrePrecision = ET.SubElement(root, "ParametrePrecision")
 216         TypeSolveurLineaire = ET.SubElement(ParametrePrecision, "TypeSolveurLineaire")
 217         if self.precond=="Crout":
 218             TypeSolveurLineaire.text = "1"
 219         if self.precond=="Jacobi":
 220             TypeSolveurLineaire.text = "2"
 221         if self.precond=="MUMPS":
 222             TypeSolveurLineaire.text = "3"
 223         kEpsilonGCP = ET.SubElement(ParametrePrecision, "kEpsilonGCP")
 224         kEpsilonGCP.text = "%s" %(self.kEpsilonGCP)
 225         nbIterationMax = ET.SubElement(ParametrePrecision, "nbIterationMax")
 226         nbIterationMax.text = "%s" %(self.nbIterationMax)
 227         if self.typeSolveur == 'Solveur_non_lineaire': # écriture des paramètres du solveur non-linéaire seulement si défini dans l'étude
 228             methodeNonLineaire = ET.SubElement(ParametrePrecision, "methodeNonLineaire")
 229             methodeNonLineaire.text = "%s" %(self.methodeNonLineaire)
 230             kEpsilonNonLinearite = ET.SubElement(ParametrePrecision, "kEpsilonNonLinearite")
 231             kEpsilonNonLinearite.text = "%s" %(self.kEpsilonNonLinearite)
 232             kCoefficientRelaxation = ET.SubElement(ParametrePrecision, "kCoefficientRelaxation")
 233             kCoefficientRelaxation.text = "%s" %(self.kCoefficientRelaxation)
 234         kEpsilonDistance = ET.SubElement(ParametrePrecision, "kEpsilonDistance")
 235         kEpsilonDistance.text = "%s" %(self.kEpsilonDistance)
 236         kdistanceRef = ET.SubElement(ParametrePrecision, "kdistanceRef")
 237         kdistanceRef.text = "%s" %(self.kdistanceRef)
 238         jauge = ET.SubElement(ParametrePrecision, "jauge")
 239         jauge.text = "%s" %(correspondance_booleen[self.jauge], )
 240         NBoucleTemps = ET.SubElement(ParametrePrecision, "NBoucleTemps")
 241         NBoucleTemps.text = "%s" %(self.NBoucleTemps)
 242         dt = ET.SubElement(ParametrePrecision, "dt")
 243         dt.text = "%s" %(self.dt)
 244
 245         #Bloc <Milieux></Milieux>
 246         i=0
 247         j=0
 248         p=0
 249         k=0
 250         listeMilieux = [] # liste des milieux,  dans l'ordre de création
 251         Milieux=ET.SubElement(root, "Milieux") # création du bloc <Milieux>...</Milieux>
 252         for nom in self.dictGroupes:  # on parcoure tous les groupes MESHGROUP
 253             if self.dictGroupes[nom].has_key('MATERIAL') \
 254                 or self.dictGroupes[nom].has_key('SOURCE') \
 255                 or self.dictGroupes[nom].has_key('AIMANT') \
 256                 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
 257                 milieu=ET.SubElement(Milieux,"milieu" ) # création d'un nouveau milieu
 258                 listeMilieux.append(nom) # mise à jour de la liste des milieux
 259                 i = i+1 # incrément du  numéro de milieu
 260                 self.dictGroupes[nom]['idMilieu'] = i # affectation de l'id à ce groupe
 261                 milieu.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
 262                 milieu.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
 263                 nomGroupeMaillage = ET.SubElement(milieu, "nomGroupeMaillage") # nom du groupe de maillage
 264                 nomGroupeMaillage.text = nom
 265                 if self.dictGroupes[nom].has_key('MATERIAL'): # matériau trouvé pour ce milieu
 266                     material = self.dictGroupes[nom]['MATERIAL'] # on récupère le nom de la propriété du matériau, clé de self.dictMaterial
 267                     permeabiliteLineaire=ET.SubElement(milieu, "permeabiliteLineaire")
 268                     permeabiliteLineaire.text="%s"%(self.dictMaterial[material]["PERMEABILITY"]["VALUE"])
 269                     if self.dictMaterial[material]["PERMEABILITY"]["LAW"]=="NONLINEAR":
 270                         coefficientsMarrocco=ET.SubElement(milieu, "coefficientsMarrocco")
 271                         epsilon = self.dictMaterial[material]["PERMEABILITY"]["EPSILON"]
 272                         c = self.dictMaterial[material]["PERMEABILITY"]["C"]
 273                         alpha = self.dictMaterial[material]["PERMEABILITY"]["ALPHA"]
 274                         tau = self.dictMaterial[material]["PERMEABILITY"]["TAU"]
 275                         coefficientsMarrocco.text = '%g, %g, %g, %g' % (epsilon,  c,  alpha,  tau)
 276                     if self.dictMaterial[material].has_key('CONDUCTIVITY'):
 277                         conductivite=ET.SubElement(milieu, "conductivite")
 278                         conductivite.text="%s" %(self.dictMaterial[material]["CONDUCTIVITY"]["VALUE"])
 279                     if self.dictMaterial[material].has_key('AIMANT'):
 280                         norme=ET.SubElement(milieu, "norme")
 281                         norme.text="%s" %(self.dictMaterial[material]["AIMANT"]["VALUE"])
 282                 if self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY'): # géométrie d'inducteur bobiné trouvée pour ce milieu
 283                     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
 284                     axe = ET.SubElement(milieu, "axe")
 285                     axe.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Direction"]))
 286                     if self.dictStrand[strand]["Forme"]=="Circulaire":
 287                         coordonneesPolaires=ET.SubElement(milieu, "coordonneesPolaires")
 288                         coordonneesPolaires.text="true"
 289                         origineReperePolaire=ET.SubElement(milieu, "origineReperePolaire")
 290                         origineReperePolaire.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Centre"]))
 291                     section=ET.SubElement(milieu, "section")
 292                     section.text="%g" %(self.dictStrand[strand]["Section"], )
 293                 if self.dictGroupes[nom].has_key('SOURCE'): # source trouvée pour ce milieu
 294                         Source = self.dictGroupes[nom]['SOURCE'] # on récupère le nom de la source, clé de self.dictSource
 295                         self.dictSource[Source]['milieux'].append(nom) # ajout du nom du groupe à cette source
 296                         if self.dictSource[Source].has_key('STRANDED_INDUCTOR'):
 297                             nbSpires=ET.SubElement(milieu, "nbSpires")
 298                             nbSpires.text="%g" %(self.dictSource[Source]["STRANDED_INDUCTOR"]["NTURNS"])
 299
 300         #Bloc <ConditionsLimitesChamps>...</ConditionsLimitesChamps>
 301         ConditionsLimitesChamps = ET.SubElement(root, "ConditionsLimitesChamps")
 302         for nomCondition in self.dictGroupes:
 303             if self.dictGroupes[nomCondition].has_key('CONDITION_LIMITE'): # condition aux limites associée à ce groupe, hors symétrie et mouvement
 304                 if self.dictGroupes[nomCondition].has_key('LISTE'): # MACRO_GROUPE
 305                     for i in range(len(self.dictGroupes[nomCondition]['LISTE'])):
 306                         conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
 307                         Type=ET.SubElement(conditionLimite,"type" )
 308                         Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
 309                         GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
 310                         GroupeNoeud.text="%s" %(self.dictGroupes[nomCondition]['LISTE'][i])
 311                 else: # MESHGROUP
 312                         conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
 313                         Type=ET.SubElement(conditionLimite,"type" )
 314                         Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
 315                         GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
 316                         GroupeNoeud.text="%s" %(nomCondition)
 317
 318         for i in range(len(self.listSymetrie)): # symétries, définies dans le bloc des conditions aux limites
 319             conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamp")
 320             Type=ET.SubElement(conditionLimite,"type" )
 321             Type.text="%s" %(self.listSymetrie[i]["Type"])
 322             GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
 323             GroupeNoeud.text="%s" %(self.listSymetrie[i]["Face1"])
 324             if 'Face2' in self.listSymetrie[i] :
 325                 GroupeNoeud2=ET.SubElement(conditionLimite, "groupeNoeud2")
 326                 GroupeNoeud2.text="%s" %(self.listSymetrie[i]["Face2"])
 327             if 'Mouvement_associe' in self.listSymetrie[i]:
 328                     MouvementAssocie=ET.SubElement(conditionLimite, "mouvementAssocie")
 329                     nomMouvementAssocie = self.listSymetrie[i]['Mouvement_associe'].nom # on récupère le nom du mouvement associé, car on a stocké le concept tout entier
 330                     MouvementAssocie.text="%i"%(self.dictMouvement[nomMouvementAssocie]['ordre'], )
 331             if 'Groupe_Points' in self.listSymetrie[i] :
 332                     GroupePoints=ET.SubElement(conditionLimite, "groupePoints")
 333                     GroupePoints.text="%s" %(self.listSymetrie[i]['Groupe_Points'])
 334
 335         #Bloc <TermeSourceElectrique>...</TermeSourceElectrique>
 336         TermeSourceElectrique=ET.SubElement(root, "TermeSourceElectrique")
 337         i=0 # ?
 338         if self.debug: print 'self.dictSource = ',  self.dictSource
 339         for source in self.dictSource.keys(): # parcours des sources
 340             if len(self.dictSource[source]['milieux']) > 0: # on continue si au moins un groupe de maillage, i.e., milieux est associé à cette source
 341                 if self.dictSource[source].has_key('STRANDED_INDUCTOR'): # inducteur bobiné
 342                     inducteur=ET.SubElement(TermeSourceElectrique, "inducteur")
 343                     listeMilieux=ET.SubElement(inducteur, "listeMilieux") # création de la liste des milieux
 344                     idListeMilieux = [] # indices des milieux concernés
 345                     for milieu in self.dictSource[source]['milieux']: # construction de la liste des milieux
 346                         idListeMilieux.append(self.dictGroupes[milieu]['idMilieu'])
 347                     listeMilieux.text = "%s" % ','.join(map(str,idListeMilieux))
 348                     if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="CURRENT": # source de type courant imposé
 349                         couplageTension=ET.SubElement(inducteur, "couplageTension")
 350                         couplageTension.text = "false"
 351                         courant=ET.SubElement(inducteur, "courant")
 352                         if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
 353                             courant.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
 354                         if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
 355                             amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
 356                             frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
 357                             phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
 358                             courant.text="%g, %g, %g" % (amplitude,  frequence,  phase)
 359                             courant.set('forme', 'sinus') # attribut forme="sinus"
 360                     if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="VOLTAGE": # source de type tension imposée
 361                         couplageTension=ET.SubElement(inducteur, "couplageTension")
 362                         couplageTension.text = "true"
 363                         tension=ET.SubElement(inducteur, "tension")
 364                         if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
 365                             tension.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
 366                         if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
 367                             amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
 368                             frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
 369                             phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
 370                             tension.text="%g, %g, %g" % (amplitude,  frequence,  phase)
 371                             tension.set('forme', 'sinus') # attribut forme="sinus"
 372                         if self.dictSource[source]["STRANDED_INDUCTOR"].has_key('Resistance'):
 373                             resistance=ET.SubElement(inducteur, "resistance")
 374                             resistance.text="%g" %(self.dictSource[source]["STRANDED_INDUCTOR"]['Resistance'])
 375
 376         #definir Terme Source Magnetique
 377         #definirTermeSourceMagnetique=ET.SubElement(root, "definirTermeSourceMagnetique")
 378         #nombreTermeSourceMagnetique=ET.SubElement(definirTermeSourceMagnetique, "nombreTermeSourceMagnetique")
 379         #nombreTermeSourceMagnetique.text="0"
 380
 381         #definir Aimants
 382         #definirAimants=ET.SubElement(root, "definirAimants")
 383         #nombreAimants=ET.SubElement(definirAimants, "nombreAimants")
 384         #nombreAimants.text="0"
 385
 386         #Bloc <Mouvements>...</Mouvements>
 387         i = 0
 388         Mouvements=ET.SubElement(root, "Mouvements")
 389         for nom in self.dictMouvement['ordre']: # parcours de la liste des noms de mouvement définis, dans l'ordre
 390             i = i+1
 391             mouvement = ET.SubElement(Mouvements, "mouvement") # création de ce mouvement
 392             mouvement.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
 393             mouvement.set("name", nom ) # ajout de l'attribut name, inutilisé
 394             milieuGlissement = ET.SubElement(mouvement, "milieuGlissement")
 395             nomMilieuGlissement = self.dictMouvement[nom]['valeurs']['Milieu_glissement'].nom  # concept stocké -> nom du concept
 396             milieuGlissement.text="%i" % (self.dictGroupes[nomMilieuGlissement]['idMilieu'], ) # numéro du milieu défini par son nom, selon tableaux remplis précédemment
 397             surfaceGlissement = ET.SubElement(mouvement, "surfaceGlissement")
 398             surfaceGlissement.text= self.dictMouvement[nom]['valeurs']['Surface_glissement'].nom # concept stocké -> nom du concept
 399             deltaMaillage = ET.SubElement(mouvement, "deltaMaillage")
 400             deltaMaillage.text="%g" % (self.dictMouvement[nom]['valeurs']['Delta_maillage'], )
 401             nbPermutPas = ET.SubElement(mouvement, "nbPermutPas")
 402             nbPermutPas.text="%i" % (self.dictMouvement[nom]['valeurs']['Nombre_pas_permutation'], )
 403             axeRotation = ET.SubElement(mouvement, "axeRotation")
 404             axeRotation.text= self.dictMouvement[nom]['valeurs']['Axe_rotation']
 405
 406         #definir Force Couple
 407         #definirForceCouple=ET.SubElement(root, "definirForceCouple")
 408         #nombreForceCouple=ET.SubElement(definirForceCouple, "nombreForceCouple")
 409         #nombreForceCouple.text="0"
 410
 411         #bloc <SpiresExploratrices></SpiresExploratrices>
 412         i = 0 # compteur de spires
 413         spiresExploratrices = False # pas de spires exploratrices a priori
 414         for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
 415             if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
 416                 spiresExploratrices  = True
 417         if spiresExploratrices: # on a trouvé au moins une spire exploratrice
 418             SpiresExploratrices=ET.SubElement(root, "SpiresExploratrices") # création du bloc XML adéquat
 419         for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
 420             if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
 421                 spire = ET.SubElement(SpiresExploratrices, "spireExploratrice") # création du bloc XML pour cette spire
 422                 spire.text = nom # le nom du groupe de noeud est directement écrit
 423                 i = i+1 # incrément du  numéro de spire
 424                 spire.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
 425                 spire.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
 426
 427         #bloc <PotentielsFlottants></PotentielsFlottants>
 428         i = 0 # compteur de potentiels flottants
 429         potentielsFlottants = False # pas de potentiel flottant a priori
 430         for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
 431             if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
 432                 potentielsFlottants  = True
 433         if potentielsFlottants: # on a trouvé au moins un potentiel flottant
 434             PotentielsFlottants=ET.SubElement(root, "PotentielsFlottants") # création du bloc XML adéquat
 435         for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
 436             if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
 437                 potentielFlottant = ET.SubElement(PotentielsFlottants, "potentielFlottant") # création du bloc XML pour ce potentiel flottant
 438                 potentielFlottant.text = nom # le nom du groupe de noeud est directement écrit
 439                 i = i+1 # incrément du  numéro de spire
 440                 potentielFlottant.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
 441                 potentielFlottant.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
 442
 443
 444         #Definir Post traitement
 445         postraitement=ET.SubElement(root, "postraitement")
 446         carteChamp=ET.SubElement(postraitement, "carteChamp")
 447         if type(self.carteChamp)==float:
 448             carteChamp.text="%s" %(self.carteChamp)
 449         else: carteChamp.text="%s" % ','.join(map(str,self.carteChamp))
 450         carteCourantInduit=ET.SubElement(postraitement, "carteCourantInduit")
 451         if type(self.carteCourantInduit)==float:
 452             carteCourantInduit.text="%s" %(self.carteCourantInduit)
 453         else: carteCourantInduit.text="%s" % ','.join(map(str,self.carteCourantInduit))
 454         carteForce=ET.SubElement(postraitement, "carteForce")
 455         if type(self.carteForce)==float:
 456             carteForce.text="%s" %(self.carteForce)
 457         else: carteForce.text="%s" % ','.join(map(str,self.carteForce))
 458         perteJoule=ET.SubElement(postraitement, "perteJoule")
 459         perteJoule.text="%s" %(correspondance_booleen[self.perteJoule])
 460         fluxInducteur=ET.SubElement(postraitement, "fluxInducteur")
 461         fluxInducteur.text="%s" %(correspondance_booleen[self.fluxInducteur])
 462         courantInducteur=ET.SubElement(postraitement, "courantInducteur")
 463         courantInducteur.text="%s" %(correspondance_booleen[self.courantInducteur])
 464         tensionInducteur=ET.SubElement(postraitement, "tensionInducteur")
 465         tensionInducteur.text="%s" %(correspondance_booleen[self.tensionInducteur])
 466         energie=ET.SubElement(postraitement, "energie")
 467         energie.text="%s" %(correspondance_booleen[self.energie])
 468         ForceCouple=ET.SubElement(postraitement, "ForceCouple")
 469         ForceCouple.text="%s" %(correspondance_booleen[self.ForceCouple])
 470         fluxSpire=ET.SubElement(postraitement, "fluxSpire")
 471         fluxSpire.text="%s" %(correspondance_booleen[self.fluxSpire])
 472         fluxGroupe=ET.SubElement(postraitement, "fluxGroupe")
 473         fluxGroupe.text="%s" %(correspondance_booleen[self.fluxGroupe])
 474         ddpElect=ET.SubElement(postraitement, "ddpElect")
 475         ddpElect.text="%s" %(correspondance_booleen[self.ddpElect])
 476         ddpMagn=ET.SubElement(postraitement, "ddpMagn")
 477         ddpMagn.text="%s" %(correspondance_booleen[self.ddpMagn])
 478         fluxMagn=ET.SubElement(postraitement, "fluxMagn")
 479         fluxMagn.text="%s" %(correspondance_booleen[self.fluxMagn])
 480         fluxJinduitTotal=ET.SubElement(postraitement, "fluxJinduitTotal")
 481         fluxJinduitTotal.text="%s" %(correspondance_booleen[self.fluxJinduitTotal])
 482         potentielFlottant=ET.SubElement(postraitement, "potFlottant")
 483         potentielFlottant.text="%s" %(correspondance_booleen[self.potFlottant])
 484
 485         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é
 486
 487         tree = ET.ElementTree(root)
 488
 489         tree.write(fileXML, encoding="UTF-8")
 490
 491        # print "le dico complet=%s" %(self.dictGroupes)
 492
 493         if self.debug:
 494             print "ecriture du fichier d'execution (SH)"
 495         RepCarmel=os.path.join(repertory,"lancer.sh")
 496         f = open( RepCarmel, 'wb')
 497         self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
 498         self.texteCarmel3D_SH+='./carmel << FIN\n'
 499         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"}
 500         self.texteCarmel3D_SH+= correspondance_resolution[self.formulation]
 501         self.texteCarmel3D_SH+='0\nFIN\n'
 502         f.write(self.texteCarmel3D_SH)
 503         f.close()
 504
 505
 506 #----------------------------------------------------------------------------------------
 507 #  analyse de chaque noeud de l'arbre
 508 #----------------------------------------------------------------------------------------
 509
 510    def generMCSIMP(self,obj) :
 511         """recuperation de l objet MCSIMP"""
 512         if self.debug:
 513             print "MCSIMP %(v_1)s  %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
 514         s=PythonGenerator.generMCSIMP(self,obj)
 515         self.dicoCourant[obj.nom]=obj.valeurFormatee
 516         return s
 517
 518
 519 #----------------------------------------------------------------------------------------
 520    def generMCFACT(self,obj) :
 521         """recuperation de l objet MCFACT"""
 522         dico={}
 523         self.dicoMCFACTCourant=dico
 524         self.dicoCourant=self.dicoMCFACTCourant
 525         s=PythonGenerator.generMCFACT(self,obj)
 526         self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
 527         self.dicoMCFACTCourant=None
 528         self.dicoCourant=self.dicoEtapeCourant
 529         return s
 530
 531
 532 #----------------------------------------------------------------------------------------
 533    def generPROC_ETAPE(self,obj):
 534         """analyse des PROC du catalogue  ( VERSION )"""
 535         dico={}
 536         self.dicoEtapeCourant=dico
 537         self.dicoCourant=self.dicoEtapeCourant
 538         s=PythonGenerator.generPROC_ETAPE(self,obj)
 539         obj.valeur=self.dicoEtapeCourant
 540
 541         if self.debug:
 542             print "PROC_ETAPE %(v_1)s  %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
 543         s=PythonGenerator.generPROC_ETAPE(self,obj)
 544         if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
 545         if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
 546         if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
 547         if obj.nom=="SYMETRIE" : self.generBLOC_SYMETRIE(obj)
 548         if obj.nom=="POST_TRAITEMENT" : self.generPOST_TRAITEMENT(obj)
 549         return s
 550
 551
 552
 553 #----------------------------------------------------------------------------------------
 554    def generETAPE(self,obj):
 555         """analyse des OPER du catalogue"""
 556         dico={}
 557         self.dicoEtapeCourant=dico
 558         self.dicoCourant=self.dicoEtapeCourant
 559         s=PythonGenerator.generETAPE(self,obj)
 560         obj.valeur=self.dicoEtapeCourant
 561         if self.debug:
 562             print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
 563         if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
 564         if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
 565         if obj.nom=="SOURCE" : self.generSOURCE(obj)
 566         if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
 567         if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
 568         if obj.nom=="MOUVEMENT" : self.generMOUVEMENT(obj)
 569         s=PythonGenerator.generETAPE(self,obj)
 570         return s
 571
 572 #----------------------------------------------------------------------------------------
 573    def generMACRO_ETAPE(self,obj):
 574         """Utilisé par INCLUDE"""
 575         dico={}
 576         self.dicoEtapeCourant=dico
 577         self.dicoCourant=self.dicoEtapeCourant
 578         import generator
 579         monGenerateur=generator.plugins[nomPlugin]()
 580         jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
 581         if self.debug:
 582             print "jdc_aux_texte : %s" % jdc_aux_texte
 583
 584         # sauvegarde de tous les matériaux trouvés dans les bibliothèques INCLUDE
 585         for cle in monGenerateur.dictMaterial:
 586             self.dictMaterial[cle] = monGenerateur.dictMaterial[cle]
 587         # sauvegarde de toutes les sources trouvées dans les bibliothèques INCLUDE
 588         for cle in monGenerateur.dictSource:
 589             self.dictSource[cle] = monGenerateur.dictSource[cle]
 590
 591         print "________FIN MACRO______________________________________"
 592         s=PythonGenerator.generMACRO_ETAPE(self,obj)
 593         return s
 594
 595 #----------------------------------------------------------------------------------------
 596 #----------------------------------------------------------------------------------------
 597    def generMESHGROUP(self,obj):
 598         """preparation de la ligne NAME referencant le groupe de mailles
 599             associe le groupe de mailles au materiau ou a la source utilisateur
 600             on sauvegarde aussi les noms des groupes de maillage
 601         """
 602         try:
 603             nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
 604             print "liste des noms sans prefixes %s" %(nomGroupe)
 605
 606             # 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.
 607             # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
 608             #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
 609
 610             # on utilise le fait que obj.valeur est un dictionnaire
 611             self.dictGroupes[nomGroupe] = {}
 612             if self.debug:
 613                 print "obj.valeur.keys()= %s" % obj.valeur.keys()
 614             #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
 615             #    raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau  et au moins une source." % nomGroupe)
 616             # association a un materiau
 617             if 'MATERIAL' in obj.valeur.keys():
 618                 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
 619            #     self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
 620             # association a une source
 621             if 'SOURCE' in obj.valeur.keys():
 622                 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
 623             #    self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
 624             # erreur ni materiau ni source associee
 625             if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
 626                     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
 627              #       self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
 628             if 'CONDITION_LIMITE' in obj.valeur.keys():
 629                     self.dictGroupes[nomGroupe]['CONDITION_LIMITE'] = obj.valeur['CONDITION_LIMITE']
 630              #       self.dictGroupes['ordreConditionJdC'].append(nomGroupe)
 631             if 'Domaine' in obj.valeur.keys():
 632                 self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
 633             #    self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
 634                 texte=""
 635                 texte+="%s"%(obj.valeur['Domaine'])
 636                 print"le texte=%s" %(texte)
 637                 self.dictDomaine[obj.get_sdname()]=texte
 638                 print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
 639             if 'Potentiel_Flottant' in obj.valeur.keys():
 640                 self.dictGroupes[nomGroupe]['Potentiel_Flottant'] = True
 641             if 'Spire_Exploratrice' in obj.valeur.keys():
 642                 self.dictGroupes[nomGroupe]['Spire_Exploratrice'] = True
 643
 644 #            else:
 645 #                raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
 646             if self.debug:
 647                 print "self.dictGroupes= %s" % repr(self.dictGroupes)
 648         except ValueError, err:
 649             raise ValueError, str(err)
 650
 651    def generMACRO_GROUPE(self, obj):
 652         """preparation de la ligne NAME referencant le groupe de mailles
 653             associe le groupe de mailles au materiau ou a la source utilisateur
 654             on sauvegarde aussi les noms des macros groupes
 655         """
 656         try:
 657             nomMacroGroupe = obj.get_sdname() # nom du macro groupe
 658             print "liste des noms sans prefixes %s" %(nomMacroGroupe)
 659             self.dictMacroGroupes[nomMacroGroupe] = obj.valeur # sauvegarde des propriétés du macro-groupe
 660
 661             if self.debug:
 662                 print "obj.valeur.keys()= %s" % obj.valeur.keys()
 663             # association a une source
 664             if 'LISTE_MESHGROUP' in obj.valeur.keys(): # test de liste définie dans la macro-groupe, sinon erreur
 665                 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
 666                 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
 667                 for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
 668                     groupe = groupe.replace("'", "") # suppression des guillement simples
 669                     groupe = groupe.replace('"', "") # suppression des guillement doubles
 670                     self.dictMacroGroupes[nomMacroGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
 671             else:
 672                 raise ValueError, tr("Ce MACRO_GROUPE %s doit contenir une liste de groupes LISTE_MESHGROUP." % nomMacroGroupe)
 673
 674             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
 675                 for propriete in ('SOURCE', 'MATERIAL',  'STRANDED_INDUCTOR_GEOMETRY'): # liste des propriétés automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
 676                     if  propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
 677                         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
 678                             print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
 679                              ( propriete, obj.valeur[propriete].nom,  nomMacroGroupe, self.dictGroupes[nomGroupe][propriete],  nomGroupe )
 680                             raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
 681                              ( propriete, obj.valeur[propriete].nom,  nomMacroGroupe, self.dictGroupes[nomGroupe][propriete],  nomGroupe ))
 682                         else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
 683                             self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete].nom # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
 684                 for propriete in ('CONDITION_LIMITE', ): # liste des propriétés définies à l'avance automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
 685                     if  propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
 686                         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
 687                             print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
 688                              ( propriete, obj.valeur[propriete],  nomMacroGroupe, self.dictGroupes[nomGroupe][propriete],  nomGroupe )
 689                             raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
 690                              ( propriete, obj.valeur[propriete],  nomMacroGroupe, self.dictGroupes[nomGroupe][propriete],  nomGroupe ))
 691                         else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
 692                             self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete] # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
 693         except ValueError, err:
 694             raise ValueError, str(err)
 695
 696
 697    def generSOLVEUR(self, obj):
 698         if self.debug:
 699             print "generation solveur obj.valeur = %s" % obj.valeur
 700         try :
 701             self.typeSolveur = obj.valeur['Type']
 702             if self.typeSolveur == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
 703             if self.typeSolveur == "Solveur_non_lineaire" :
 704                 self.generSOLVEUR_LINEAIRE(obj)
 705                 self.generSOLVEUR_NON_LINEAIRE(obj)
 706         except ValueError,  err:
 707             raise ValueError,  str(err)
 708
 709    def generSOLVEUR_LINEAIRE(self, obj):
 710         if self.debug:
 711             print "generation material obj.valeur = %s" % obj.valeur
 712         try :
 713             nature = obj.valeur['Methode_lineaire']
 714             if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
 715             if nature  =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
 716         except ValueError,  err:
 717             raise ValueError,  str(err)
 718
 719    def generMETHODE_ITERATIVE_BICGCR(self, obj):
 720         if self.debug:
 721             print "generation methode iterative BICGCR obj.valeur = %s" % obj.valeur
 722         self.kEpsilonGCP =  obj.valeur["Precision"]
 723         self.precond=obj.valeur["Preconditionneur"]
 724         self.nbIterationMax=obj.valeur["Nombre_iterations_max"]
 725
 726
 727    def generMETHODE_DIRECTE_MUMPS(self, obj):
 728         texte=""
 729         if self.debug:
 730             print "_____________directe_____________"
 731
 732    def generSOLVEUR_NON_LINEAIRE(self, obj):
 733         if self.debug:
 734             print "generation solveur_non_lineaire obj.valeur = %s" % obj.valeur
 735         correspondance_methodeNonLineaire = {"Methode de Newton":2,"Methode de substitution":1} # correspondance sur la méthode non-linéaire entre le catalogue et le XML
 736         self.methodeNonLineaire = correspondance_methodeNonLineaire[obj.valeur["Methode_non_lineaire"]]
 737         self.kEpsilonNonLinearite=obj.valeur["PrecisionNonLineaire"]
 738         self.kCoefficientRelaxation=obj.valeur["Coefficient_de_Relaxation"]
 739
 740    def generMATERIAL(self,obj):
 741         """preparation du bloc correspondant a un materiau du fichier PHYS"""
 742         texte=""
 743         if self.debug:
 744             print "generation material obj.valeur = %s" % obj.valeur
 745         try :
 746             nomMaterial = obj.get_sdname()
 747             self.dictMaterial[nomMaterial]=obj.valeur
 748             print"self.dictMaterial=%s" %(self.dictMaterial)
 749         except ValueError, err:
 750             raise ValueError, str(err)
 751 #-------------------------------------------------------------------
 752
 753    def generSOURCE(self,obj):
 754         """preparation du bloc correspondant a une source du fichier PHYS"""
 755         if self.debug:
 756             print "generation source obj valeur = %s" % obj.valeur
 757         texte=""
 758         try :
 759             nomSource = obj.get_sdname()
 760             self.dictSource[nomSource]=obj.valeur # dictionnaire
 761             self.dictSource[nomSource]['milieux'] = [] # liste ordonnée des groupes associés à cette source
 762             print"mon dico des sources=%s" %(self.dictSource)
 763         except ValueError, err:
 764             raise ValueError, str(err)
 765
 766    def generPOST_COMMANDS(self, obj):
 767         if self.debug:
 768             print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
 769
 770
 771
 772         self.visu = False
 773         self.post_global = False
 774         if obj.valeur.has_key('GLOBAL'):
 775             self.post_global = True
 776         if obj.valeur.has_key('VISU'):
 777             self.visu = True
 778             self.visu_format=obj.valeur["VISU"]["VISU_Format"]
 779          #   self.visu_type=obj.valeur["VISU"]["VISU_Type"]
 780
 781
 782 #---------------------------------------------------------------------------------------
 783 # traitement fichier PHYS
 784 #---------------------------------------------------------------------------------------
 785    def generBLOC_VERSION(self,obj) :
 786       # constitution du bloc VERSION du fichier PHYS
 787       # creation d une entite  VERSION ; elle sera du type PROC car decrit ainsi
 788       # dans le du catalogue
 789       version=obj.addentite('VERSION',pos=None)
 790       self.generPROC_ETAPE(obj.etapes[0])
 791       self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
 792       for cle in obj.etapes[0].valeur :
 793           self.texteCarmel3D+="   "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
 794       self.texteCarmel3D+="]\n"
 795       # destruction de l entite creee
 796       obj.suppentite(version)
 797       #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
 798       #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
 799
 800
 801    def generBLOC_PARAMETERS(self,obj):
 802         if self.debug:
 803             print "generation parameters obj.valeur = %s" % obj.valeur
 804
 805         self.identification = obj.valeur["Identification_du_Modele"]
 806         self.fichierMaillage = obj.valeur["Fichier_maillage"]
 807         self.echelleMaillage = obj.valeur["Echelle_du_maillage"]
 808
 809         self.kEpsilonDistance=obj.valeur["kEpsilonDistance"]
 810         self.kdistanceRef=obj.valeur["kdistanceRef"]
 811         self.jauge=obj.valeur["Jauge"]
 812         self.NBoucleTemps=obj.valeur["Nb_pas_de_temps"]
 813         self.dt=obj.valeur["Pas_de_temps"]
 814
 815         self.repertory=obj.valeur["RepCarmel"]
 816         self.fcarmel=obj.valeur["Resoudre_probleme"]
 817         self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
 818         self.formulation=obj.valeur["Formulation"]
 819
 820    def generBLOC_SYMETRIE(self, obj):
 821         if self.debug:
 822             print "generation de la symetrie obj.valeur = %s" % obj.valeur
 823
 824         try:
 825             self.listSymetrie.append(obj.valeur)
 826             print"ma liste symetrie =%s" %(self.listSymetrie)
 827         except ValueError, err:
 828             raise ValueError, str(err)
 829 #----------------------------------------------------------------------------------------
 830
 831    def generMOUVEMENT(self, obj):
 832         if self.debug:
 833             print "generation du mouvement obj.valeur = %s" % obj.valeur
 834
 835         try:
 836             nom = obj.get_sdname()
 837             self.nombreMouvements = self.nombreMouvements+1
 838             self.dictMouvement[nom] = {'ordre': self.nombreMouvements, 'valeurs': obj.valeur}
 839             self.dictMouvement['ordre'].append(nom)
 840             if self.debug:
 841                 print "self.dictMouvement =%s" %(self.dictMouvement)
 842                 print "self.nombreMouvements =%i" %(self.nombreMouvements)
 843         except ValueError,  err:
 844             raise valueError,  str(err)
 845 #----------------------------------------------------------------------------------------
 846    def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
 847         """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
 848         if self.debug:
 849             print "generation strand obj valeur = %s" % obj.valeur
 850         try :
 851             nomStrand = obj.get_sdname()
 852             self.dictStrand[nomStrand]=obj.valeur
 853             print"mon dico des stranded inductor geometry=%s" %(self.dictStrand)
 854
 855         except ValueError, err:
 856             raise ValueError, str(err)
 857
 858    def generPOST_TRAITEMENT(self, obj):
 859         if self.debug:
 860             print "generation post traitement obj.valeur = %s" % obj.valeur
 861         self.carteChamp=obj.valeur["Cartes_des_champs"]
 862         self.carteCourantInduit=obj.valeur["Cartes_des_courants_induits"]
 863         self.carteForce=obj.valeur["Cartes_des_forces"]
 864         self.perteJoule=obj.valeur["Pertes_Joules"]
 865         self.fluxInducteur=obj.valeur["Flux_par_inducteur"]
 866         self.courantInducteur=obj.valeur["Courants_par_inducteur"]
 867         self.tensionInducteur=obj.valeur["Tensions_par_inducteur"]
 868         self.energie=obj.valeur["Energie"]
 869         self.ForceCouple=obj.valeur["Forces_et_couple"]
 870         self.fluxSpire=obj.valeur["Flux_par_spire"]
 871         self.fluxGroupe=obj.valeur["Flux_par_groupe"]
 872         self.ddpElect=obj.valeur["Tensions_electriques"]
 873         self.ddpMagn=obj.valeur["DDP_magnetiques"]
 874         self.fluxMagn=obj.valeur["Flux_magnetiques"]
 875         self.fluxJinduitTotal=obj.valeur["Flux_J_induit"]
 876         self.potFlottant=obj.valeur["Potentiel_Flottant"]
 877
 878 #-------------------------------------
 879 # Methodes utilitaires
 880 # ------------------------------------
 881    def formateCOMPLEX(self,nbC):
 882         """prise en compte des differentes formes de description d un nombre complexe
 883         3 formats possibles : 2 listes (anciennement tuples?)  et 1 nombre complexe
 884         """
 885         if self.debug:
 886             print "formatage"
 887             print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
 888         nbformate =""
 889         if isinstance(nbC,(tuple,list)):
 890             if nbC[0] == "'RI'" :
 891                 nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
 892             if nbC[0] == "'MP'" :
 893                 nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
 894         else:
 895             nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
 896         if self.debug:
 897             print "nbformate : %s" % nbformate
 898         return nbformate
 899
 900