pattern_comment_slash = re.compile(r"^\s*/")
pattern_eta = re.compile(r".*&ETA.*")
pattern_fin = re.compile(r".*&FIN.*")
-pattern_blanc = re.compile(r"^ *$")
-pattern_OUI = re.compile(r"^ *OUI *")
-pattern_oui = re.compile(r"^ *oui *")
-pattern_NON = re.compile(r"^ *NON *")
-pattern_non = re.compile(r"^ *non *")
-pattern_vide = re.compile(r"^ *$")
+pattern_oui = re.compile(r"^\s*(oui|OUI|YES|yes|TRUE|VRAI)\s*$")
+pattern_non = re.compile(r"^\s*(non|NON|NO|no|FALSE|FAUX)\*s$")
+pattern_blanc = re.compile(r"^\s*$")
+pattern_listeVide = re.compile(r"^\s*'\s*'\s*$")
-from aideAuxConvertisseurs import DicoEficasToCas, ListeSupprimeCasToEficas
-from aideAuxConvertisseurs import ListeCalculCasToEficas, DicoAvecMajuscules
-from enumDicoTelemac2 import DicoEnumCasEn
+pattern_ligne=re.compile(r'^\s*(?P<ident>[^=:]*)\s*[:=]\s*(?P<reste>.*)$')
+
+# Attention aux listes de flottants
+pattern_liste=re.compile(r'^\s*(?P<valeur>[+-.\w]+(\s*;\s*[+-.\w]+)+)\s*(?P<reste>.*)$')
+pattern_flottant=re.compile(r'^\s*(?P<valeur>[+-]?((\d+(\.\d*)?)|(\.\d+))([dDeE][+-]?\d+)?)\s*(?P<reste>.*)$')
+pattern_texteQuote = re.compile (r"^\s*(?P<valeur>'[^']+(''[^']+)*')\s*(?P<reste>.*)$")
+pattern_texteSimple = re.compile (r"(?P<valeur>(^|\s)\s*[\w\.-]+)\s*(?P<reste>.*)$")
+pattern_texteVide = re.compile (r"^\s*(?P<valeur>'')\s*(?P<reste>.*)$")
+
+pattern_ContientDouble=re.compile (r"^.*''.*$")
+
+
+# le pattern texte reconnait
+#nom1 nom 2 : ou = chaine entre '
+# avec eventuellement des quotes au milieu par exemple
+# TITRE = 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
+# m.group("texte") va rendre 'TELEMAC 2D : GOUTTE D''EAU DANS UN BASSIN$'
+
+
+#Si le code n est pas Telemac
+try :
+ from aideAuxConvertisseurs import DicoEficasToCas, ListeSupprimeCasToEficas
+ from aideAuxConvertisseurs import ListeCalculCasToEficas, DicoAvecMajuscules
+ from enumDicoTelemac2 import DicoEnumCasEn
+except :
+ pass
from Extensions import localisation
l_lignes = string.split(self.text,'\n')
self.dictSimp={}
for ligne in l_lignes :
+
if pattern_comment_slash.match(ligne) : continue
if pattern_eta.match(ligne) : continue
if pattern_fin.match(ligne) : continue
if pattern_blanc.match(ligne) : continue
- ligne=re.sub('\t',' ',ligne)
- ligne=re.sub("'",' ',ligne)
- ligne=re.sub(":",'=',ligne)
- if ligne.count('=') != 1 :
- print "pb avec la ligne " , ligne
- continue
-
- motsInLigne=string.split(ligne,' ')
- listeMotsSimp=()
- simp=""
- for mot in motsInLigne:
- if mot == "" : continue
- if mot == "=" :
- simp=simp[0:-1]
- while simp[-1] == " " : simp=simp[0:-1]
- if simp.find('-') > 0 : simp=self.redecoupeSimp(simp)
- break
-
- mot=mot.replace('_','__')
- simp=simp+mot[0].upper() +mot[1:].lower()+'_'
- valeur=ligne.split('=')[1]
- self.dictSimp[simp]=valeur
+
+ finLigne=ligne
+ while finLigne != "" :
+ print finLigne
+ valeur=""
+ m=pattern_ligne.match(finLigne)
+ if m == None :
+ print "________________________________________________"
+ print 'pb avec ****', finLigne , '**** dans ', ligne
+ print "________________________________________________"
+ break
-
- #print dictSimp
- #print self.dicoInverseFrancais
+ simp=self.traiteIdent(m.group('ident'))
+ finLigne=m.group('reste')
+
+ # attention, l ordre des if est important
+ if pattern_liste.match(finLigne) :
+ m=pattern_liste.match(finLigne)
+ elif pattern_texteQuote.match(finLigne) :
+ m=pattern_texteQuote.match(finLigne)
+ elif pattern_flottant.match(finLigne) :
+ m=pattern_flottant.match(finLigne)
+ elif pattern_texteVide.match(finLigne):
+ m=pattern_texteVide.match(finLigne)
+ elif pattern_texteSimple.match(finLigne):
+ m=pattern_texteSimple.match(finLigne)
+ else :
+ print "________________________________________________"
+ print 'pb avec ****', finLigne , '**** dans ', ligne
+ print "non match"
+ print "________________________________________________"
+ break
+
+ valeur=m.group('valeur')
+ if pattern_blanc.match(valeur) : valeur=None
- dicoParMC={}
- #print ListeCalculCasToEficas
+ if pattern_flottant.match(finLigne) :
+ valeur=re.sub("d","e",valeur)
+ valeur=re.sub("D","E",valeur)
+
+ if pattern_liste.match(finLigne):
+ valeur=valeur.split(";")
- if 'Titre' not in self.dictSimp.keys():
+ finLigne=m.group('reste')
+ #print simp
+ #print valeur
+ #print finLigne
+ self.dictSimp[simp]=valeur
+
+ if 'Title' not in self.dictSimp.keys() and 'Titre' not in self.dictSimp.keys():
import os
self.dictSimp['Titre']=os.path.basename(self.filename)
+ dicoParMC={}
for simp in self.dictSimp.keys():
- if simp in ListeSupprimeCasToEficas: continue
+ #print simp, " : ", self.dictSimp[simp]
+
if simp in TELEMACParser.__dict__.keys() : apply(TELEMACParser.__dict__[simp],(self,))
for simp in self.dictSimp.keys():
+ if simp in ListeSupprimeCasToEficas: continue
if simp not in self.dicoInverseFrancais.keys() :
print "************"
- print "pb avec ", simp,'------'
+ print "pb avec dans dicoInverseFrancais", simp,'------'
print "************"
+ print poum
continue
listeGenea=self.dicoInverseFrancais[simp]
listeGeneaReverse=[]
#print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
listeMC=self.tri(dicoParMC.keys())
for k in listeMC :
- print "----------- traitement de " , k
+ #print "----------- traitement de " , k
self.textePy += self.dicoFrancaisAnglais[k] + "("
self.traiteMC(dicoParMC[k])
self.textePy += ");\n"
- print "----------- "
+ #print "----------- "
print self.textePy
return self.textePy
+ #----------------------------------------
+ def redecoupeSimp(self,simp):
+ # traite les - dans les identifants python
+ # les remplace par des _
+ #----------------------------------------
+ # replace('-','_') uniquement dans les identifiants
+ while simp.find('-') > 0 :
+ ind=simp.find('-')
+ if ind==len(simp)-1 : break
+ simp=simp[0:ind]+'_'+simp[ind+1].upper()+simp[ind+2:]
+
+ #----------------------------------------
+ def traiteIdent(self,listeIdent):
+ # Recree l identifiant Python
+ #----------------------------------------
+ while listeIdent[-1] == " " or listeIdent[-1] == '\t' : listeIdent=listeIdent[0:-1]
+ while listeIdent[0] == " " or listeIdent[0] == '\t' : listeIdent=listeIdent[1:]
+
+ listeIdent=re.sub("'"," ",listeIdent)
+ motsInIdent=string.split(listeIdent,' ')
+ simp=""
+ for mot in motsInIdent:
+ if re.compile(r"^\s*$").match(mot) : continue
+ mot=mot.replace('_','__')
+ simp=simp+mot[0].upper() +mot[1:].lower()+'_'
+
+ simp=simp[0:-1]
+ while simp[-1] == " " : simp=simp[0:-1]
+ if simp.find('-') > 0 : simp=self.redecoupeSimp(simp)
+ return simp
+
+
def traiteMC(self,dico) :
for k in dico.keys() :
valeur= dico[k]
def generSIMP(self,obj,nom,valeur):
if nom in ("Prescribed_Flowrates", "Prescribed_Velocities", "Prescribed_Elevations" ): return
+ #print "___________________________"
+ #print nom
+ #print valeur
+ if valeur == None : print nom
if obj.max==1 :
if 'TXM' in obj.type :
+
+ if pattern_ContientDouble.match(valeur):
+ valeur=re.sub("''","\'\'",valeur)
+ print str(valeur)
+ print valeur
+ print tr(valeur)
+ print poum
valeur=str(valeur)
- while valeur[-1] == " " : valeur=valeur[0:-1]
- while valeur[0] == " " : valeur=valeur[1:]
- valeur=valeur[0].upper()+valeur[1:].lower()
- valeur=tr(valeur)
+
+ # ceinture et bretelle si les re sont correctes -)
+ while valeur[-1] == " " or valeur[-1] == '\t' : valeur=valeur[0:-1]
+ while valeur[0] == " " or valeur[0] == '\t' : valeur=valeur[1:]
+
+ if pattern_ContientDouble.match(valeur):
+ valeur=re.sub("''","\'\'",valeur)
+ print valeur
+ print tr(valeur)
+ print poum
+
+
+ # Pour les enum
try : valeur=eval(valeur,{})
except : pass
if nom in DicoEnumCasEn.keys():
+ #print "est dans le dico des enum, valeur simple"
try : valeur=DicoEnumCasEn[nom][valeur]
except : pass
+
+
+ if obj.into != [] and obj.into != None :
+ for possible in obj.into :
+ if possible.upper() == valeur.upper():
+ valeur=possible
+ break
+ v=valeur[0].upper()+valeur[1:].lower()
+ v2=tr(v)
+ if possible.upper() == v2.upper():
+ valeur=possible
+ break
+
if 'Fichier' in obj.type or 'TXM' in obj.type or 'Repertoire' in obj.type :
valeur=str(valeur)
while valeur[-1] == " " : valeur=valeur[0:-1]
while valeur[0] == " " : valeur=valeur[1:]
self.textePy += nom + "= '" + str(valeur) +"' ,"
return
+
if bool in obj.type :
- if pattern_OUI.match(valeur) or pattern_oui.match(valeur) : self.textePy += nom + "= True,"
- if pattern_NON.match(valeur) or pattern_non.match(valeur) : self.textePy += nom + "= False,"
+ if valeur == True : self.textePy += nom + "= True,"
+ elif valeur == False : self.textePy += nom + "= False,"
+ elif pattern_oui.match(valeur) : self.textePy += nom + "= True,"
+ elif pattern_non.match(valeur) : self.textePy += nom + "= False,"
+ else : self.textePy += nom + "= None,"
return
self.textePy += nom + "=" + str(valeur) +","
+
else :
- if pattern_vide.match(valeur) : return
- while valeur[-1] == " " : valeur=valeur[0:-1]
- while valeur[0] == " " : valeur=valeur[1:]
+ if pattern_listeVide.match(valeur) :
+ self.textePy += nom + "= None,"
+ return
+ while valeur[-1] == " " or valeur[-1]=="'" : valeur=valeur[0:-1]
+ while valeur[0] == " " or valeur[-0]=="'" : valeur=valeur[1:]
if ";" in valeur : valeur=valeur.split(';')
elif "," in valeur : valeur=valeur.split(',')
if valeur == None : return
newVal=[]
for v in valeur :
- try : v==eval(v,{})
+ try : v=eval(v,{})
except : pass
if nom in DicoEnumCasEn.keys():
+ #print "est dans le dico des enum, valeurs multiples"
try : v=DicoEnumCasEn[nom][v]
except : pass
newVal.append(v)
-
def tri(self, listeIn):
if len(listeIn) == 1 : return listeIn
if self.Ordre_Des_Commandes == None : return listeIn
if self.dictSimp["Processeurs_Paralleles"] == 0 : del self.dictSimp["Processeurs_Paralleles"]
else : self.dictSimp["Parallel_Computation"]="Parallel"
+ def decoupeListe(self,valeurs,label):
+ print "decoupeSUPG"
+ print valeurs
+ i=0
+ for prefixe in ('_U_And_V','_H'):
+ labelComplet=label+prefixe
+ valeur=valeurs[i]
+ try : valeur=eval(valeur,{})
+ except : pass
+ if tr(label) in DicoEnumCasEn.keys():
+ try : valeur=DicoEnumCasEn[tr(label)][valeur]
+ except : pass
+ self.dictSimp[labelComplet]=valeur
+ i=i+1
+ if len(valeurs)==2 : return
+ for prefixe in ('_K_And_Epsilon','_Tracers'):
+ labelComplet=label+prefixe
+ valeur=valeurs[i]
+ try : valeur=eval(valeur,{})
+ except : pass
+ if tr(label) in DicoEnumCasEn.keys():
+ try : valeur=DicoEnumCasEn[tr(label)][valeur]
+ except : pass
+ self.dictSimp[labelComplet]=valeur
+ i=i+1
def Option_De_Supg(self):
- print "ds Option_De_Supg"
- return
+ #print "ds Option_De_Supg"
+ self.decoupeListe( self.dictSimp["Option_De_Supg"],"Option_De_Supg")
+ del self.dictSimp["Option_De_Supg"]
def Forme_De_La_Convection(self):
- print "ds Forme_De_La_Convection"
- return
-
- def redecoupeSimp(self,simp):
- # replace('-','_') uniquement dans les identifiants
- while simp.find('-') > 0 :
- ind=simp.find('-')
- if ind==len(simp)-1 : break
- simp=simp[0:ind]+'_'+simp[ind+1].upper()+simp[ind+2:]
- return simp
-
-
+ self.decoupeListe( self.dictSimp["Forme_De_La_Convection"],"Forme_De_La_Convection")
+ valeurs=self.dictSimp["Forme_De_La_Convection"]
+ del self.dictSimp["Forme_De_La_Convection"]
+ self.dictSimp['Convection_De_U_Et_V']=True
+ self.dictSimp['Convection_De_H']=True
+ if len(valeurs)==2 : return
+ self.dictSimp['Advection_Of_K_And_Epsilon']=True
+ self.dictSimp['Advection_Of_Tracers']=True
+
+ def Discretisations_En_Espace(self):
+ self.decoupeListe( self.dictSimp["Discretisations_En_Espace"],"Discretisations_En_Espace")
+ del self.dictSimp["Discretisations_En_Espace"]
+
def Liquid_Boundaries(self):
+ #print 'Liquid Boundaries'
texte_Boundaries="Liquid_Boundaries=( "
premier=0
if 'Prescribed_Elevations' in self.dictSimp.keys():
- valeurs=self.dictSimp["Prescribed_Elevations"].split(";")
+ valeurs=self.dictSimp["Prescribed_Elevations"]
elif 'Cotes_Imposees' in self.dictSimp.keys():
- valeurs=self.dictSimp["Cotes_Imposees"].split(";")
+ valeurs=self.dictSimp["Cotes_Imposees"]
else : valeurs=()
+ #print valeurs
for e in range(len(valeurs)):
if valeurs[e] == "" or valeurs[e] == "\n" : continue
if eval(valeurs[e],{})==0 : continue
texte_Boundaries += "Prescribed_Elevations = " + str(valeurs[e]) + "),\n"
if 'Prescribed_Flowrates' in self.dictSimp.keys():
- valeurs=self.dictSimp["Prescribed_Flowrates"].split(";")
+ valeurs=self.dictSimp["Prescribed_Flowrates"]
elif 'Debits_Imposes' in self.dictSimp.keys():
- valeurs=self.dictSimp["Debits_Imposes"].split(";")
+ valeurs=self.dictSimp["Debits_Imposes"]
else : valeurs=()
+ #print valeurs
for e in range(len(valeurs)):
if valeurs[e] == "" or valeurs[e] == "\n" : continue
if eval(valeurs[e],{})==0 : continue
texte_Boundaries += "Prescribed_Flowrates = " + str(valeurs[e]) + "),\n"
if 'Prescribed_Velocity' in self.dictSimp.keys():
- valeurs=self.dictSimp["Prescribed_Velocity"].split(";")
+ valeurs=self.dictSimp["Prescribed_Velocity"]
elif 'Vitesses_Imposees' in self.dictSimp.keys():
- valeurs=self.dictSimp["Vitesses_Imposees"].split(";")
+ valeurs=self.dictSimp["Vitesses_Imposees"]
else : valeurs=()
+ #print valeurs
for e in range(len(valeurs)):
if valeurs[e] == "" or valeurs[e] == "\n" : continue
if eval(valeurs[e],{})==0 : continue
#DicoAglomere=()
#DicoEficasToCas=()
from aideAuxConvertisseurs import listeSupprime, DicoAglomere, DicoEficasToCas
+from enumDicoTelemac2 import DicoEnumCasEnInverse
def entryPoint():
def initDico(self) :
+ self.PE=False
+ self.FE=False
+ self.VE=False
+ self.textPE = 'PRESCRIBED ELEVATIONS :'
+ self.textFE = 'PRESCRIBED FLOWRATES :'
+ self.textVE = 'PRESCRIBED VELOCITY :'
self.texteDico = ""
# analyse de chaque noeud de l'arbre
#----------------------------------------------------------------------------------------
+ def generPROC_ETAPE(self,obj):
+ self.texteDico += '/------------------------------------------------------/\n'
+ self.texteDico += '/\t\t\t'+obj.nom +'\n'
+ self.texteDico += '/------------------------------------------------------/\n'
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom in TELEMACGenerator.__dict__.keys() : apply(TELEMACGenerator.__dict__[obj.nom],(self,obj))
+
+ return s
+
def generMCSIMP(self,obj) :
"""recuperation de l objet MCSIMP"""
s=PythonGenerator.generMCSIMP(self,obj)
+ if obj.nom == "Title" :
+ print s
+ print str(obj.valeur)
+ print repr(obj.valeur)
+
+
+ # Attention pas sur --> ds certains cas non traite par MCFACT ?
+ # a reflechir avec Yoann
+ if hasattr(obj.definition,'defaut') :
+ if obj.definition.defaut == obj.valeur : return s
+
nomMajuscule=obj.nom.upper()
nom=nomMajuscule.replace('_',' ')
- if nom in listeSupprime : return s
+ if nom in listeSupprime or s == "" : return s
+
+ sTelemac=s[0:-1]
+ if not( type(obj.valeur) in (types.TupleType,types.ListType) ):
+ if obj.nom in DicoEnumCasEnInverse.keys():
+ try : sTelemac=DicoEnumCasEnInverse[obj.nom][obj.valeur]
+ except : print "generMCSIMP Pb avec ", obj.nom, obj.valeur
+ if type(obj.valeur) in (types.TupleType,types.ListType) :
+ if obj.nom in DicoEnumCasEnInverse.keys():
+ sT = "'"
+ for v in obj.valeur:
+ try : sT +=DicoEnumCasEnInverse[obj.nom][v] +";"
+ except : print "generMCSIMP Pb avec ", obj.nom, v
+ sTelemac=sT[0:-1]+"'"
+
if nom in DicoEficasToCas.keys() : nom=DicoEficasToCas[nom]
- self.texteDico+=nom+ ":" + s[0:-1]+ "\n"
+ self.texteDico+=nom+ ":" + str(sTelemac) + "\n"
return s
def generMCFACT(self,obj):
"""
- Recalule les jours et les heures
"""
s=PythonGenerator.generMCFACT(self,obj)
+ if obj.nom in TELEMACGenerator.__dict__.keys() : apply(TELEMACGenerator.__dict__[obj.nom],(self,obj))
+
return s
+ def Liquid_Boundaries(self,obj):
+ #print obj.nom , dir(obj)
+ if 'Type_Condition' in obj.liste_mc_presents() :
+ objForme=obj.get_child('Type_Condition')
+ valForme=objForme.valeur
+
+ nomBloc='b_'+valForme.split(" ")[1]
+ if nomBloc in obj.liste_mc_presents() :
+ objBloc=obj.get_child(nomBloc)
+ objValeur=objBloc.get_child(objBloc.liste_mc_presents()[0])
+ valeur=objValeur.valeur
+ if valeur== None : valeur="0."
+ if valForme == 'Prescribed Elevations' :
+ self.PE=True
+ self.textPE += str(valeur) +"; "
+ else : self.textPE += "0.; "
+ if valForme == 'Prescribed Flowrates' :
+ self.FE=True
+ self.textFE += str(valeur) +"; "
+ else : self.textFE += "0.; "
+ if valForme == 'Prescribed Velocity' :
+ self.VE=True
+ self.textVE += str(valeur) +"; "
+ else : self.textVE += "0.; "
+ print self.textPE, self.textFE,self.textVE
+
+ def BOUNDARY_CONDITIONS(self,obj):
+ if self.FE : self.texteDico += self.textFE[0:-1]+'\n'
+ if self.VE : self.texteDico += self.textVE[0:-1]+'\n'
+ if self.PE : self.texteDico += self.textPE[0:-1]+'\n'
+
+ def Validation(self,obj):
+ self.textDico += "Validation = OUI \n"
+
