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