convert/convert_TELEMAC.py

   1 # Copyright (C) 2007-2013   EDF R&D
   2 #
   3 # This library is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU Lesser General Public
   5 # License as published by the Free Software Foundation; either
   6 # version 2.1 of the License.
   7 #
   8 # This library is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # Lesser General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU Lesser General Public
  14 # License along with this library; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 #
  17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 #
  19 import re, string
  20 from Extensions.i18n import tr
  21
  22
  23 from convert_python import PythonParser
  24
  25 pattern_comment_slash   = re.compile(r"^\s*/")
  26 pattern_eta   = re.compile(r".*&ETA.*")
  27 pattern_fin   = re.compile(r".*&FIN.*")
  28 pattern_oui   = re.compile(r"^\s*(oui|OUI|YES|yes|TRUE|VRAI)\s*$")
  29 pattern_non   = re.compile(r"^\s*(non|NON|NO|no|FALSE|FAUX)\*s$")
  30 pattern_blanc = re.compile(r"^\s*$")
  31 pattern_listeVide = re.compile(r"^\s*'\s*'\s*$")
  32
  33 pattern_ligne=re.compile(r'^\s*(?P<ident>[^=:]*)\s*[:=]\s*(?P<reste>.*)$')
  34
  35 pattern_variables=re.compile (r"^\s*(?P<ident>VARIABLES POUR LES SORTIES GRAPHIQUES)\s*[:=]\s*(?P<valeur>\w(,\w)*)\s*(?P<reste>.*)$")
  36
  37 # Attention aux listes de flottants
  38 pattern_liste=re.compile(r'^\s*(?P<valeur>[+-.\w]+(\s*;\s*[+-.\w]+)+)\s*(?P<reste>.*)$')
  39 pattern_flottant=re.compile(r'^\s*(?P<valeur>[+-]?((\d+(\.\d*)?)|(\.\d+))([dDeE][+-]?\d+)?)\s*(?P<reste>.*)$')
  40 pattern_texteQuote  = re.compile (r"^\s*(?P<valeur>'[^']+(''[^']+)*')\s*(?P<reste>.*)$")
  41 pattern_texteSimple = re.compile (r"(?P<valeur>(^|\s)\s*[\w\.-]+)\s*(?P<reste>.*)$")
  42 pattern_texteVide   = re.compile (r"^\s*(?P<valeur>'')\s*(?P<reste>.*)$")
  43
  44 pattern_ContientDouble=re.compile (r"^.*''.*$")
  45
  46
  47 # le pattern texte reconnait
  48 #nom1 nom 2 : ou = chaine entre '
  49 # avec eventuellement  des quotes au milieu par exemple
  50 # TITRE = 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
  51 # m.group("texte") va rendre 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
  52
  53
  54 #Si le code n est pas Telemac
  55 try :
  56    from aideAuxConvertisseurs import DicoEficasToCas, ListeSupprimeCasToEficas
  57    from aideAuxConvertisseurs import ListeCalculCasToEficas, DicoAvecMajuscules
  58    from enumDicoTelemac       import DicoEnumCasEn
  59 except :
  60    pass
  61
  62 from Extensions import localisation
  63
  64 from determine import monEnvQT5
  65
  66
  67
  68 def entryPoint():
  69    """
  70    Return a dictionary containing the description needed to load the plugin
  71    """
  72    return {
  73           'name' : 'TELEMAC',
  74           'factory' : TELEMACParser
  75           }
  76
  77 class TELEMACParser(PythonParser):
  78    """
  79    This converter works like PythonParser, except that it also initializes all
  80    model variables to None in order to avoid Python syntax errors when loading
  81    a file with a different or inexistent definition of variables.
  82    """
  83
  84    def convert(self, outformat, appli=None):
  85       from Accas import A_BLOC, A_FACT, A_SIMP
  86       self.dicoInverseFrancais=appli.readercata.dicoInverseFrancais
  87       self.dicoAnglaisFrancais=appli.readercata.dicoAnglaisFrancais
  88       self.dicoFrancaisAnglais=appli.readercata.dicoFrancaisAnglais
  89       self.dicoMC=appli.readercata.dicoMC
  90       self.Ordre_Des_Commandes=appli.readercata.Ordre_Des_Commandes
  91
  92
  93       #print self.dicoInverseFrancais
  94       #text = PythonParser.convert(self, outformat, appli)
  95
  96       text=""
  97       l_lignes = string.split(self.text,'\n')
  98       self.dictSimp={}
  99       for ligne in l_lignes :
 100
 101           if pattern_comment_slash.match(ligne) : continue
 102           if pattern_eta.match(ligne) : continue
 103           if pattern_fin.match(ligne) : continue
 104           if pattern_blanc.match(ligne) : continue
 105
 106
 107           finLigne=ligne
 108           while finLigne != "" :
 109               #print finLigne
 110               if pattern_comment_slash.match(finLigne) : finLigne=""; continue
 111               valeur=""
 112               if pattern_variables.match(finLigne) :
 113                  m=pattern_variables.match(finLigne)
 114                  valeur=m.group('valeur')
 115                  simp=self.traiteIdent(m.group('ident'))
 116                  finLigne=m.group('reste')
 117                  self.dictSimp[simp]=valeur
 118                  continue
 119
 120               m=pattern_ligne.match(finLigne)
 121               if m == None :
 122                  #print "________________________________________________"
 123                  print 'pb avec ****', finLigne , '**** dans ', ligne
 124                  #print "________________________________________________"
 125                  break
 126
 127               simp=self.traiteIdent(m.group('ident'))
 128               finLigne=m.group('reste')
 129
 130               # attention, l ordre des if est important
 131               if pattern_liste.match(finLigne) :
 132                  m=pattern_liste.match(finLigne)
 133               elif pattern_texteQuote.match(finLigne) :
 134                  m=pattern_texteQuote.match(finLigne)
 135               elif pattern_flottant.match(finLigne) :
 136                  m=pattern_flottant.match(finLigne)
 137               elif pattern_texteVide.match(finLigne):
 138                  m=pattern_texteVide.match(finLigne)
 139               elif pattern_texteSimple.match(finLigne):
 140                  m=pattern_texteSimple.match(finLigne)
 141               else :
 142                  #print "________________________________________________"
 143                  print 'pb avec ****', finLigne , '**** dans ', ligne
 144                  print "non match"
 145                  #print "________________________________________________"
 146                  break
 147
 148               valeur=m.group('valeur')
 149               if pattern_blanc.match(valeur) : valeur=None
 150
 151               if pattern_flottant.match(finLigne) :
 152                  valeur=re.sub("d","e",valeur)
 153                  valeur=re.sub("D","E",valeur)
 154
 155               if pattern_liste.match(finLigne):
 156                  valeur=valeur.split(";")
 157
 158               finLigne=m.group('reste')
 159               #print simp
 160               #print valeur
 161               #print finLigne
 162               self.dictSimp[simp]=valeur
 163
 164       if 'Title' not in self.dictSimp.keys() and 'Titre' not in self.dictSimp.keys():
 165           import os
 166           self.dictSimp['Titre']=os.path.basename(self.filename)
 167
 168       dicoParMC={}
 169       for simp in self.dictSimp.keys():
 170           #print simp, " : ", self.dictSimp[simp]
 171
 172           if simp in TELEMACParser.__dict__.keys() : apply(TELEMACParser.__dict__[simp],(self,))
 173
 174       for simp in self.dictSimp.keys():
 175           if simp in ListeSupprimeCasToEficas: continue
 176           if simp not in self.dicoInverseFrancais.keys() :
 177              print "************"
 178              print "pb avec dans dicoInverseFrancais", simp,'------'
 179              print "************"
 180              #print poum
 181              continue
 182           listeGenea=self.dicoInverseFrancais[simp]
 183           listeGeneaReverse=[]
 184           for (u,v) in listeGenea :
 185               if isinstance(v,A_BLOC.BLOC): continue
 186               listeGeneaReverse.append(u)
 187           listeGeneaReverse.reverse()
 188           dicoTravail=dicoParMC
 189           i=0
 190           #print (listeGeneaReverse[0:-1])
 191           while i < len(listeGeneaReverse[0:-1]) :
 192             mot=listeGeneaReverse[i]
 193             i=i+1
 194             if mot not in dicoTravail.keys(): dicoTravail[mot]={}
 195             dicoTravail=dicoTravail[mot]
 196           dicoTravail[simp]=self.dictSimp[simp]
 197
 198       self.textePy=""
 199       #print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
 200       #print dicoParMC
 201       #print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
 202       listeMC=self.tri(dicoParMC.keys())
 203       for k in listeMC :
 204           #print "----------- traitement de " , k
 205           self.textePy += self.dicoFrancaisAnglais[k] + "("
 206           self.traiteMC(dicoParMC[k])
 207           self.textePy += ");\n"
 208           #print "----------- "
 209
 210
 211       #print self.textePy
 212       return self.textePy
 213
 214    #----------------------------------------
 215    def redecoupeSimp(self,simp):
 216    # traite les - dans les identifants python
 217    # les remplace par des _
 218    #----------------------------------------
 219       # replace('-','_')  uniquement dans les identifiants
 220       while simp.find('-') > 0 :
 221         ind=simp.find('-')
 222         if ind==len(simp)-1 : break
 223         simp=simp[0:ind]+'_'+simp[ind+1].upper()+simp[ind+2:]
 224       return simp
 225
 226    #----------------------------------------
 227    def traiteIdent(self,listeIdent):
 228    # Recree l identifiant Python
 229    #----------------------------------------
 230           while listeIdent[-1] == " " or listeIdent[-1] == '\t' : listeIdent=listeIdent[0:-1]
 231           while listeIdent[0]  == " " or listeIdent[0]  == '\t' : listeIdent=listeIdent[1:]
 232
 233           listeIdent=re.sub("'"," ",listeIdent)
 234           motsInIdent=string.split(listeIdent,' ')
 235           simp=""
 236           for mot in motsInIdent:
 237               if re.compile(r"^\s*$").match(mot) : continue
 238               mot=mot.replace('_','__')
 239               simp=simp+mot[0].upper() +mot[1:].lower()+'_'
 240
 241           simp=simp[0:-1]
 242           while simp[-1] == " " : simp=simp[0:-1]
 243           if simp.find('-') > 0 : simp=self.redecoupeSimp(simp)
 244
 245           return simp
 246
 247
 248    def traiteMC(self,dico) :
 249        from Accas import A_BLOC, A_FACT, A_SIMP
 250        for k in dico.keys() :
 251            valeur= dico[k]
 252            if k not in self.dicoMC.keys() : kA=self.dicoFrancaisAnglais[k]
 253            else : kA=k
 254            obj=self.dicoMC[kA]
 255            if isinstance(obj,A_FACT.FACT):   self.convertFACT(obj,kA,valeur)
 256            elif isinstance(obj,A_BLOC.BLOC): self.convertBLOC(obj,kA,valeur)
 257            elif isinstance(obj,A_SIMP.SIMP): self.convertSIMP(obj,kA,valeur)
 258            else : print "%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%"
 259
 260            #print "_____________"
 261
 262    def convertFACT(self,obj,nom,valeur):
 263        if nom in TELEMACParser.__dict__.keys() :
 264           apply(TELEMACParser.__dict__[nom],(self,))
 265           return
 266        self.textePy +=  nom + "=_F( "
 267        self.traiteMC(valeur)
 268        self.textePy += '),\n'
 269
 270
 271    def convertBLOC(self,obj,nom,valeur):
 272        print "BLOC "
 273        print nom
 274
 275    def convertSIMP(self,obj,nom,valeur):
 276        if nom in ("Prescribed_Flowrates", "Prescribed_Velocities", "Prescribed_Elevations" ): return
 277        if obj.max==1 :
 278           if hasattr(obj.type[0],'ntuple') :
 279              lval=[]
 280              for v in valeur :
 281                try :    v=eval(v,{})
 282                except : pass
 283                lval.append(v)
 284              self.textePy += nom + "=" + str(lval) +","
 285              return
 286           if 'TXM' in obj.type :
 287
 288               if pattern_ContientDouble.match(str(valeur)):
 289                  valeur=re.sub("''","\'\'",str(valeur))
 290                  self.textePy += nom + "=" + str(valeur) +","
 291                  return
 292               valeur=str(valeur)
 293
 294               # ceinture et bretelle si les re sont correctes -)
 295               while valeur[-1] == " " or valeur[-1] == '\t' : valeur=valeur[0:-1]
 296               while valeur[0]  == " " or valeur[0]  == '\t' : valeur=valeur[1:]
 297
 298
 299
 300           # Pour les enum
 301           try    : valeur=eval(valeur,{})
 302           except : pass
 303           if nom in DicoEnumCasEn.keys():
 304              #print "est dans le dico des enum, valeur simple"
 305              try    :
 306                valeur=DicoEnumCasEn[nom][valeur]
 307                self.textePy += nom + "= '" + str(valeur) +"',"
 308                return
 309              except : pass
 310
 311
 312           if obj.into != [] and obj.into != None and not('R' in obj.type) and not('I' in obj.type):
 313              for possible in obj.into :
 314                 try :
 315                   if possible.upper() == valeur.upper():
 316                      valeur=possible
 317                      break
 318                   v=valeur[0].upper()+valeur[1:].lower()
 319                   v2=tr(v)
 320                   if possible.upper() == v2.upper():
 321                      valeur=possible
 322                      break
 323                 except:
 324                    print "pb avec le type de ", obj.nom, obj.type, 'et la valeur ', valeur
 325
 326           if 'Fichier' in obj.type or 'TXM' in obj.type or 'Repertoire' in obj.type :
 327               valeur=str(valeur)
 328               while valeur[-1] == " " : valeur=valeur[0:-1]
 329               while valeur[0]  == " " : valeur=valeur[1:]
 330               self.textePy += nom + "= '" + str(valeur) +"' ,"
 331               return
 332
 333           if bool in obj.type :
 334             if   valeur == True  :  self.textePy += nom + "= True,"
 335             elif valeur == False :  self.textePy += nom + "= False,"
 336             elif pattern_oui.match(valeur) : self.textePy += nom + "= True,"
 337             elif pattern_non.match(valeur) : self.textePy += nom + "= False,"
 338             else :  self.textePy += nom + "= None,"
 339             return
 340           self.textePy += nom + "=" + str(valeur) +","
 341
 342        else :
 343           if pattern_listeVide.match(valeur) :
 344              self.textePy += nom + "= None,"
 345              return
 346           while valeur[-1] == " " or  valeur[-1]=="'" : valeur=valeur[0:-1]
 347           while valeur[0]  == " " or  valeur[-0]=="'" : valeur=valeur[1:]
 348
 349           if   ";" in valeur : valeur=valeur.split(';')
 350           elif "," in valeur : valeur=valeur.split(',')
 351
 352           if valeur == None : return
 353           newVal=[]
 354           for v in valeur :
 355             try :    v=eval(v,{})
 356             except : pass
 357             if nom in DicoEnumCasEn.keys():
 358                #print "est dans le dico des enum, valeurs multiples"
 359                try    : v=DicoEnumCasEn[nom][v]
 360                except : pass
 361             newVal.append(v)
 362           self.textePy += nom + "=" + str(newVal) +","
 363
 364
 365
 366    def tri(self, listeIn):
 367       if len(listeIn) == 1 : return listeIn
 368       if self.Ordre_Des_Commandes == None : return listeIn
 369       #print self.Ordre_Des_Commandes
 370       listeOut=[listeIn[0],]
 371       for kF in listeIn[1:]:
 372           k=str(self.dicoFrancaisAnglais[kF])
 373           ordreK=self.Ordre_Des_Commandes.index(k)
 374           i=0
 375           while i < len(listeOut):
 376              ordreI=self.Ordre_Des_Commandes.index(self.dicoFrancaisAnglais[listeOut[i]])
 377              if ordreK < ordreI : break
 378              i=i+1
 379           listeOut.insert(i,kF)
 380       return listeOut
 381
 382    def Processeurs_Paralleles(self):
 383       #YOANN
 384       if self.dictSimp["Processeurs_Paralleles"] == 0 : del  self.dictSimp["Processeurs_Paralleles"]
 385       else : self.dictSimp["Parallel_Computation"]="Parallel"
 386
 387    def decoupeListe(self,valeurs,label):
 388       #print "decoupeListe"
 389       #print valeurs
 390       i=0
 391       for prefixe in ('_U_And_V','_H'):
 392           labelComplet=label+prefixe
 393           valeur=valeurs[i]
 394           try    : valeur=eval(valeur,{})
 395           except : pass
 396           if tr(label) in DicoEnumCasEn.keys():
 397              try    : valeur=DicoEnumCasEn[tr(label)][valeur]
 398              except : pass
 399           self.dictSimp[labelComplet]=valeur
 400           i=i+1
 401       if len(valeurs)==2 : return
 402       for prefixe in ('_K_And_Epsilon','_Tracers'):
 403           labelComplet=label+prefixe
 404           valeur=valeurs[i]
 405           try    : valeur=eval(valeur,{})
 406           except : pass
 407           if tr(label) in DicoEnumCasEn.keys():
 408              try    : valeur=DicoEnumCasEn[tr(label)][valeur]
 409              except : pass
 410           self.dictSimp[labelComplet]=valeur
 411           i=i+1
 412
 413    def Option_De_Supg(self):
 414        #print "ds Option_De_Supg"
 415        self.decoupeListe( self.dictSimp["Option_De_Supg"],"Option_De_Supg")
 416        del self.dictSimp["Option_De_Supg"]
 417
 418    def Forme_De_La_Convection(self):
 419        self.decoupeListe( self.dictSimp["Forme_De_La_Convection"],"Forme_De_La_Convection")
 420        valeurs=self.dictSimp["Forme_De_La_Convection"]
 421        del self.dictSimp["Forme_De_La_Convection"]
 422        self.dictSimp['Convection_De_U_Et_V']=True
 423        self.dictSimp['Convection_De_H']=True
 424        if len(valeurs)==2 : return
 425        self.dictSimp['Convection_De_K_Et_Epsilon']=True
 426        self.dictSimp['Convection_Des_Traceurs']=True
 427
 428    def Discretisations_En_Espace(self):
 429        self.decoupeListe( self.dictSimp["Discretisations_En_Espace"],"Discretisations_En_Espace")
 430        del self.dictSimp["Discretisations_En_Espace"]
 431
 432    def Date_De_L_Origine_Des_Temps (self):
 433        valeurs=self.dictSimp["Date_De_L_Origine_Des_Temps"]
 434        self.dictSimp['Annee']=valeurs[0]
 435        self.dictSimp['Mois']=valeurs[1]
 436        self.dictSimp['Jour']=valeurs[2]
 437        del  self.dictSimp["Date_De_L_Origine_Des_Temps"]
 438
 439
 440    def Heure_De_L_Origine_Des_Temps (self):
 441        valeurs=self.dictSimp["Heure_De_L_Origine_Des_Temps"]
 442        self.dictSimp['Heure']=valeurs[0]
 443        self.dictSimp['Minute']=valeurs[1]
 444        self.dictSimp['Seconde']=valeurs[2]
 445        del  self.dictSimp["Heure_De_L_Origine_Des_Temps"]
 446
 447    def Liquid_Boundaries(self):
 448        #print 'Liquid Boundaries'
 449        texte_Boundaries="Liquid_Boundaries=( "
 450        premier=0
 451        if 'Prescribed_Elevations' in self.dictSimp.keys():
 452            valeurs=self.dictSimp["Prescribed_Elevations"]
 453        elif 'Cotes_Imposees' in self.dictSimp.keys():
 454            valeurs=self.dictSimp["Cotes_Imposees"]
 455        else : valeurs=()
 456        #print valeurs
 457        for e in range(len(valeurs)):
 458           if valeurs[e] == "" or valeurs[e] == "\n" : continue
 459           if eval(valeurs[e],{})==0 : continue
 460           if not premier : premier=1
 461           texte_Boundaries += "_F(Type_Condition = 'Prescribed Elevations',\n"
 462           texte_Boundaries += "Prescribed_Elevations = " + str(valeurs[e]) + "),\n"
 463
 464        if 'Prescribed_Flowrates' in self.dictSimp.keys():
 465           valeurs=self.dictSimp["Prescribed_Flowrates"]
 466        elif 'Debits_Imposes' in self.dictSimp.keys():
 467           valeurs=self.dictSimp["Debits_Imposes"]
 468        else : valeurs=()
 469        #print valeurs
 470        for e in range(len(valeurs)):
 471           if valeurs[e] == "" or valeurs[e] == "\n" : continue
 472           if eval(valeurs[e],{})==0 : continue
 473           if not premier : premier=1
 474           texte_Boundaries += "_F(Type_Condition = 'Prescribed Flowrates',\n"
 475           texte_Boundaries += "Prescribed_Flowrates = " + str(valeurs[e]) + "),\n"
 476
 477        if 'Prescribed_Velocity' in self.dictSimp.keys():
 478            valeurs=self.dictSimp["Prescribed_Velocity"]
 479        elif 'Vitesses_Imposees' in self.dictSimp.keys():
 480            valeurs=self.dictSimp["Vitesses_Imposees"]
 481        else : valeurs=()
 482        #print valeurs
 483        for e in range(len(valeurs)):
 484           if valeurs[e] == "" or valeurs[e] == "\n" : continue
 485           if eval(valeurs[e],{})==0 : continue
 486           if not premier : premier=1
 487           texte_Boundaries += "_F(Type_Condition = 'Prescribed Velocity',\n"
 488           texte_Boundaries += "Prescribed_Velocity = " + str(valeurs[e]) + "),\n"
 489        if premier :  texte_Boundaries +="),\n"
 490        else : texte_Boundaries="" ; print "pb texte_Boundaries "
 491        self.textePy += texte_Boundaries
 492