PN pour sauvegarde

diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py
index 4f462f4d2aa1a3860bde81ba0879d90afb14981c..05c76a6f8e8ab68bd99b21351b0a36eefa579db4 100644 (file)
--- a/Traducteur/calcG.py
+++ b/Traducteur/calcG.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 from parseur import FactNode
+from dictErreurs import jdcSet 
 import logging
 
 dict_commande={}
@@ -10,6 +11,8 @@ import sys
 #--------------------------------------------------------------------------
 def traitementRayon(jdc):
 #--------------------------------------------------------------------------
+   
+    if "DEFI_FONCTION" not in jdcSet : return
     for c in jdc.root.childNodes:
        if c.name != "DEFI_FONCTION" : continue
        monTexte=jdc.getLines()[c.lineno-1]
@@ -134,36 +137,3 @@ def chercheValeurSelonGenea3(jdc,liste_cherche_valeur):
     return liste_valeurs
 
 
-#--------------------------------------------------------------------------
-def traitementOption(jdc):
-#--------------------------------------------------------------------------
-    dtheta={"CALC_G_LAGR":"G_LAGR_GLOB", "G_BILINEAIRE":"G_BILI_GLOB", "CALC_G_MAX":"G_MAX_GLOB", "CALC_G":"CALC_G_MAX"}
-    dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"}
-
-    for c in jdc.root.childNodes:
-       if c.name != "CALC_G_THETA_T"  and c.name != "CALC_G_LOCAL_T" : continue
-       if c.name == "CALC_G_LOCAL_T" :
-          DictNouvVal=dlocal
-       else :
-          DictNouvVal=dtheta
-       for mc in c.childNodes:
-          if mc.name != "OPTION" : continue
-          TexteMC=mc.getText(jdc)
-          liste_ligne_MC=TexteMC.splitlines()
-          indexLigneGlob=mc.lineno-1
-          indexTexteMC=0
-          while indexLigneGlob < mc.endline - 1 :
-             MaLigneGlob=jdc.getLines()[indexLigneGlob]
-             MaLigneTexte=liste_ligne_MC[indexTexteMC]
-             for Valeur in DictNouvVal.keys() :
-                trouve=MaLigneTexte.find(Valeur)
-                if trouve > -1 :
-                   debut=MaLigneGlob.find(MaLigneTexte)
-                  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
-             indexTexteMC=indexTexteMC+1

diff --git a/Traducteur/changeValeur.py b/Traducteur/changeValeur.py
index 818437bea00da9c56a703dd02515088f3ad5fc5e..31ce3459e37272f5d9a93d3c7673f3bd8b41a84a 100644 (file)
--- a/Traducteur/changeValeur.py
+++ b/Traducteur/changeValeur.py
@@ -1,12 +1,15 @@
 # -*- coding: utf-8 -*-
 import logging
 from dictErreurs import EcritErreur
+from dictErreurs import jdcSet
 
 
 #--------------------------------------------------------------------------
 def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
 #--------------------------------------------------------------------------
+    if command  not in jdcSet : return
 
+    boolChange=0
     for c in jdc.root.childNodes:
        if c.name != command  : continue
        trouveUnMC=0
@@ -35,16 +38,19 @@ def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
                       EcritErreur((command,motcle,"VALEUR"),indexLigneGlob)
                    else :
                       logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
+                   boolChange=1
              indexLigneGlob=indexLigneGlob+1
              indexTexteMC=indexTexteMC+1
        if (trouveUnMC == 0) and ( defaut == 1):
           EcritErreur((command,motcle,"DEFAUT"),c.lineno)
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
              
 #--------------------------------------------------------------------------------
 def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0):
 #--------------------------------------------------------------------------------
 
+    if command  not in jdcSet : return
+    boolChange=0
     for c in jdc.root.childNodes:
        if c.name != command  : continue
        for mcF in c.childNodes:
@@ -78,16 +84,18 @@ def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0)
                             EcritErreur((command,fact,motcle,"VALEUR"),indexLigneGlob)
                          else :
                             logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
+                   boolChange=1
                    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())
+    if boolChange : jdc.reset(jdc.getSource())
              
 #---------------------------------------------------------------------------------------
 def ChangementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste):
 #---------------------------------------------------------------------------------------
+    if command  not in jdcSet : return
     defaut=0
     if liste[-1] == "defaut" : 
        defaut=1
@@ -96,6 +104,7 @@ def ChangementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal
 #--------------------------------------------------------------------------
 def ChangementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste):
 #--------------------------------------------------------------------------
+    if command  not in jdcSet : return
     defaut=0
     if liste[-1] == "defaut" : 
        defaut=1
@@ -105,6 +114,8 @@ def ChangementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste):
 def SuppressionValeurs(jdc, command,motcle,liste):
 #--------------------------------------------------------------------------
 
+    if command.name  not in jdcSet : return
+    boolChange=0
     for c in jdc.root.childNodes:
        if c.name != command  : continue
        for mc in c.childNodes:
@@ -141,6 +152,7 @@ def SuppressionValeurs(jdc, command,motcle,liste):
                    if premier == 1 : fin = fin + 1 # on supprime la ,
                    finLigne = chercheLigne[fin:]
                    MaLigne=debLigne+finLigne
+                   boolChange=1
                 jdc.getLines()[indexLigneGlob]=MaLigne
              indexLigneGlob=indexLigneGlob+1
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())

diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py
index 1528dc4c770597d760bbd0f528530cfbbf8faec0..ece9a0c8213e1273e7b9c5032d66040b5ce00683 100644 (file)
--- a/Traducteur/inseremocle.py
+++ b/Traducteur/inseremocle.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import logging
 from parseur import FactNode
+from dictErreurs import jdcSet
 import string
 import regles
 debug=0
@@ -12,6 +13,7 @@ def insereMotCle(jdc,recepteur,texte):
 # appelle la methode selon la classe 
 # du recepteur
 
+    if recepteur.name  not in jdcSet : return
     if recepteur.__class__.__name__ == "Command" :
        if debug : print " Ajout de ", texte, "dans la commande : " ,recepteur.name 
        insereMotCleDansCommande(jdc,recepteur,texte)
@@ -23,6 +25,7 @@ def insereMotCleDansCommande(jdc,command,texte):
 #---------------------------------------------
 # insere le texte comme 1er mot cle
 # de la commande
+    if command.name  not in jdcSet : return
     if debug : print "insereMotCle ", texte , " dans ", command.name
     numcol=chercheDebut1Mot(jdc,command)
     if numcol > 0 :
@@ -131,14 +134,17 @@ def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle):
 # cree le texte
 # appelle insereMotCle pour ajouter le texte
 #
+    boolChange=0
     texte=nouveau+"=_F(),"
+    if nomcommande  not in jdcSet : return
     commands= jdc.root.childNodes[:]
     commands.reverse()
     for c in commands:
         if c.name != nomcommande:continue
         if ensemble.verif(c) == 0 : continue
+        boolChange=1
         insereMotCle(jdc,c,texte)
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #------------------------------------------------------------------------
 def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles):
@@ -147,6 +153,7 @@ def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles):
 # cree le texte
 # appelle insereMotCle pour ajouter le texte
 #
+    if nomcommande  not in jdcSet : return
     mesRegles=regles.ensembleRegles(liste_regles)
     chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles)
     
@@ -159,12 +166,14 @@ def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle
 # cree le texte
 # appelle insereMotCle pour ajouter le texte
 #
+    if commande  not in jdcSet : return
     if estunFacteur : 
       texte=nouveau+"=_F(),"
     else :
       texte=nouveau
     commands= jdc.root.childNodes[:]
     commands.reverse()
+    boolChange=0
     for c in commands:
         if c.name != commande : continue
         for mcF in c.childNodes:
@@ -172,12 +181,14 @@ def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle
           if ensemble.verif(c) == 0 : continue
           l=mcF.childNodes[:]
           l.reverse()
+          boolChange=1
           insereMotCleDansFacteur(jdc,mcF,texte)
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #-------------------------------------------------------------------------------------------
 def AjouteMotClefDansFacteurSiRegle(jdc,commande,fact,nouveau,liste_regles,estunFacteur=0):
 #-------------------------------------------------------------------------------------------
 #
+    if commande  not in jdcSet : return
     mesRegles=regles.ensembleRegles(liste_regles)
     AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,mesRegles,estunFacteur)

diff --git a/Traducteur/jdcparser.py b/Traducteur/jdcparser.py
index 1093d363509378c3c4b1d4f463e55b4514ea52ec..2a9d764c7d686a407d31b6b412f8310b06c075a1 100644 (file)
--- a/Traducteur/jdcparser.py
+++ b/Traducteur/jdcparser.py
@@ -30,7 +30,7 @@ atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE",
           "CALC_NO","EXTR_MODE","CALC_META","IMPR_RESU","TEST_RESU",
           "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT","CALC_CHAM_ELEM",
           "AFFE_CHAR_THER", "MACR_LIGN_COUPE","POST_RCCM","PROJ_MESU_MODAL",
-          "CREA_RESU",
+          "CREA_RESU","DIST_LIGN_3D",
         )
 
 #atraiter=( "IMPR_GENE",)
@@ -41,25 +41,22 @@ def traduc(infile,outfile):
 
     #Parse les mocles des commandes
     parseKeywords(root)
+    
+    ####################### traitement erreurs #######################
+    GenereErreurPourCommande(jdc,("MACR_LIGN_COUPE","POST_RCCM","DIST_LIGN_3D"))
 
+    ####################### traitement CALC_META     #######################
     renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO")
+
+    ####################### traitement CALC_FONCTION #######################
     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,
-    #                              - nom de la procedure (pas teste avec autre chose)
-    #                              - nom du mot clef facteur contenant,
-    #                              - nom du mot cle simple
-    #          Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer
+    ####################### traitement IMPR_GENE     #######################
     moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","UNITE")
     moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","FORMAT")
 
-    #          Les arguments sont  - jdc
-    #                              - nom de l operateur (pas teste avec autre chose)
-    #                              - nom du mot clef facteur source,
-    #                              - nom du mot cle simple
-    #                              - liste de  mots clef facteur arrivée possible
-    #          Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer
+    ####################### traitement STAT/DYNA_NON_LINE #######################
     moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
     moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
     moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
@@ -68,15 +65,25 @@ def traduc(infile,outfile):
     moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
     moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
     moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS"))
-#    
-#    
+
+    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)
+
+    ####################### traitement DEFI_MATERIAU #######################
     renameMotCle(jdc,"DEFI_MATERIAU","LEMAITRE","LEMAITRE_IRRA")
     moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","QSR_K",("LEMAITRE_IRRA",))
     moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","BETA",("LEMAITRE_IRRA",))
     moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","PHI_ZERO",("LEMAITRE_IRRA",))
     moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","L",("LEMAITRE_IRRA",))
     removeMotCle(jdc,"DEFI_MATERIAU","FLU_IRRA")
-#    
+    renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","CHABOCHE","CINx_CHAB")
+
+    ####################### traitement DEFI_MATERIAU #######################
     renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","A","GRAN_A")
     renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","B","GRAN_B")
     renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","S","GRAN_S")
@@ -84,14 +91,23 @@ def traduc(infile,outfile):
     moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_B",("LEMAITRE_IRRA",))
     moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_S",("LEMAITRE_IRRA",))
     removeMotCle(jdc,"DEFI_MATERIAU","GRAN_IRRA")
-#    
+
+    ####################### traitement DEFI_MATERIAU #######################
+    chercheOperInsereFacteurSiRegle(jdc,"DEFI_MATERIAU","ELAS",((("CABLE",),"existe"),))
+    moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","E",  ("ELAS",))
+    moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","NU", ("ELAS",))
+    moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","RHO",("ELAS",))
+
+    ####################### traitement IMPR_CO       #######################
     chercheOperInsereFacteurSiRegle(jdc,"IMPR_CO","CONCEPT",((("CO",),"existe"),))
     moveMotClefInOperToFact(jdc,"IMPR_CO","CO","CONCEPT")
     renameMotCleInFact(jdc,"IMPR_CO","CONCEPT","CO","NOM")
-#    
+
+    ####################### traitement DEFI_SQUELETTE #######################
     chercheOperInsereFacteurSiRegle(jdc,"DEFI_SQUELETTE","CYCLIQUE",((("MODE_CYCL",),"existe"),))
     moveMotClefInOperToFact(jdc,"DEFI_SQUELETTE","MODE_CYCL","CYCLIQUE")
-#
+
+    ####################### traitement AFFE_CHAR_*   #######################
     removeMotCle(jdc,"AFFE_CHAR_MECA","VERI_DDL")
     removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL")
     removeMotCle(jdc,"AFFE_CHAR_THER","VERI_DDL")
@@ -101,10 +117,10 @@ def traduc(infile,outfile):
     moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_G","LISSAGE")
     moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","DEGRE","LISSAGE")
     
-#
+    ####################### traitement CALC_G   #######################
     dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"}
     ChangementValeur(jdc,"CALC_G_LOCAL_T","OPTION",dlocal)
-#
+    #
     dtheta={"CALC_G_LAGR":"G_LAGR_GLOB", "G_BILINEAIRE":"G_BILI_GLOB", "CALC_G_MAX":"G_MAX_GLOB","CALC_G":"CALC_G_GLOB"}
     # Attention si le defaut doit generer un avertissement Il faut le mettre comme dernier mot de la liste
     lavertit=("CALC_G_LAGR","CALC_G","defaut")
@@ -127,58 +143,44 @@ def traduc(infile,outfile):
     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
+    ####################### traitement 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"),))
  
-
+    ####################### traitement PROJ_MESU_MODAL #######################
     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)
-
-#
-#
+    ####################### traitement CALC_ELEM / CALC_NO #######################
+    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"}
     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")
     
-
+    ####################### traitement EXTR_MODE #######################
     AjouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF")))
 
+    ####################### traitement DYNA_TRAN_EXPLI #######################
     chercheOperInsereFacteur(jdc,"DYNA_TRAN_EXPLI","DIFF_CENT")
 
+    ####################### traitement CREA_RESU #######################
     dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"}
     lavertit=("HYDR_ELGA",)
     ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dcrearesu,lavertit)
 
+    ####################### traitement DEBUT #######################
     removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),))
 
+    ####################### traitement DEFI_THER_JOULE #######################
     removeCommande(jdc,"DEFI_THER_JOULE")
-    removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),))
-    removeCommande(jdc,"DIST_LIGN_3D")
-
-    # Pour Tests 
-    #removeMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","TOUT")
-    #SuppressionValeurs(jdc,"CALC_ELEM","OPTION",("'ERRE_ELGA_NORE'","'ERRE_ELNO_ELGA'"))
-    #SuppressionValeurs(jdc,"CALC_NO","OPTION",("'ERRE_NOEU_ELGA'",))
 
+    ####################### traitement CALC_CHAM_ELEM #######################
+    removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),))
 
     f=open(outfile,'w')
     f.write(jdc.getSource())

diff --git a/Traducteur/load.py b/Traducteur/load.py
index adca24106b3c6b37101c66cc4a0ec761b197ac90..b8f0a5aa48ef0b0d471a77eb59af9a1feb29c39b 100644 (file)
--- a/Traducteur/load.py
+++ b/Traducteur/load.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import os
+import re
 import parseur
 from mocles import parseKeywords
 

diff --git a/Traducteur/mocles.py b/Traducteur/mocles.py
index 6e304bc73d1118e0b8e216b75fe3fe6d35254636..7d2aafeb30015d345996e98f59f37324982f6317 100644 (file)
--- a/Traducteur/mocles.py
+++ b/Traducteur/mocles.py
@@ -5,6 +5,7 @@ import types
 from parseur  import Keyword, FactNode, lastparen, lastparen2,maskStringsAndComments
 from visiteur import KeywordFinder, visitor
 from utils    import indexToCoordinates
+import traceback
 
 debug=0
 
@@ -69,6 +70,9 @@ def parseKeywords(root):
     """A partir d'un arbre contenant des commandes, ajoute les noeuds 
        fils correspondant aux mocles de la commande
     """
+    #print "parseKeywords"
+    #traceback.print_stack(limit=5)
+
     matchFinder=KeywordFinder()
 
     for c in root.childNodes:

diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py
index 1c4a8d093aaaae1edf4810154febdccd16c77725..f4bd73d051a083d6350e004f161e17b5ae4e601a 100644 (file)
--- a/Traducteur/movemocle.py
+++ b/Traducteur/movemocle.py
@@ -4,6 +4,7 @@ import logging
 import removemocle
 import inseremocle
 from parseur import FactNode
+from dictErreurs import jdcSet
 debug=0
 
 #-----------------------------------------------------
@@ -11,6 +12,8 @@ def moveMotCleFromFactToFather(jdc,command,fact,mocle):
 #-----------------------------------------------------
 # exemple type : IMPR_GENE
 
+    if command not in jdcSet : return
+    boolChange=0
     for c in jdc.root.childNodes:
         if c.name != command:continue
         for mc in c.childNodes:
@@ -21,10 +24,11 @@ def moveMotCleFromFactToFather(jdc,command,fact,mocle):
                     if n.name != mocle:continue
                     if debug : print "Changement de place :", n.name, n.lineno, n.colno
                     MonTexte=n.getText(jdc);
+                    boolChange=1
                     inseremocle.insereMotCle(jdc,c,MonTexte)
                     logging.info("Changement de place :  %s,%s, %s ",n.name, n.lineno, n.colno)
             
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
     removemocle.removeMotCleInFact(jdc,command,fact,mocle)
 
 
@@ -34,14 +38,15 @@ def moveMotCleFromFactToFactMulti(jdc,oper,factsource,mocle,liste_factcible):
 # exemple type STAT_NON_LINE et RESI_INTER_RELA
     for factcible in liste_factcible :
        moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible)
-       jdc.reset(jdc.getSource())
     removemocle.removeMotCleInFact(jdc,oper,factsource,mocle)
 
 
 #----------------------------------------------------------------------------
 def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible):
 #----------------------------------------------------------------------------
+    if oper not in jdcSet : return
     if debug : print "moveMotCleFromFactToFact pour " ,oper,factsource,mocle,factcible
+    boolChange=0
     commands= jdc.root.childNodes[:]
     commands.reverse()
     for c in commands:
@@ -75,8 +80,10 @@ def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible):
               if n.name != mocle:continue
               MonTexte=n.getText(jdc);
               inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte)
+              boolChange=1
               logging.info("Changement de place :  %s,%s, %s ",n.name, n.lineno, n.colno)
               logging.info("vers :  %s", cible.name)
+    if boolChange : jdc.reset(jdc.getSource())
 
 
 
@@ -86,7 +93,9 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible):
 #------------------------------------------------------
 # Attention le cas type est THETA_OLD dans calc_G
 
+    if oper not in jdcSet : return
     if debug : print "movemocleinoper pour " ,oper,mocle,factcible
+    boolChange=9
     commands= jdc.root.childNodes[:]
     commands.reverse()
     for c in commands:
@@ -113,6 +122,7 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible):
            if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée"
            continue
         MonTexte=source.getText(jdc);
+        boolChange=1
         inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte)
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
     removemocle.removeMotCle(jdc,oper,mocle)

diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py
index fef3dfa204021ada182d933f0c19883c7024eb88..b6b84b08a021f45849bea3d079fcad714c7d11a5 100644 (file)
--- a/Traducteur/removemocle.py
+++ b/Traducteur/removemocle.py
@@ -3,6 +3,7 @@ import logging
 import regles
 from parseur import FactNode
 from dictErreurs import EcritErreur
+from dictErreurs import jdcSet
 
 #debug=1
 debug=0
@@ -14,6 +15,8 @@ debug=0
 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
+    if command not in jdcSet : return
+    boolChange=0
     commands= jdc.root.childNodes[:]
     commands.reverse()
     for c in commands:
@@ -22,43 +25,52 @@ def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle,erreur = 0):
             if mc.name != mocle:continue
             if ensemble.verif(c) == 0 : continue
             if erreur : EcritErreur((command,mocle),c.lineno)
+            boolChange=1
             removeMC(jdc,c,mc)
 
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #-------------------------------------------------------
 def removeMotCleSiRegle(jdc,command,mocle,liste_regles) :
 #-------------------------------------------------------
+    if command not in jdcSet : return
     mesRegles=regles.ensembleRegles(liste_regles)
     removeMotCle(jdc,command,mocle,mesRegles,erreur=0)
 
 #----------------------------------------------------------------
 def removeMotCleSiRegleAvecErreur(jdc,command,mocle,liste_regles) :
 #--------------------------------------------------------------
+    if command not in jdcSet : return
     mesRegles=regles.ensembleRegles(liste_regles)
     removeMotCle(jdc,command,mocle,mesRegles,erreur=1)
 
 #----------------------------------------------------------------
 def removeMotCleAvecErreur(jdc,command,mocle) :
 #--------------------------------------------------------------
+    if command not in jdcSet : return
     removeMotCle(jdc,command,mocle,erreur=1)
       
 
 #--------------------------------------------------------------------
 def removeCommande(jdc,command,ensemble=regles.SansRegle,erreur=0):
 #--------------------------------------------------------------------
+    if command not in jdcSet : return
+    boolChange=0
     commands= jdc.root.childNodes[:]
     commands.reverse()
     for c in commands:
         if c.name != command:continue
         if ensemble.verif(c) == 0 : continue
+        boolChange=1
         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)
+    if boolChange : jdc.reset(jdc.getSource())
 
 #-------------------------------------------------------------
 def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles):
 #-------------------------------------------------------------
+    if command not in jdcSet : return
     mesRegles=regles.ensembleRegles(liste_regles)
     removeCommande(jdc,command,mesRegles,1)
                 
@@ -86,8 +98,10 @@ 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
+    if command not in jdcSet : return
     commands= jdc.root.childNodes[:]
     commands.reverse()
+    boolChange=0
     for c in commands:
         if c.name != command:continue
         for mc in c.childNodes:
@@ -99,13 +113,15 @@ def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0
                     if n.name != mocle:continue
                     if ensemble.verif(c) == 0 : continue
                     if erreur : EcritErreur((command,fact,mocle),c.lineno)
+                    boolChange=1
                     removeMC(jdc,c,n)
 
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #------------------------------------------------------------------
 def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles):
 #------------------------------------------------------------------
+    if command not in jdcSet : return
     erreur=0
     mesRegles=regles.ensembleRegles(liste_regles)
     removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur)
@@ -113,6 +129,7 @@ def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles):
 #----------------------------------------------------------------------
 def removeMotCleInFactSiRegleAvecErreur(jdc,command,fact,mocle,liste_regles):
 #----------------------------------------------------------------------
+    if command not in jdcSet : return
     erreur=1
     mesRegles=regles.ensembleRegles(liste_regles)
     removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur)

diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py
index 1f613fc33b9acf696ee960e2dd443b8e5e916af4..f6dab579a8be69167fd845db1b876497f02d4a0f 100644 (file)
--- a/Traducteur/renamemocle.py
+++ b/Traducteur/renamemocle.py
@@ -2,6 +2,7 @@
 import logging
 import sys
 from parseur import FactNode
+from dictErreurs import jdcSet
 import regles
 from dictErreurs import EcritErreur
 #debug=1
@@ -13,10 +14,13 @@ debug=0
 #--------------------------------------------------------------------------------
 def renameMotCle(jdc,command,mocle,new_name, erreur=0):
 #--------------------------------------------------------------------------------
+    if command not in jdcSet : return
+    boolChange=0
     for c in jdc.root.childNodes:
         if c.name != command:continue
         for mc in c.childNodes:
             if mc.name != mocle:continue
+            boolChange=1
             if debug:print "Renommage de:",c.name,mc.name,mc.lineno,mc.colno
             if erreur :
                EcritErreur((command,mocle),c.lineno)
@@ -27,25 +31,30 @@ def renameMotCle(jdc,command,mocle,new_name, erreur=0):
             diff=len(new_name) - len(mocle)
             decaleLignesdeNBlancs(jdc,mc.lineno,mc.endline-1,diff)
 
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
                 
 #------------------------------------------------------
 def renameMotCleAvecErreur(jdc,command,mocle,new_name):
 #------------------------------------------------------
+    if command not in jdcSet : return
     renameMotCle(jdc,command,mocle,new_name,1)
 
 #-------------------------------------------
 def renameOper(jdc,command,new_name):
 #-------------------------------------------
+    if command not in jdcSet : return
+    jdcSet.add(new_name)
+    boolChange=0
     for c in jdc.root.childNodes:
         if c.name != command:continue
         if debug:print "Renommage de:",c.name,c.lineno,c.colno
         logging.info("Renommage de: %s, %s, %s, en %s",c.name,c.lineno,c.colno,new_name)
+        boolChange=1
         s=jdc.getLines()[c.lineno-1]
         jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):]
         diff=len(new_name) - len(command)
         decaleLignesdeNBlancs(jdc,c.lineno,c.endline,diff)
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #----------------------------------------------------------
 def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc):
@@ -64,6 +73,8 @@ def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc):
 #----------------------------------------------------------
 def renameMotCleInFact(jdc,command,fact,mocle,new_name):
 #----------------------------------------------------------
+    if command not in jdcSet : return
+    boolChange=0
     for c in jdc.root.childNodes:
         if c.name != command:continue
         for mc in c.childNodes:
@@ -76,14 +87,18 @@ def renameMotCleInFact(jdc,command,fact,mocle,new_name):
                     if n.name != mocle:continue
                     s=jdc.getLines()[n.lineno-1]
                     jdc.getLines()[n.lineno-1]=s[:n.colno]+new_name+s[n.colno+len(mocle):]
+                    boolChange=1
                     logging.info("Renommage de: %s, %s, %s, en %s",n.name,n.lineno,n.colno,new_name)
 
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #-----------------------------------------------------------------
 def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle):
 #-----------------------------------------------------------------
 # nom de la commande "ancien format" , nom de la commande " nouveau format "
+    if command not in jdcSet : return
+    jdcSet.add(new_name)
+    boolChange=0
     if debug :
         if ensemble != regles.SansRegle :
           logging.info("Traitement de %s renomme en %s sous conditions", command, new_name)
@@ -92,17 +107,19 @@ def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle):
     for c in jdc.root.childNodes:
         if c.name != command:continue
         if ensemble.verif(c) == 0 : continue
+        boolChange=1
         if debug:print "Renommage de:",c.name,new_name ,c.lineno,c.colno
         logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,"",c.lineno,c.colno,new_name)
         s=jdc.getLines()[c.lineno-1]
         jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):]
 
-    jdc.reset(jdc.getSource())
+    if boolChange : jdc.reset(jdc.getSource())
 
 #-----------------------------------------------------------
 def renameCommandeSiRegle(jdc,command,new_name,liste_regles):
 #-----------------------------------------------------------
     
+    if command not in jdcSet : return
     mesRegles=regles.ensembleRegles(liste_regles)
     renameCommande(jdc,command,new_name,mesRegles)