egal,nomval,fin=ancien.split("'",2)
nouvelleLigne=debChaine+egal+"'ABSC'"+fin
jdc.getLines()[child.lineno-1]=nouvelleLigne
+ logging.info("renommage parametre ABSC ligne %d",child.lineno-1)
return
#--------------------------------------------------------------------------
Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur])
Nouveau=MaLigneGlob[0:debut]+Nouveau
jdc.getLines()[indexLigneGlob]=Nouveau
+ logging.info("Changement de %s par %s ligne %d",Valeur,DictNouvVal[Valeur],indexLigneGlob)
break
if trouve > -1 : break
indexLigneGlob=indexLigneGlob+1
# -*- coding: utf-8 -*-
import logging
+from dictErreurs import EcritErreur
+
#--------------------------------------------------------------------------
def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
MaLigneTexte=Nouveau # raccourci honteux mais ...
MaLigneGlob=Nouveau
if Valeur in liste :
- logging.error("OPTION de CALCG à verifier ligne %s" , indexLigneGlob)
- # break
- #if trouve > -1 : break
+ EcritErreur((command,motcle,"VALEUR"),indexLigneGlob)
+ else :
+ logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
indexLigneGlob=indexLigneGlob+1
indexTexteMC=indexTexteMC+1
if (trouveUnMC == 0) and ( defaut == 1):
- logging.error("OPTION (defaut) de CALCG à verifier ligne %s" ,c.lineno )
+ EcritErreur((command,motcle,"DEFAUT"),c.lineno)
jdc.reset(jdc.getSource())
-#--------------------------------------------------------------------------
+#--------------------------------------------------------------------------------
def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0):
-#--------------------------------------------------------------------------
+#--------------------------------------------------------------------------------
for c in jdc.root.childNodes:
if c.name != command : continue
MaLigneTexte=Nouveau # raccourci honteux mais ...
MaLigneGlob=Nouveau
if Valeur in liste :
- logging.error("OPTION de %s %s %s ligne %s" ,command,fact,motcle, indexLigneGlob)
+ EcritErreur((command,fact,motcle,"VALEUR"),indexLigneGlob)
+ else :
+ logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
indexLigneGlob=indexLigneGlob+1
indexTexteMC=indexTexteMC+1
if (trouveUnMC == 0) and ( defaut == 1):
logging.error("OPTION (defaut) de CALCG à verifier ligne %s" ,c.lineno )
+ EcritErreur((command,fact,motcle,"DEFAUT"),c.lineno)
jdc.reset(jdc.getSource())
#---------------------------------------------------------------------------------------
jdc.splitLine(command.lineno,numcol)
texte=texte+'\n'
jdc.addLine(texte,command.lineno)
+ logging.info("insertion de %s ligne %d", texte,command.lineno)
if numcol > 0 : # Les mots clefs etaient sur la même ligne
jdc.joinLineandNext(command.lineno)
while ligneaCouper < facteur.endline + 1 :
if ancien.find("_F") > 0 :
indice=ancien.find("_F")
- # pour ne pas tenir compte
- if ancien[indice+2] in ("("," ") :
- trouve=1
- break
+ # pour ne pas tenir compte des autres noms
+ # Attention si 2 MCF sur la meme ligne (la 1ere)
+ if ((ligneaCouper!=facteur.lineno) or (ancien.find(facteur.name) < indice)) :
+ if ancien[indice+2] in ("("," ") :
+ trouve=1
+ break
ligneaCouper=ligneaCouper+1
ancien=jdc.getLine(ligneaCouper)
jdc.addLine(texte,ligneaCouper)
jdc.joinLineandNext(ligneaCouper)
+ logging.info("insertion de %s ligne %d", texte,ligneaCouper)
# Gestion du cas particulier du mot clef facteur vide
if facteur.childNodes == []:
jdc.joinLineandNext(facteur.lineno)
from inseremocle import *
from changeValeur import *
from movemocle import *
+from dictErreurs import GenereErreurPourCommande
+
+# Demander a emmanuel pour affe_char_ther et test_resu
import calcG
atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE",
"AFFE_CHAR_THER_F","IMPR_CO","DEFI_SQUELETTE","DEFI_FONCTION",
"CALC_THETA","AFFE_MODELE","DYNA_NON_LINE","CALC_ELEM",
"CALC_NO","EXTR_MODE","CALC_META","IMPR_RESU","TEST_RESU",
- "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT"
+ "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT","CALC_CHAM_ELEM",
+ "AFFE_CHAR_THER", "MACR_LIGN_COUPE","POST_RCCM","PROJ_MESU_MODAL",
+ "CREA_RESU",
)
-#atraiter=("CALC_FONCTION","IMPR_GENE","STAT_NON_LINE","DEFI_MATERIAU",
-# "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G",)
-#atraiter=( "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G",)
#atraiter=( "IMPR_GENE",)
def traduc(infile,outfile):
parseKeywords(root)
renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO")
+ removeMotCleSiRegle(jdc,"CALC_FONCTION","NOM_PARA",((("MAX"),"existeMCFParmi"),))
renameCommandeSiRegle(jdc,"CALC_FONCTION","INFO_FONCTION", ((("RMS","MAX","NOCI_SEISME","NORME","ECART-TYPE"),"existeMCFParmi"),))
# Les arguments sont - jdc,
#
removeMotCle(jdc,"AFFE_CHAR_MECA","VERI_DDL")
removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL")
+ removeMotCle(jdc,"AFFE_CHAR_THER","VERI_DDL")
chercheOperInsereFacteurSiRegle(jdc,"CALC_G_LOCAL_T","LISSAGE",((("LISSAGE_G","LISSAGE_THETA","DEGRE"),"existeMCFParmi"),))
moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_THETA","LISSAGE")
# Attention cela necessite un traitement particulier et ne peut pas etre generalise tel quel
# Attention egalement doit etre fait avant le regroupement dans THETA
calcG.traitementRayon(jdc)
-
- #Affe_modele
- daffeModele={"PLAN_FISSURE":"PLAN_JOINT", "AXIS_FISSURE":"AXIS_JOINT","OHNO":"VISC_TAHERI"}
- lavertit=("OHNO")
- ChangementValeurDsMCFAvecAvertissement(jdc,"AFFE_MODELE","AFFE","MODELISATION",daffeModele,lavertit)
- removeMotCleSiRegle(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","APPUI_REP",jdc),"MCsousMCFaPourValeur"),))
-
-
- #--> MACR_LIGN_COUPE + POST_RCCM avertissement
- #removeMotCle(jdc,"PROJ_MESU_MODAL","NOM_PARA")
- #removeMotCle(jdc,"AFFE_CHAR_MECA",CONTACT", "FROTTEMENT" si METHODE ="CONTRAINTE"
-
- # dStatNonLine={"ELAS":"ELAS_THER"}
- # lavertit=("ELAS_THER")
- # STAT_NON_LINE mCF COMP-INCR contient le mot cle RELATION_KIT
- # la valeur de ELAS COMP ELAS devient ELAS
- # STAT_NON_LINE mCF COMP-INCR contient le mot cle RELATION contient ASSE_COMBU __> erreur
- # suppresion de CALC_CHAM_ELEM si OPTION = "SOUR_ELGA_ELEC" + erreur
-
- # CALC_FONCTION NOM_PARA a supprimer si MCF MAX
- # dCREA-RESU={"HYDR_ELGA":"HYDR_NOEUD_ELGA"}
-#
-#
renameMotCle(jdc,"CALC_G","THETA","THETA_OLD")
chercheOperInsereFacteur(jdc,"CALC_G","THETA")
moveMotClefInOperToFact(jdc,"CALC_G","THETA_OLD","THETA")
moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA")
moveMotClefInOperToFact(jdc,"CALC_G","R_INF","THETA")
moveMotClefInOperToFact(jdc,"CALC_G","R_SUP","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","FISSURE","THETA")
dcalcelemno={"ERRE_ELGA_NORE":"ERRE_ELEM_SIGM","ERRE_ELEM_NOZ1":"ERZ1_ELEM_SIGM","ERRE_ELEM_NOZ2":"ERZ2_ELEM_SIGM","ERRE_ELNO_ELGA":"ERRE_ELNO_ELEM","ERRE_NOEU_ELGA":"ERRE_NOEU_ELEM","ERTH_ELEM_TEMP":"ERRE_ELEM_TEMP","ERTH_ELNO_ELEM":"ERRE_ELNO_ELEM"}
+
+ #Affe_modele
+ daffeModele={"PLAN_FISSURE":"PLAN_JOINT", "AXIS_FISSURE":"AXIS_JOINT","OHNO":"VISC_TAHERI"}
+ lavertit=("OHNO")
+ ChangementValeurDsMCFAvecAvertissement(jdc,"AFFE_MODELE","AFFE","MODELISATION",daffeModele,lavertit)
+ removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","APPUI_REP",jdc),"MCsousMCFaPourValeur"),))
+
+
+ removeMotCleInFact(jdc,"PROJ_MESU_MODAL","MODELE_MESURE","NOM_PARA")
+ removeMotCleInFactSiRegleAvecErreur(jdc,"AFFE_CHAR_MECA","CONTACT","FROTTEMENT",((("CONTACT","METHODE","CONTRAINTE",jdc),"MCsousMCFaPourValeur"),))
+
+ dStatNonLine={"ELAS":"ELAS_THER"}
+ lavertit=("ELAS")
+ ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP-INCR","RELATION_KIT",dStatNonLine,lavertit)
+
+ lavertit=("CHABOCHE","ASSE_COMBU")
+ dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB","ASSE_COMBU":"XXX_IRA"}
+ ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit)
+
+#
+#
ChangementValeur(jdc,"CALC_ELEM","OPTION",dcalcelemno)
ChangementValeur(jdc,"CALC_NO","OPTION",dcalcelemno)
ChangementValeurDsMCF(jdc,"IMPR_RESU","RESU","NOM_CHAM",dcalcelemno)
ChangementValeur(jdc,"TEST_RESU","RESU",dcalcelemno)
+ removeMotCleAvecErreur(jdc,"TEST_RESU","UNITE")
+ GenereErreurPourCommande(jdc,("MACR_LIGN_COUPE","POST_RCCM"))
#
renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","CHABOCHE","CINx_CHAB")
- lavertit=("CHABOCHE")
- dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB"}
- ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit)
AjouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF")))
chercheOperInsereFacteur(jdc,"DYNA_TRAN_EXPLI","DIFF_CENT")
+ dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"}
+ lavertit=("HYDR_ELGA",)
+ ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dcrearesu,lavertit)
+
removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),))
removeCommande(jdc,"DEFI_THER_JOULE")
+ removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),))
removeCommande(jdc,"DIST_LIGN_3D")
# Pour Tests
cible=mc
break
if cible==None :
- logging.info("Pas de changement pour %s,%s,%s", oper, factsource,mocle)
- logging.info("Le mot clef cible %s n est pas présent", factcible)
if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "cible non trouvée"
continue
source=mc
break
if source==None :
- logging.info("Pas de changement pour %s,%s,%s", oper, factsource,mocle)
- logging.info("Le mot clef source %s n est pas présent", factsource)
if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "source non trouvée"
continue
cible=mc
break
if cible==None :
- logging.info("Pas de changement pour %s,%s,%s",oper, mocle,factcible)
- logging.info("Le mot clef cible %s n est pas présent", factcible)
-# if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée"
+ if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée"
continue
source=None
source=mc
break
if source==None :
- logging.info("Pas de changement pour %s,%s,%s",oper, mocle,factcible)
- logging.info("Le mot clef source %s n est pas présent", mocle)
-# if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée"
+ if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée"
continue
MonTexte=source.getText(jdc);
inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte)
f=self.fonction(self.list_args)
return f.verif(commande)
-#------------------
+#---------------------
class existeMCFParmi :
-#------------------
+#---------------------
def __init__(self,list_arg):
self.listeMCF=list_arg;
bool=1
return bool
+#-------------------------------
+class MCaPourValeur :
+#------------------------------
+ def __init__(self,list_arg):
+ assert (len(list_arg)==3)
+ self.MC=list_arg[0]
+ self.Val=list_arg[1]
+ self.Jdc=list_arg[2]
+
+ def verif(self,commande):
+ bool=0
+ for mc in commande.childNodes :
+ if mc.name != self.MC : continue
+ TexteMC=mc.getText(self.Jdc)
+ if (TexteMC.find(self.Val) < 0 ): continue
+ bool=1
+ return bool
-dictionnaire_regle={"existe":existe,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur}
+dictionnaire_regle={"existe":existe,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur,"MCaPourValeur":MCaPourValeur}
SansRegle=pasDeRegle()
import logging
import regles
from parseur import FactNode
+from dictErreurs import EcritErreur
#debug=1
debug=0
#avant de supprimer un autre mocle, on remet à jour l'arbre syntaxique (lineno,colno,etc.)
-#-----------------------------------------------------------
-def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle):
-#-----------------------------------------------------------
+#-----------------------------------------------------------------------
+def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle,erreur = 0):
+#-----------------------------------------------------------------------
#on itere sur les commandes a l'envers pour ne pas polluer les numeros de ligne avec les modifications
commands= jdc.root.childNodes[:]
commands.reverse()
for mc in c.childNodes:
if mc.name != mocle:continue
if ensemble.verif(c) == 0 : continue
+ if erreur : EcritErreur((command,mocle),c.lineno)
removeMC(jdc,c,mc)
jdc.reset(jdc.getSource())
def removeMotCleSiRegle(jdc,command,mocle,liste_regles) :
#-------------------------------------------------------
mesRegles=regles.ensembleRegles(liste_regles)
- removeMotCle(jdc,command,mocle,mesRegles)
+ removeMotCle(jdc,command,mocle,mesRegles,erreur=0)
+#----------------------------------------------------------------
+def removeMotCleSiRegleAvecErreur(jdc,command,mocle,liste_regles) :
+#--------------------------------------------------------------
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCle(jdc,command,mocle,mesRegles,erreur=1)
+
+#----------------------------------------------------------------
+def removeMotCleAvecErreur(jdc,command,mocle) :
+#--------------------------------------------------------------
+ removeMotCle(jdc,command,mocle,erreur=1)
+
-#--------------------------------
-def removeCommande(jdc,command):
-#--------------------------------
+#--------------------------------------------------------------------
+def removeCommande(jdc,command,ensemble=regles.SansRegle,erreur=0):
+#--------------------------------------------------------------------
commands= jdc.root.childNodes[:]
commands.reverse()
for c in commands:
if c.name != command:continue
+ if ensemble.verif(c) == 0 : continue
+ if erreur : EcritErreur((command,),c.lineno)
jdc.supLignes(c.lineno,c.endline)
logging.error("Suppression de: %s, %s, %s",c.name,c.lineno,c.endline)
+#-------------------------------------------------------------
+def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles):
+#-------------------------------------------------------------
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeCommande(jdc,command,mesRegles,1)
#---------------------------------
def removeMC(jdc,c,mc):
jdc.getLines()[mc.lineno-1]=s[:mc.colno]+s[mc.endcol:]
fusionne(jdc,mc.lineno-1)
-#--------------------------------------------
-def removeMotCleInFact(jdc,command,fact,mocle):
-#---------------------------------------------
+#---------------------------------------------------------------------------------
+def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0):
+#----------------------------------------------------------------------------------
# on itere sur les commandes a l'envers pour ne pas polluer
# les numeros de ligne avec les modifications
commands= jdc.root.childNodes[:]
for ll in l:
for n in ll.childNodes:
if n.name != mocle:continue
+ if ensemble.verif(c) == 0 : continue
+ if erreur : EcritErreur((command,fact,mocle),c.lineno)
removeMC(jdc,c,n)
jdc.reset(jdc.getSource())
+#------------------------------------------------------------------
+def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles):
+#------------------------------------------------------------------
+ erreur=0
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur)
+
+#----------------------------------------------------------------------
+def removeMotCleInFactSiRegleAvecErreur(jdc,command,fact,mocle,liste_regles):
+#----------------------------------------------------------------------
+ erreur=1
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur)
+
+
#------------------------------------------
def fusionne(jdc,numLigne):
#------------------------------------------
import sys
from parseur import FactNode
import regles
+from dictErreurs import EcritErreur
#debug=1
debug=0
#on n'a qu'un mocle par commande.
#en fin de traitement, on remet à jour l'arbre syntaxique (lineno,colno,etc.)
-#------------------------------------------------------
+#--------------------------------------------------------------------------------
def renameMotCle(jdc,command,mocle,new_name, erreur=0):
-#------------------------------------------------------
+#--------------------------------------------------------------------------------
for c in jdc.root.childNodes:
if c.name != command:continue
for mc in c.childNodes:
if mc.name != mocle:continue
if debug:print "Renommage de:",c.name,mc.name,mc.lineno,mc.colno
if erreur :
- logging.error("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name)
+ EcritErreur((command,mocle),c.lineno)
else :
logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name)
s=jdc.getLines()[mc.lineno-1]
#-------------------------------------------
def renameOper(jdc,command,new_name):
#-------------------------------------------
- logging.info("Traitement de %s renomme en %s ", command, new_name)
- logging.info ("_________________________________________________")
- logging.info (" ")
for c in jdc.root.childNodes:
if c.name != command:continue
if debug:print "Renommage de:",c.name,c.lineno,c.colno
#----------------------------------------------------------
def renameMotCleInFact(jdc,command,fact,mocle,new_name):
#----------------------------------------------------------
- logging.info("Traitement de %s sous %s de %s renomme en %s ", mocle,fact,command, new_name)
- logging.info ("_______________________________________________________________________")
- logging.info (" ")
for c in jdc.root.childNodes:
if c.name != command:continue
for mc in c.childNodes:
def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle):
#-----------------------------------------------------------------
# nom de la commande "ancien format" , nom de la commande " nouveau format "
- if ensemble != regles.SansRegle :
- logging.info("Traitement de %s renomme en %s sous conditions", command, new_name)
- else :
- logging.info("Traitement de %s renomme en %s ", command, new_name)
- logging.info ("_______________________________________________________________________")
- logging.info (" ")
+ if debug :
+ if ensemble != regles.SansRegle :
+ logging.info("Traitement de %s renomme en %s sous conditions", command, new_name)
+ else :
+ logging.info("Traitement de %s renomme en %s ", command, new_name)
for c in jdc.root.childNodes:
if c.name != command:continue
if ensemble.verif(c) == 0 : continue
jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):]
jdc.reset(jdc.getSource())
- logging.info (" ")
#-----------------------------------------------------------
def renameCommandeSiRegle(jdc,command,new_name,liste_regles):
