generator/generator_TELEMAC.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 from __future__ import absolute_import
  24 from __future__ import print_function
  25 try :
  26    from builtins import str
  27 except : pass
  28
  29 import traceback
  30 import types,re,os
  31 from Extensions.i18n import tr
  32 from .generator_python import PythonGenerator
  33
  34 extensions=('.comm',)
  35
  36
  37
  38
  39 def entryPoint():
  40    """
  41       Retourne les informations necessaires pour le chargeur de plugins
  42       Ces informations sont retournees dans un dictionnaire
  43    """
  44    return {
  45         # Le nom du plugin
  46           'name' : 'TELEMAC',
  47         # La factory pour creer une instance du plugin
  48           'factory' : TELEMACGenerator,
  49           }
  50
  51
  52 class TELEMACGenerator(PythonGenerator):
  53    """
  54       Ce generateur parcourt un objet de type JDC et produit
  55       un texte au format eficas et
  56       un texte au format dictionnaire
  57
  58    """
  59
  60 #----------------------------------------------------------------------------------------
  61    def gener(self,obj,format='brut',config=None,appli=None,statut="Entier"):
  62
  63       self.statut=statut
  64       self.langue=appli.langue
  65       self.DicoEnumCasEnInverse={}
  66       from enum_Telemac2d_auto       import TelemacdicoEn
  67       for motClef in TelemacdicoEn:
  68           d={}
  69           for valTelemac in TelemacdicoEn[motClef]:
  70              valEficas= TelemacdicoEn[motClef][valTelemac]
  71              d[valEficas]=valTelemac
  72           self.DicoEnumCasEnInverse[motClef]=d
  73       if self.langue == 'fr' :
  74          from  enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
  75          for motClef in DicoEnumCasFrToEnumCasEn:
  76               d={}
  77               for valTelemac in DicoEnumCasFrToEnumCasEn[motClef]:
  78                  valEficas= DicoEnumCasFrToEnumCasEn[motClef][valTelemac]
  79                  d[valEficas]=valTelemac
  80               self.DicoEnumCasEnInverse[motClef]=d
  81       self.initDico()
  82       #print (self.DicoEnumCasEnInverse.keys())
  83       # Pour Simplifier les verifs d ecriture
  84       if hasattr(appli,'listeTelemac') : self.listeTelemac=appli.listeTelemac
  85       else : self.listeTelemac = ()
  86
  87       self.dicoCataToCas={}
  88       self.dicoCasToCata=appli.readercata.dicoCasToCata
  89       for motClef in self.dicoCasToCata:
  90            self.dicoCataToCas[self.dicoCasToCata[motClef]]=motClef
  91
  92
  93
  94       # Cette instruction genere le contenu du fichier de commandes (persistance)
  95       self.text=PythonGenerator.gener(self,obj,format)
  96       return self.text
  97
  98
  99 #----------------------------------------------------------------------------------------
 100 # initialisations
 101 #----------------------------------------------------------------------------------------
 102
 103    def initDico(self) :
 104
 105       self.PE=False
 106       self.FE=False
 107       self.VE=False
 108       self.commentaireAvant = False
 109       self.texteCom=''
 110       if self.langue == "fr" :
 111         self.textPE = 'COTES IMPOSEES :'
 112         self.textFE = 'DEBITS IMPOSES :'
 113         self.textVE = 'VITESSES IMPOSEES :'
 114       else :
 115         self.textPE = 'PRESCRIBED ELEVATIONS :'
 116         self.textFE = 'PRESCRIBED FLOWRATES :'
 117         self.textVE = 'PRESCRIBED VELOCITIES :'
 118       self.nbTracers = 0
 119       self.texteDico = ""
 120
 121
 122
 123
 124 #----------------------------------------------------------------------------------------
 125 # ecriture de tout
 126 #----------------------------------------------------------------------------------------
 127
 128    def writeDefault(self,fn) :
 129        self.texteDico+='&ETA\n'
 130        if self.statut == 'Leger' : extension = ".Lcas"
 131        else                      : extension = ".cas"
 132        fileDico = fn[:fn.rfind(".")] + extension
 133        f = open( str(fileDico), 'w')
 134        f.write( self.texteDico )
 135        f.close()
 136
 137 #----------------------------------------------------------------------------------------
 138 # ecriture de Leger
 139 #----------------------------------------------------------------------------------------
 140
 141    def writeLeger(self,fn,jdc,config,appli) :
 142        jdc_formate=self.gener(jdc,config=config,appli=appli,statut="Leger")
 143        self.writeDefault(fn)
 144
 145
 146 #----------------------------------------------------------------------------------------
 147 #  analyse de chaque noeud de l'arbre
 148 #----------------------------------------------------------------------------------------
 149
 150    def generPROC_ETAPE(self,obj):
 151         if  not self.commentaireAvant or self.texteCom.find(obj.nom) < 0:
 152             self.texteDico += '/------------------------------------------------------------------/\n'
 153             self.texteDico += '/\t\t\t'+obj.nom +'\n'
 154             self.texteDico += '/------------------------------------------------------------------/\n'
 155         self.commentaireAvant = False
 156         self.texteCom=''
 157         s=PythonGenerator.generPROC_ETAPE(self,obj)
 158         if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](*(self,obj))
 159
 160         return s
 161
 162    def generMCSIMP(self,obj) :
 163         """recuperation de l objet MCSIMP"""
 164         s=PythonGenerator.generMCSIMP(self,obj)
 165
 166
 167         # Attention pas sur --> ds certains cas non traite par MCFACT ?
 168         # a reflechir avec Yoann
 169         # ajouter le statut ?
 170         if self.statut == 'Leger' :
 171           if hasattr(obj.definition,'defaut') and (obj.definition.defaut == obj.valeur) and (obj.nom not in self.listeTelemac) : return s
 172           if hasattr(obj.definition,'defaut') and obj.definition.defaut != None and (type(obj.valeur) == tuple or type(obj.valeur) == list) and (tuple(obj.definition.defaut) == tuple(obj.valeur)) and (obj.nom not in self.listeTelemac) : return s
 173
 174
 175         #nomMajuscule=obj.nom.upper()
 176         #nom=nomMajuscule.replace('_',' ')
 177         #if nom in listeSupprime or s == "" : return s
 178         if s == "" : return s
 179
 180         sTelemac=s[0:-1]
 181         if not( type(obj.valeur) in (tuple,list) ):
 182            if obj.nom in self.DicoEnumCasEnInverse:
 183              try : sTelemac=str(self.DicoEnumCasEnInverse[obj.nom][obj.valeur])
 184              except :
 185                if obj.valeur==None :  sTelemac=obj.valeur
 186                else : print(("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur))
 187
 188         if type(obj.valeur) in (tuple,list) :
 189            if obj.nom in self.DicoEnumCasEnInverse:
 190              #sT = "'"
 191              sT=''
 192              for v in obj.valeur:
 193                try : sT +=str(self.DicoEnumCasEnInverse[obj.nom][v]) +";"
 194                except :
 195                  if obj.definition.intoSug != [] : sT +=str(v) + ";"
 196                  else : print(("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur))
 197              #sTelemac=sT[0:-1]+"'"
 198              sTelemac=sT[0:-1]
 199            else  :
 200              sTelemac=sTelemac[0:-1]
 201              if sTelemac.find("'") > 0 :
 202                 sTelemac= sTelemac.replace (',',';\n    ')
 203                 # on enleve le dernier  ';'
 204                 index=(sTelemac.rfind(";"))
 205                 sTelemac=sTelemac[:index]+' '+sTelemac[index+1:]
 206
 207         if self.langue=='fr' :
 208            s1=str(sTelemac).replace('True','OUI')
 209            s2=s1.replace('False','NON')
 210         else :
 211            s1=str(sTelemac).replace('True','YES')
 212            s2=s1.replace('False','NO')
 213         if hasattr(obj.definition,'max'):
 214            if obj.definition.max != 1:
 215               s3=s2.replace(',',';')
 216            else:
 217               s3=s2
 218         if s3 != "" and s3[0]=='(' :
 219           try : s3=s3[1:-1] # cas de liste vide
 220           except : s3 = ' '
 221
 222
 223         # LIQUID_BOUNDARIES
 224         #if obj.nom in ('PRESCRIBED_FLOWRATES','PRESCRIBED_VELOCITIES','PRESCRIBED_ELEVATIONS') :
 225         #   return s
 226
 227         if obj.nom not in self.dicoCataToCas :
 228            if obj.nom == 'Consigne' : return ""
 229            return s
 230
 231         nom=self.dicoCataToCas[obj.nom]
 232         if nom in ["VARIABLES FOR GRAPHIC PRINTOUTS", "VARIABLES POUR LES SORTIES GRAPHIQUES", "VARIABLES TO BE PRINTED","VARIABLES A IMPRIMER"] :
 233               if s3 != 'None' and s3 != "''":
 234                 s3=s3.replace(';',',')
 235                 s3="'"+ s3 +"'"
 236               else:
 237                 s3 = "''"
 238         if s3 == "" or s3 == " " : s3 = " "
 239         ligne=nom+ " : " + s3 + "\n"
 240         if len(ligne) > 72 : ligne=self.redecoupeLigne(nom,s3)
 241         self.texteDico+=ligne
 242
 243    def generMCFACT(self,obj):
 244       """
 245       """
 246       s=PythonGenerator.generMCFACT(self,obj)
 247       if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](self,obj)
 248
 249       return s
 250
 251
 252 #  def LIQUID_BOUNDARIES(self,obj):
 253 #     print ('jkljklj')
 254 #     if 'BOUNDARY_TYPE' in  obj.liste_mc_presents() :
 255 #         objForme=obj.get_child('BOUNDARY_TYPE')
 256 #         valForme=objForme.valeur
 257 #         if valForme == None : return
 258
 259
 260 #         if valForme == 'Prescribed Unknown':
 261 #            nomBloc='b_'+valForme.split(" ")[1]
 262 #            if nomBloc in  obj.liste_mc_presents() :
 263 #               objBloc=obj.get_child(nomBloc)
 264 #               valeurPE = objValeur=objBloc.get_child(objBloc.liste_mc_presents()[0]).valeur
 265 #               valeurFE = objValeur=objBloc.get_child(objBloc.liste_mc_presents()[1]).valeur
 266 #               valeurVE = objValeur=objBloc.get_child(objBloc.liste_mc_presents()[2]).valeur
 267 #               if valeurPE== None : valeurPE="0."
 268 #               if valeurFE== None : valeurPE="0."
 269 #               if valeurVE== None : valeurPE="0."
 270 #            self.PE=True
 271 #            self.textPE += str(valeurPE) +"; "
 272 #            self.FE=True
 273 #            self.textFE += str(valeurFE) +"; "
 274 #            self.VE=True
 275 #            self.textVE += str(valeurVE) +"; "
 276 #         else:
 277 #            nomBloc='b_'+valForme.split(" ")[1]
 278 #            if nomBloc in  obj.liste_mc_presents() :
 279 #               objBloc=obj.get_child(nomBloc)
 280 #               objValeur=objBloc.get_child(objBloc.liste_mc_presents()[0])
 281 #               valeur=objValeur.valeur
 282 #               if valeur== None : valeur="0."
 283 #            if valForme == 'Prescribed Elevations' :
 284 #                self.PE=True
 285 #                self.textPE += str(valeur) +"; "
 286 #            else : self.textPE += "0.; "
 287 #            if valForme == 'Prescribed Flowrates' :
 288 #                self.FE=True
 289 #                self.textFE += str(valeur) +"; "
 290 #            else : self.textFE += "0.; "
 291 #            if valForme == 'Prescribed Velocity'  :
 292 #                self.VE=True
 293 #                self.textVE += str(valeur) +"; "
 294 #            else : self.textVE += "0.; "
 295
 296 #  def BOUNDARY_CONDITIONS(self,obj):
 297 #      # sans '; '
 298 #      if self.FE :  self.texteDico += self.textFE[0:-2]+'\n'
 299 #      if self.PE :  self.texteDico += self.textPE[0:-2]+'\n'
 300 #      if self.VE :  self.texteDico += self.textVE[0:-2]+'\n'
 301
 302    def TRACERS(self,obj):
 303        if self.nbTracers != 0 :  self.texteDico += 'NUMBER_OF_TRACERS : '+str(self.nbTracers) + '\n'
 304
 305
 306    def NAME_OF_TRACER(self,obj):
 307        print((dir(obj) ))
 308        print((obj.get_genealogie_precise()))
 309
 310    def Validation(self,obj):
 311        self.texteDico += "VALIDATION : True \n"
 312
 313    def Date_De_L_Origine_Des_Temps (self,obj):
 314        an=obj.get_child('Year').valeur
 315        mois=obj.get_child('Month').valeur
 316        jour=obj.get_child('Day').valeur
 317        self.texteDico += "ORIGINAL DATE OF TIME  :"+ str(an)+ " ,"+str(mois)+ "," +str(jour)+ "\n"
 318
 319    def Original_Hour_Of_Time (self,obj):
 320        hh=obj.get_child('Hour').valeur
 321        mm=obj.get_child('Minute').valeur
 322        ss=obj.get_child('Second').valeur
 323        self.texteDico += "ORIGINAL HOUR OF TIME :"+str(hh)+" ,"+str(mm)+ ","+str(ss)+"\n"
 324
 325    def Type_Of_Advection(self,obj):
 326        listeAdvection=[1,5,1,1]
 327        listeSupg=[2,2,2,2]
 328        listeUpwind=[1.,1.,1.,1.]
 329        self.listeMCAdvection=[]
 330        self.chercheChildren(obj)
 331        dicoSuf={ 'U_And_V' : 0, 'H' : 1, 'K_And_Epsilon' : 2, 'Tracers' : 3}
 332        for c in  self.listeMCAdvection:
 333            if c.nom[0:18] == 'Type_Of_Advection_' and c.valeur!=None:
 334               suf=c.nom[18:]
 335               index=dicoSuf[suf]
 336               listeAdvection[index]=self.DicoEnumCasEnInverse['Type_Of_Advection'][c.valeur]
 337            if c.nom[0:13] == 'Supg_Option_' and c.valeur!=None:
 338               suf=c.nom[13:]
 339               index=dicoSuf[suf]
 340               listeAdvection[index]=self.DicoEnumCasEnInverse['Supg_Option'][c.valeur]
 341            if c.nom[0:23] == 'Upwind_Coefficients_Of_' and c.valeur!=None:
 342               suf=c.nom[23:]
 343               index=dicoSuf[suf]
 344               listeUpwind[index]=c.valeur
 345        self.texteDico += "TYPE OF ADVECTION = "+ str(listeAdvection) + "\n"
 346        self.texteDico += "SUPG OPTION = "+ str(listeSupg) + "\n"
 347        self.texteDico += "UPWIND COEFFICIENTS = "+ str(listeUpwind) + "\n"
 348
 349    def chercheChildren(self,obj):
 350        for c in obj.liste_mc_presents():
 351            objc=obj.get_child(c)
 352            if hasattr(objc,'liste_mc_presents') and objc.liste_mc_presents() != [] : self.chercheChildren(objc)
 353            else : self.listeMCAdvection.append(objc)
 354
 355
 356
 357    def redecoupeLigne(self,nom,valeur) :
 358        text=nom+ " : \n"
 359        valeur=valeur
 360        if valeur.find("'") > -1:
 361           lval=valeur.split(";")
 362           for v in lval : text+='   '+v+';'
 363           text=text[0:-1]+'\n'
 364        else :
 365          lval=valeur.split(";")
 366          ligne="   "
 367          for v in lval :
 368            if len(ligne) < 70 : ligne += str(v)+'; '
 369            else :
 370               text+= ligne+"\n"
 371               ligne="   "+str(v)+'; '
 372          text+= ligne[0:-2]+'\n'
 373        return text
 374
 375    def generCOMMENTAIRE(self,obj):
 376        sans_saut = re.sub("\n$","",obj.valeur)
 377        l_lignes = sans_saut.split('\n')
 378        txt='/'+66*'-'+'/'+'\n'
 379        i=1
 380        for ligne in l_lignes:
 381          self.texteCom+=ligne+'\n'
 382          txt = txt + '/'+ligne+'\n'
 383        txt= txt + '/'+66*'-'+'/'+'\n'
 384        self.texteDico += txt
 385        self.commentaireAvant= True
 386        return PythonGenerator.generCOMMENTAIRE(self,obj)
 387
 388