From 1b44dff96cea69a0a9fcf7d59b336dcd5dd9080d Mon Sep 17 00:00:00 2001 From: Renaud Barate Date: Mon, 7 Mar 2011 16:24:21 +0000 Subject: [PATCH] Integrated modifications in Traducteur from Isabelle --- Traducteur/dictErreurs.py | 34 ++ Traducteur/inseremocle.py | 10 +- Traducteur/movemocle.py | 97 +++++- Traducteur/regles.py | 27 +- Traducteur/removemocle.py | 4 +- Traducteur/traduitV9V10.py | 679 +++++++++++++++++++++++++++++++++++++ 6 files changed, 845 insertions(+), 6 deletions(-) create mode 100755 Traducteur/traduitV9V10.py diff --git a/Traducteur/dictErreurs.py b/Traducteur/dictErreurs.py index 85d9fe66..086da0ec 100644 --- a/Traducteur/dictErreurs.py +++ b/Traducteur/dictErreurs.py @@ -55,3 +55,37 @@ def GenereErreurMotCleInFact(jdc,command,fact,mocle): else : EcritErreur((command,fact,mocle,),c.lineno) +def GenereErreurMCF(jdc,command,fact): + for c in jdc.root.childNodes: + if c.name != command:continue + for mc in c.childNodes: + if mc.name != fact: + continue + else : + EcritErreur((command,fact,),c.lineno) + +def GenereErreurValeur(jdc,command,fact,list_valeur): + for c in jdc.root.childNodes: + if c.name != command:continue + for mc in c.childNodes: + if mc.name != fact:continue + texte=mc.getText(jdc) + for valeur in list_valeur: + trouve=texte.find(valeur) + if trouve > -1 : + logging.warning("%s doit etre supprimee ou modifiee dans %s : ligne %d",valeur,c.name,mc.lineno) + +def GenereErreurValeurDsMCF(jdc,command,fact,mocle,list_valeur): + for c in jdc.root.childNodes: + if c.name != command:continue + for mc in c.childNodes: + if mc.name != fact:continue + l=mc.childNodes[:] + for ll in l: + for n in ll.childNodes: + if n.name != mocle:continue + texte=n.getText(jdc) + for valeur in list_valeur: + trouve=texte.find(valeur) + if trouve > -1 : + logging.warning("%s doit etre supprimee ou modifiee dans %s : ligne %d",valeur,c.name,n.lineno) diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index f8307f5e..b3fdaea4 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -32,7 +32,7 @@ def insereMotCleDansCommande(jdc,command,texte): if numcol > 0 : jdc.splitLine(command.lineno,numcol) indice = -1 - while texte[indice] == " " : + while texte[indice] == " " or texte[indice] == "\n": indice = indice -1 if texte[indice] != "," : texte=texte+"," texteinfo=texte @@ -204,6 +204,14 @@ def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles, estunF if nomcommande not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur) + +#---------------------------------------------------------------------------------------- +def chercheOperInsereMotCleSiRegle(jdc,nomcommande,nouveau,liste_regles, estunFacteur=0): +#---------------------------------------------------------------------------------------- + if nomcommande not in jdcSet : return + mesRegles=regles.ensembleRegles(liste_regles) + chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur) + #--------------------------------------------------------------------------------------------------------- def chercheOperInsereFacteurSiRegleAvecAvertissement(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1): diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index fef05893..293d4b0a 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -3,7 +3,7 @@ import logging import removemocle import inseremocle -from parseur import FactNode +from parseur import lastparen from dictErreurs import jdcSet debug=0 @@ -18,18 +18,22 @@ def moveMotCleFromFactToFather(jdc,command,fact,mocle): commands.reverse() for c in commands: if c.name != command:continue + boolchange_c=0 for mc in c.childNodes: if mc.name != fact:continue l=mc.childNodes[:] for ll in l: for n in ll.childNodes: if n.name != mocle:continue + # test boolchange_c :il faut le faire une seule fois par commande sinon duplication du mot clé + if boolchange_c != 0 :continue if debug : print "Changement de place :", n.name, n.lineno, n.colno MonTexte=n.getText(jdc); boolChange=1 + boolchange_c=1 inseremocle.insereMotCle(jdc,c,MonTexte) logging.info("Changement de place %s ligne %s ",n.name, n.lineno) - + if boolChange : jdc.reset(jdc.getSource()) removemocle.removeMotCleInFact(jdc,command,fact,mocle) @@ -127,3 +131,92 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible): inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) if boolChange : jdc.reset(jdc.getSource()) removemocle.removeMotCle(jdc,oper,mocle) + +#------------------------------------------------------ +def copyMotClefInOperToFact(jdc,oper,mocle,factcible): +#------------------------------------------------------ + + 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: + if c.name != oper : continue + cible=None + for mc in c.childNodes: + if mc.name != factcible : + continue + else : + cible=mc + break + if cible==None : + if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" + continue + + source=None + for mc in c.childNodes: + if mc.name != mocle: + continue + else : + source=mc + break + if source==None : + 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) + if boolChange : jdc.reset(jdc.getSource()) + +#---------------------------------------------------------------------- +def moveMCFToCommand(jdc,command,factsource,commandcible,factcible): +#---------------------------------------------------------------------- +# exemple CONTACT en 10 +# CONTACT devient commande DEFI_CONTACT/ZONE +# + if command not in jdcSet : return + boolChange=0 + commands= jdc.root.childNodes[:] + commands.reverse() + for c in commands: + if c.name != command : continue + for mcF in c.childNodes: + if mcF.name != factsource : continue + l=mcF.getText(jdc) + texte=l.replace(factsource,factcible) + texte='xxxx='+commandcible+'('+texte+')\n' + jdc.splitLine(c.lineno,0) + jdc.addLine(texte,c.lineno) + logging.info("Deplacement de %s dans %s ligne %s",factsource,commandcible,c.lineno) + boolChange=1 + if boolChange : + jdc.reset(jdc.getSource()) + jdcSet.add(commandcible) + +#-------------------------------------------------------------------- +def EclaMotCleToFact(jdc,command,motcle,mot1,mot2,defaut=0): +#-------------------------------------------------------------------------- +# exemple STA10 pesanteur devient MCF avec eclatement des valeurs dans les MC +# On suppose que le MC est sur une seule ligne + if command not in jdcSet : return + boolChange=0 + for c in jdc.root.childNodes: + if c.name != command : continue + trouveUnMC=0 + for mc in c.childNodes: + if mc.name != motcle : continue + trouveUnMC=1 + TexteMC=mc.getText(jdc) + indexLigneGlob=mc.lineno-1 + MaLigneGlob=jdc.getLines()[indexLigneGlob] + Ligne=TexteMC.split('(')[1].split(')')[0].split(',') + motcle1=mot1+"="+Ligne[0] + motcle2=mot2+"=("+Ligne[1]+','+Ligne[2]+','+Ligne[3]+')' + texte=motcle+'=_F('+motcle1+','+motcle2+')' + num=lastparen(TexteMC) + Nouveau=MaLigneGlob.replace(TexteMC[0:num],texte) + jdc.getLines()[indexLigneGlob]=Nouveau + logging.info("Transformation de %s dans %s ligne %s",motcle,command,c.lineno) + boolChange=1 + if boolChange : jdc.reset(jdc.getSource()) diff --git a/Traducteur/regles.py b/Traducteur/regles.py index d07c7b9c..60248fab 100644 --- a/Traducteur/regles.py +++ b/Traducteur/regles.py @@ -158,6 +158,31 @@ class MCsousMCFaPourValeur : if (TexteMC.find(self.Val) < 0 ): continue bool=1 return bool +#----------------------------- +class MCsousMCFaPourValeurDansListe : +#---------------------------- + def __init__(self,list_arg): + assert (len(list_arg)==4) + self.genea=list_arg[0:-2] + self.MCF=list_arg[0] + self.MC=list_arg[1] + self.LVal=list_arg[2] + self.Jdc=list_arg[3] + + def verif(self,commande): + bool=0 + for mcf in commande.childNodes : + if mcf.name != self.MCF : continue + l=mcf.childNodes[:] + l.reverse() + for ll in l: + for mc in ll.childNodes: + if mc.name != self.MC : continue + TexteMC=mc.getText(self.Jdc) + for Val in self.LVal: + if (TexteMC.find(Val) < 0 ): continue + bool=1 + return bool #------------------------------- class MCaPourValeur : @@ -177,5 +202,5 @@ class MCaPourValeur : bool=1 return bool -dictionnaire_regle={"existe":existe,"nexistepas":nexistepas,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur,"MCaPourValeur":MCaPourValeur} +dictionnaire_regle={"existe":existe,"nexistepas":nexistepas,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur,"MCsousMCFaPourValeurDansListe":MCsousMCFaPourValeurDansListe,"MCaPourValeur":MCaPourValeur} SansRegle=pasDeRegle() diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index 5f633578..212bc4b7 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -64,7 +64,7 @@ def removeCommande(jdc,command,ensemble=regles.SansRegle,erreur=0): boolChange=1 if erreur : EcritErreur((command,),c.lineno) jdc.supLignes(c.lineno,c.endline) - logging.warning("Suppression de: %s ligne %s",c.name,c.lineno) + logging.warning("Suppression de %s ligne %s",c.name,c.lineno) if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------------- @@ -78,7 +78,7 @@ def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles): def removeMC(jdc,c,mc): #--------------------------------- if debug : print "Suppression de:",c.name,mc.name,mc.lineno,mc.colno,mc.endline,mc.endcol - logging.info("Suppression de: %s, %s, ligne %d",c.name,mc.name,mc.lineno) + logging.info("Suppression de %s dans %s ligne %d",mc.name,c.name,mc.lineno) if mc.endline > mc.lineno: if debug:print "mocle sur plusieurs lignes--%s--" % jdc.getLines()[mc.lineno-1][mc.colno:] diff --git a/Traducteur/traduitV9V10.py b/Traducteur/traduitV9V10.py new file mode 100755 index 00000000..5df0872d --- /dev/null +++ b/Traducteur/traduitV9V10.py @@ -0,0 +1,679 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +""" +usage="""usage: %prog [options] +Typical use is: + python traduitV9V10.py --infile=xxxx --outfile=yyyy +""" + +import log +import optparse +import sys + +from load import getJDC +from mocles import parseKeywords +from removemocle import * +from renamemocle import * +from renamemocle import * +from inseremocle import * +from changeValeur import * +from movemocle import * +from dictErreurs import * +from regles import pasDeRegle + +atraiter=("STAT_NON_LINE","CALC_PRECONT","DYNA_NON_LINE","THER_LINEAIRE","THER_NON_LINE","THER_NON_LINE_MO","DYNA_LINE_HARM","DYNA_LINE_TRAN", + "MACRO_MATR_AJOU","DYNA_TRAN_MODAL","MECA_STATIQUE","MODE_STATIQUE","MACR_ASCOUF_CALC","MACR_ASPIQ_CALC","SIMU_POINT_MAT", + "IMPR_RESU","DYNA_TRAN_MODAL","AFFE_CHAR_MECA","AFFE_CHAR_MECA_F","PROJ_CHAMP","CALCUL","POST_GP","CALC_G","COMB_SISM_MODAL", + "DEFI_BASE_MODALE","LIRE_RESU","CALC_NO","MACR_ECREVISSE","DEFI_COMPOR","IMPR_MATRICE","DEFI_MATERIAU","MACR_ADAP_MAIL","AFFE_CHAR_CINE", + "MODE_ITER_SIMULT","MODE_ITER_INV","POST_CHAM_XFEM","AFFE_CARA_ELEM","CALC_MODAL","MACR_INFO_MAIL","POST_ZAC","CALC_ELEM","CREA_CHAMP", + "CALC_CHAM_ELEM","TEST_RESU", "CREA_RESU","EXTR_RESU","MACRO_ELAS_MULT","MODI_REPERE","POST_ELEM","RECU_FONCTION","DYNA_ISS_VARI","DEFI_GLRC", + "CALC_META","REST_GENE_PHYS","REST_SPEC_PHYS","COMB_FOURIER","POST_K1_K2_K3","MACR_LIGN_COUPE","POST_RELEVE_T", + "DEFI_CONTACT","DEFI_LIST_INST", + ) + +dict_erreurs={ +# STA10 +# + "AFFE_CHAR_MECA_CONTACT":"Modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_LIAISON_UNILATER":"Modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_F_LIAISON_UNILATER":"Modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_GRAPPE_FLUIDE":"Resorption de GRAPPE_FLUIDE en STA10", + "DEFI_MATERIAU_LMARC":"Resorption loi LMARC en STA10", + "DEFI_MATERIAU_LMARC_FO":"Resorption loi LMARC en STA10", + "POST_ZAC":"Resorption POST_ZAC en STA10", + "AFFE_CHAR_MECA_ARLEQUIN":"Resorption ARLEQUIN en STA10", + + "PROJ_CHAMP_CHAM_NO":"Attention, verifier pour PROJ_CHAMP la présence de MODELE1/MAILLAGE1 et MODELE2/MAILLAGE2", + + "COMB_SISM_MODAL_EXCIT_MULTI_APPUI":"Preciser GROUP_APPUI si les excitations ne sont pas toutes decorrélées entre elles", + + "CALC_PRECONT_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "CALC_PRECONT_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_LINE_HARM_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_LINE_HARM_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_LINE_TRAN_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_LINE_TRAN_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_TRAN_MODAL_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_TRAN_MODAL_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MACR_ASCOUF_CALC_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MACR_ASCOUF_CALC_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MACR_ASPIQ_CALC_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MACR_ASPIQ_CALC_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MACRO_MATR_AJOU_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MACRO_MATR_AJOU_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MECA_STATIQUE_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MECA_STATIQUE_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MODE_STATIQUE_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "MODE_STATIQUE_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "STAT_NON_LINE_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "STAT_NON_LINE_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "THER_LINEAIRE_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "THER_LINEAIRE_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "THER_NON_LINE_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "THER_NON_LINE_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_NON_LINE_SOLVEUR_PARALLELISME":"Modification du PARALLELISME qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + "DYNA_NON_LINE_SOLVEUR_PARTITION":"Modification de PARTITION qui se definit au niveau de AFFE_MODELE ou MODI_MODELE", + + "STAT_NON_LINE_INCREMENT":"La subdivision des pas est mise dans la commande DEFI_LIST_INST. Verifier DEFI_LIST_INST et son appel dans STAT_NON_LINE", + "CALC_PRECONT_INCREMENT":"La subdivision des pas est mise dans la commande DEFI_LIST_INST. Verifier DEFI_LIST_INST et son appel dans STAT_NON_LINE", + "DYNA_NON_LINE_INCREMENT":"La subdivision des pas est mise dans la commande DEFI_LIST_INST. Verifier DEFI_LIST_INST et son appel dans STAT_NON_LINE", + "MACR_ASCOUF_CALC_INCREMENT":"La subdivision des pas est mise dans la commande DEFI_LIST_INST. Verifier DEFI_LIST_INST et son appel dans STAT_NON_LINE", + "MACR_ASPIQ_CALC_INCREMENT":"La subdivision des pas est mise dans la commande DEFI_LIST_INST. Verifier DEFI_LIST_INST et son appel dans STAT_NON_LINE", + "SIMU_POINT_MAT_INCREMENT":"La subdivision des pas est mise dans la commande DEFI_LIST_INST. Verifier DEFI_LIST_INST et son appel dans STAT_NON_LINE", + + "CALC_ELEM_SENSIBILITE":"Le post-traitement SENSIBILITE est à supprimer de CALC_ELEM et à faire via CALC_SENSI", + } + +sys.dict_erreurs=dict_erreurs + +def traduc(infile,outfile,flog=None): + + hdlr=log.initialise(flog) + jdc=getJDC(infile,atraiter) + root=jdc.root + + #Parse les mocles des commandes + parseKeywords(root) + + ####################### initialisation et traitement des erreurs ######################### + + + #####RESORPTION + + GenereErreurPourCommande(jdc,("POST_ZAC",)) + GenereErreurMCF(jdc,"AFFE_CHAR_MECA","GRAPPE_FLUIDE") + GenereErreurMCF(jdc,"DEFI_MATERIAU","LMARC") + GenereErreurMCF(jdc,"DEFI_MATERIAU","LMARC_FO") + GenereErreurMCF(jdc,"AFFE_CHAR_MECA","ARLEQUIN") + + + #####SOLVEUR + + ####################### traitement MUMPS/PARALELLISME-PARTITION ################## + #commandes concernes en plus : CALC_FORC_AJOU?,CALC_MATR_AJOU? + # */SOLVEUR/CHARGE_PROCO_MA(SD)--> AFFE_MODELE (ou MODI_MODELE)/PARTITION/. + # */SOLVEUR/PARALLELISME =CENTRALISE--> AFFE_MODELE (ou MODI_MODELE)/PARTITION/PARALLELISME = CENTRALISE + # */SOLVEUR/PARALLELISME = "DISTRIBUE_MC/MD/SD"--> AFFE_MODELE/PARTITION/PARALLELISME = "MAIL_CONTIGU/MAIL_DISPERSE/SOUS_DOMAINE" + # */SOLVEUR/PARTITION --> AFFE_MODELE (ou MODI_MODELE)/PARTITION/PARTITION + + + GenereErreurMotCleInFact(jdc,"CALC_PRECONT","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"CALC_PRECONT","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"DYNA_LINE_HARM","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"DYNA_LINE_HARM","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"DYNA_LINE_TRAN","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"DYNA_LINE_TRAN","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"DYNA_TRAN_MODAL","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"DYNA_TRAN_MODAL","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"MACR_ASCOUF_CALC","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"MACR_ASCOUF_CALC","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"MACR_ASPIQ_CALC","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"MACR_ASPIQ_CALC","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"MACRO_MATR_AJOU","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"MACRO_MATR_AJOU","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"MECA_STATIQUE","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"MECA_STATIQUE","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"MODE_STATIQUE","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"MODE_STATIQUE","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"STAT_NON_LINE","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"STAT_NON_LINE","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"THER_LINEAIRE","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"THER_LINEAIRE","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"THER_NON_LINE","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"THER_NON_LINE","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"THER_NON_LINE_MO","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"THER_NON_LINE_MO","SOLVEUR","PARTITION") + GenereErreurMotCleInFact(jdc,"DYNA_NON_LINE","SOLVEUR","PARALLELISME") + GenereErreurMotCleInFact(jdc,"DYNA_NON_LINE","SOLVEUR","PARTITION") + + ####################### traitement mot cle INCREMENT redecoupage en temps ####################### + renameMotCleSiRegle(jdc,"STAT_NON_LINE","INCREMENT","INCREMENT_NEW",((("INCREMENT","SUBD_METHODE"),"existeMCsousMCF"),),1) + moveMCFToCommand(jdc,"STAT_NON_LINE","INCREMENT_NEW","DEFI_LIST_INST","ECHEC") + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_COEF_PAS_1",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_ITER_FIN",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_ITER_IGNO",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_ITER_PLUS",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_METHODE",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_NIVEAU",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_OPTION",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT_NEW","SUBD_PAS_MINI",pasDeRegle(),0) + renameMotCle(jdc,"STAT_NON_LINE","INCREMENT_NEW","INCREMENT") + + renameMotCleSiRegle(jdc,"CALC_PRECONT","INCREMENT","INCREMENT_NEW",((("INCREMENT","SUBD_METHODE"),"existeMCsousMCF"),),1) + moveMCFToCommand(jdc,"CALC_PRECONT","INCREMENT_NEW","DEFI_LIST_INST","ECHEC") + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_COEF_PAS_1",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_ITER_FIN",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_ITER_IGNO",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_ITER_PLUS",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_METHODE",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_NIVEAU",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_OPTION",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_PRECONT","INCREMENT_NEW","SUBD_PAS_MINI",pasDeRegle(),0) + renameMotCle(jdc,"CALC_PRECONT","INCREMENT_NEW","INCREMENT") + + + renameMotCleSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","INCREMENT_NEW",((("INCREMENT","SUBD_METHODE"),"existeMCsousMCF"),),1) + moveMCFToCommand(jdc,"DYNA_NON_LINE","INCREMENT_NEW","DEFI_LIST_INST","ECHEC") + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_COEF_PAS_1",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_ITER_FIN",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_ITER_IGNO",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_ITER_PLUS",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_METHODE",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_NIVEAU",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_OPTION",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT_NEW","SUBD_PAS_MINI",pasDeRegle(),0) + renameMotCle(jdc,"DYNA_NON_LINE","INCREMENT_NEW","INCREMENT") + + renameMotCleSiRegle(jdc,"MACR_ASCOUF_CALC","INCREMENT","INCREMENT_NEW",((("INCREMENT","SUBD_METHODE"),"existeMCsousMCF"),),1) + moveMCFToCommand(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","DEFI_LIST_INST","ECHEC") + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_COEF_PAS_1",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_ITER_FIN",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_ITER_IGNO",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_ITER_PLUS",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_METHODE",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_NIVEAU",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_OPTION",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","SUBD_PAS_MINI",pasDeRegle(),0) + renameMotCle(jdc,"MACR_ASCOUF_CALC","INCREMENT_NEW","INCREMENT") + + renameMotCleSiRegle(jdc,"MACR_ASPIQ_CALC","INCREMENT","INCREMENT_NEW",((("INCREMENT","SUBD_METHODE"),"existeMCsousMCF"),),1) + moveMCFToCommand(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","DEFI_LIST_INST","ECHEC") + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_COEF_PAS_1",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_ITER_FIN",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_ITER_IGNO",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_ITER_PLUS",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_METHODE",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_NIVEAU",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_OPTION",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","SUBD_PAS_MINI",pasDeRegle(),0) + renameMotCle(jdc,"MACR_ASPIQ_CALC","INCREMENT_NEW","INCREMENT") + + renameMotCleSiRegle(jdc,"SIMU_POINT_MAT","INCREMENT","INCREMENT_NEW",((("INCREMENT","SUBD_METHODE"),"existeMCsousMCF"),),1) + moveMCFToCommand(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","DEFI_LIST_INST","ECHEC") + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_COEF_PAS_1",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_ITER_FIN",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_ITER_IGNO",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_ITER_PLUS",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_METHODE",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_NIVEAU",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_OPTION",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","SUBD_PAS_MINI",pasDeRegle(),0) + renameMotCle(jdc,"SIMU_POINT_MAT","INCREMENT_NEW","INCREMENT") + + removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","INST_INIT") + removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","INST_FIN") + removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","NUME_INST_FIN") + removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","NUME_INST_INIT") + removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","PRECISION") + chercheOperInsereFacteur(jdc,"DEFI_LIST_INST","DEFI_LIST",pasDeRegle(),1) + moveMotCleFromFactToFact(jdc,"DEFI_LIST_INST","ECHEC","LIST_INST","DEFI_LIST") + removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","LIST_INST") + + ###################### traitement de NPREC_SOLVEUR ########## + removeMotCleInFact(jdc,"MODE_ITER_SIMULT","CALC_FREQ","NPREC_SOLVEUR",pasDeRegle(),0) + removeMotCleInFact(jdc,"MODE_ITER_INV","CALC_FREQ","NPREC_SOLVEUR",pasDeRegle(),0) + removeMotCleInFact(jdc,"CALC_MODAL","CALC_FREQ","NPREC_SOLVEUR",pasDeRegle(),0) + removeMotCle(jdc,"IMPR_STURM","NPREC_SOLVEUR") + removeMotCleInFact(jdc,"MACRO_MATR_AJOU","CALC_FREQ","NPREC_SOLVEUR",pasDeRegle(),0) + + ###################### traitement CALC_MODAL SOLVEUR ############ + removeMotCle(jdc,"CALC_MODAL","SOLVEUR",pasDeRegle()) + + ##################### traitement DYNA_TRAN-MODAL ADAPT ################# + ChangementValeur(jdc,"DYNA_TRAN_MODAL","METHODE",{"ADAPT":"ADAPT_ORDRE2"}) + + #################### traitement STAT/DYNA_NON_LINE SUIVI_DDL=NON ########### + removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","OBSERVATION","SUIVI_DDL",((("OBSERVATION","SUIVI_DDL","NON",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","OBSERVATION","SUIVI_DDL",((("OBSERVATION","SUIVI_DDL","NON",jdc),"MCsousMCFaPourValeur"),)) + + #####COMPORTEMENT/CARA + + ################### traitement COMP_ELAS et COMP_INCR DEFORMATION = GREEN ##############" + dGREEN={"GREEN_GR":"GROT_GDEP","GREEN":"GROT_GDEP","REAC_GEOM":"GROT_GDEP","EULER_ALMANSI":"GROT_GDEP","COROTATIONNEL":"GDEF_HYPO_ELAS"} + ChangementValeurDsMCF(jdc,"SIMU_POINT_MAT","COMP_ELAS","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_ELAS","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_ELAS","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"CALCUL","COMP_ELAS","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"POST_GP","COMP_ELAS","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"CALC_G","COMP_ELAS","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"SIMU_POINT_MAT","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"CALCUL","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"CALC_PRECONT","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"CALC_NO","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"LIRE_RESU","COMP_INCR","DEFORMATION",dGREEN) + ChangementValeurDsMCF(jdc,"MACR_ECREVISSE","COMP_INCR","DEFORMATION",dGREEN) + + ###################### traitement COMP_INCR/COMP_ELAS RESO_INTE ########## + dALGOI={"RUNGE_KUTTA_2":"RUNGE_KUTTA","RUNGE_KUTTA_4":"RUNGE_KUTTA"} + removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","COMP_ELAS","RESO_INTE",((("COMP_ELAS","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","COMP_ELAS","RESO_INTE",((("COMP_ELAS","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"CALCUL","COMP_ELAS","RESO_INTE",((("COMP_ELAS","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"CALCUL","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"MACR_ASCOUF_CALC","COMP_ELAS","RESO_INTE",((("COMP_ELAS","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"MACR_ASCOUF_CALC","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"MACR_ASPIQ_CALC","COMP_ELAS","RESO_INTE",((("COMP_ELAS","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"MACR_ASPIQ_CALC","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"SIMU_POINT_MAT","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"CALC_PRE_CONT","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"CALC_NO","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"LIRE_RESU","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle(jdc,"MACR_ECREVISSE","COMP_INCR","RESO_INTE",((("COMP_INCR","RESO_INTE","IMPLICITE",jdc),"MCsousMCFaPourValeur"),)) + + ChangementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_ELAS","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_ELAS","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"CALCUL","COMP_ELAS","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"CALCUL","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"MACR_ASCOUF_CALC","COMP_ELAS","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"MACR_ASCOUF_CALC","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"MACR_ASPIQF_CALC","COMP_ELAS","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"MACR_ASPIQ_CALC","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"SIMU_POINT_MAT","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"CALC_PRECONT","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"CALC_NO","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"LIRE_RESU","COMP_INCR","RESO_INTE",dALGOI) + ChangementValeurDsMCF(jdc,"MACR_ECREVISSE","COMP_INCR","RESO_INTE",dALGOI) + + renameMotCleInFact(jdc,"STAT_NON_LINE","COMP_ELAS","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"STAT_NON_LINE","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"DYNA_NON_LINE","COMP_ELAS","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"DYNA_NON_LINE","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"CALCUL","COMP_ELAS","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"CALCUL","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"MACR_ASCOUF_CALC","COMP_ELAS","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"MACR_ASCOUF_CALC","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"MACR_ASPIQF_CALC","COMP_ELAS","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"MACR_ASPIQ_CALC","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"SIMU_POINT_MAT","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"CALC_PRECONT","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"CALC_NO","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"LIRE_RESU","COMP_INCR","RESO_INTE","ALGO_INTE") + renameMotCleInFact(jdc,"MACR_ECREVISSE","COMP_INCR","RESO_INTE","ALGO_INTE") + + ###################### traitement COMP_ELAS/ITER_INTE_PAS ###### + removeMotCleInFact(jdc,"CALCUL","COMP_ELAS","ITER_INTE_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","COMP_ELAS","ITER_INTE_PAS",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","COMP_ELAS","ITER_INTE_PAS",pasDeRegle(),0) + + ###################### traitement CALC_G/COMP_INCR/RELATION ELAS_VMIS_PUIS #### + ChangementValeurDsMCF(jdc,"CALC_G","COMP_INCR","RELATION",{"ELAS_VMIS_PUIS":"VMIS_ISOT_PUIS"}) + + ########################" traitement DEFI_COMPOR/MULTIFIBRE/DEFORMATION=REAC_GEOM ######### + ChangementValeurDsMCF(jdc,"DEFI_COMPOR","MULTIFIBRE","DEFORMATION",dGREEN) + + ####################### traitement DEFI_COMPOR/MONOCRISTAL/ECOULEMENT ############# + dECOULEMENT={"ECOU_VISC1":"MONO_VISC1","ECOU_VISC2":"MONO_VISC2","ECOU_VISC3":"MONO_VISC3","KOCKS_RAUCH":"MONO_DD_KR"} + ChangementValeurDsMCF(jdc,"DEFI_COMPOR","MONOCRISTAL","ECOULEMENT",dECOULEMENT) + dISOT={"ECRO_ISOT1":"MONO_ISOT1","ECRO_ISOT2":"MONO_ISOT2"} + dCINE={"ECRO_CINE1":"MONO_CINE1","ECRO_CINE2":"MONO_CINE2"} + ChangementValeurDsMCF(jdc,"DEFI_COMPOR","MONOCRISTAL","ECRO_ISOT",dISOT) + ChangementValeurDsMCF(jdc,"DEFI_COMPOR","MONOCRISTAL","ECRO_CINE",dCINE) + + ################### traitement DEFI_MATERIAU monocristallin ####### + renameMotCle(jdc,"DEFI_MATERIAU","ECOU_VISC1","MONO_VISC1") + renameMotCle(jdc,"DEFI_MATERIAU","ECOU_VISC2","MONO_VISC2") + renameMotCle(jdc,"DEFI_MATERIAU","ECOU_VISC3","MONO_VISC3") + renameMotCle(jdc,"DEFI_MATERIAU","ECRO_CINE1","MONO_CINE1") + renameMotCle(jdc,"DEFI_MATERIAU","ECRO_CINE2","MONO_CINE2") + renameMotCle(jdc,"DEFI_MATERIAU","ECRO_ISOT1","MONO_ISOT1") + renameMotCle(jdc,"DEFI_MATERIAU","ECRO_ISOT2","MONO_ISOT2") + renameMotCle(jdc,"DEFI_MATERIAU","KOCKS_RAUCH","MONO_DD_KR") + + ################ traitement DEFI_MATERIAU/THER_HYDR ####### + removeMotCleInFact(jdc,"DEFI_MATERIAU","THER_HYDR","QSR_K") + + ##################### traitement AFFE_CARA_ELEM/DISCRET ###############" + dDISCRET={"K_T_N_NS":"K_T_N", "K_T_L_NS":"K_T_L", "K_TR_N_NS":"K_TR_N", "K_TR_L_NS":"K_TR_L", + "M_T_N_NS":"M_T_N", "M_T_L_NS":"M_T_L", "M_TR_N_NS":"M_TR_N", "M_TR_L_NS":"M_TR_L", + "A_T_N_NS":"A_T_N", "A_T_L_NS":"A_T_L", "A_TR_N_NS":"A_TR_N", "A_TR_L_NS":"A_TR_L"} + dlist_DISCRET=["K_T_N_NS","K_T_L_NS", "K_TR_N_NS","K_TR_L_NS","M_T_N_NS","M_T_L_NS","M_TR_N_NS","M_TR_L_NS","A_T_N_NS","A_T_L_NS","A_TR_N_NS","A_TR_L_NS"] + + removeMotCleInFact(jdc,"AFFE_CARA_ELEM","DISCRET_2D","SYME") + removeMotCleInFact(jdc,"AFFE_CARA_ELEM","DISCRET","SYME") + AjouteMotClefDansFacteurSiRegle(jdc,"AFFE_CARA_ELEM","DISCRET","SYME='NON'",((("DISCRET","CARA",dlist_DISCRET,jdc),"MCsousMCFaPourValeurDansListe"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"AFFE_CARA_ELEM","DISCRET_2D","SYME='NON'",((("DISCRET_2D","CARA",dlist_DISCRET,jdc),"MCsousMCFaPourValeurDansListe"),)) + ChangementValeurDsMCF(jdc,"AFFE_CARA_ELEM","DISCRET_2D","CARA",dDISCRET) + ChangementValeurDsMCF(jdc,"AFFE_CARA_ELEM","DISCRET","CARA",dDISCRET) + + #####CHARGEMENT + + ####################### traitement CONTACT ############################################### + + + renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","ITER_MULT_MAXI","ITER_CONT_MULT") + renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","NB_REAC_GEOM","NB_ITER_GEOM") + AjouteMotClefDansFacteurSiRegle(jdc,"AFFE_CHAR_MECA","CONTACT","RESOLUTION='NON'",((("CONTACT","METHODE","VERIF",jdc),"MCsousMCFaPourValeur"),)) + copyMotClefInOperToFact(jdc,"AFFE_CHAR_MECA","MODELE","CONTACT") + moveMCFToCommand(jdc,"AFFE_CHAR_MECA","CONTACT","DEFI_CONTACT","ZONE") + removeMotCle(jdc,"AFFE_CHAR_MECA","CONTACT",pasDeRegle(),1) + + + removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_UNILATER","METHODE") + AjouteMotClefDansFacteur(jdc,"AFFE_CHAR_MECA","LIAISON_UNILATER","METHODE='LIAISON_UNIL'",pasDeRegle()) + copyMotClefInOperToFact(jdc,"AFFE_CHAR_MECA","MODELE","LIAISON_UNILATER") + moveMCFToCommand(jdc,"AFFE_CHAR_MECA","LIAISON_UNILATER","DEFI_CONTACT","ZONE") + removeMotCle(jdc,"AFFE_CHAR_MECA","LIAISON_UNILATER",pasDeRegle(),1) + + removeMotCleInFact(jdc,"AFFE_CHAR_MECA_F","LIAISON_UNILATER","METHODE") + AjouteMotClefDansFacteur(jdc,"AFFE_CHAR_MECA_F","LIAISON_UNILATER","METHODE='LIAISON_UNIL'",pasDeRegle()) + AjouteMotClefDansFacteur(jdc,"AFFE_CHAR_MECA_F","LIAISON_UNILATER","FORMULATION='LIAISON_UNIL'",pasDeRegle()) + copyMotClefInOperToFact(jdc,"AFFE_CHAR_MECA_F","MODELE","LIAISON_UNILATER") + moveMCFToCommand(jdc,"AFFE_CHAR_MECA_F","LIAISON_UNILATER","DEFI_CONTACT","ZONE") + removeMotCle(jdc,"AFFE_CHAR_MECA_F","LIAISON_UNILATER",pasDeRegle(),1) + + chercheOperInsereMotCleSiRegle(jdc,"DEFI_CONTACT","FORMULATION='XFEM'",((("ZONE","METHODE","XFEM",jdc),"MCsousMCFaPourValeur"),)) + chercheOperInsereMotCleSiRegle(jdc,"DEFI_CONTACT","FORMULATION='CONTINUE'",((("ZONE","METHODE","CONTINUE",jdc),"MCsousMCFaPourValeur"),)) + chercheOperInsereMotCleSiRegle(jdc,"DEFI_CONTACT","FORMULATION='VERIF'",((("ZONE","METHODE","VERIF",jdc),"MCsousMCFaPourValeur"),)) + chercheOperInsereMotCleSiRegle(jdc,"DEFI_CONTACT","FORMULATION='LIAISON_UNIL'",((("ZONE","METHODE","LIAISON_UNIL",jdc),"MCsousMCFaPourValeur"),)) + liste_meth_ZONE=["GCP","CONTRAINTE","LAGRANGIEN","PENALISATION"] + chercheOperInsereMotCleSiRegle(jdc,"DEFI_CONTACT","FORMULATION='DISCRETE'",((("ZONE","METHODE",liste_meth_ZONE,jdc),"MCsousMCFaPourValeurDansListe"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='LAGRANGIEN'",((("ZONE","METHODE","LAGRANGIEN",jdc),"MCsousMCFaPourValeur"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_FROT='LAGRANGIEN'",((("ZONE","METHODE","LAGRANGIEN",jdc),"MCsousMCFaPourValeur"),(("ZONE","COULOMB"),"existeMCsousMCF"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='GCP'",((("ZONE","METHODE","GCP",jdc),"MCsousMCFaPourValeur"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='PENALISATION'",((("ZONE","METHODE","PENALISATION",jdc),"MCsousMCFaPourValeur"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_FROT='PENALISATION'",((("ZONE","METHODE","PENALISATION",jdc),"MCsousMCFaPourValeur"),(("ZONE","COULOMB"),"existeMCsousMCF"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='CONTRAINTE'",((("ZONE","METHODE","CONTRAINTE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFact(jdc,"DEFI_CONTACT","ZONE","METHODE") + + + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","COEF_RESI") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","FROTTEMENT") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","ITER_CONT_MAXI") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","ITER_FROT_MAXI") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","ITER_GCP_MAXI") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","ITER_GEOM_MAXI") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","LISSAGE") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","NB_RESOL") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","PRE_COND") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","REAC_GEOM") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","REAC_ITER") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","RECH_LINEAIRE") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","STOP_INTERP") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","STOP_SINGULIER") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","RESI_ABSO") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","ITER_CONT_MULT") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","ITER_PRE_MAXI") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","NB_ITER_GEOM") + moveMotCleFromFactToFather(jdc,"DEFI_CONTACT","ZONE","MODELE") + + + # FORMULATION = DEPL/VITE + # Si EXCL_FROT_1 + # Si EXCL_FROT_2 + + + ####################### traitement DCX/DCY/DCZ ############################# + dDC={"DCX":"DX","DCY":"DY","DCZ":"DZ"} + renameMotCleInFact(jdc,"AFFE_CHAR_MECA","DDL_IMPO","DCX","DX") + renameMotCleInFact(jdc,"AFFE_CHAR_MECA","DDL_IMPO","DCY","DY") + renameMotCleInFact(jdc,"AFFE_CHAR_MECA","DDL_IMPO","DCZ","DZ") + renameMotCleInFact(jdc,"AFFE_CHAR_MECA_F","DDL_IMPO","DCX","DX") + renameMotCleInFact(jdc,"AFFE_CHAR_MECA_F","DDL_IMPO","DCY","DY") + renameMotCleInFact(jdc,"AFFE_CHAR_MECA_F","DDL_IMPO","DCZ","DZ") + renameMotCleInFact(jdc,"AFFE_CHAR_CINE","MECA_IMPO","DCX","DX") + renameMotCleInFact(jdc,"AFFE_CHAR_CINE","MECA_IMPO","DCY","DY") + renameMotCleInFact(jdc,"AFFE_CHAR_CINE","MECA_IMPO","DCZ","DZ") + # QUESTION Non pris en compte : AFFE_CHAR_MECA/LIAISON_DDL","DDL",Liste de valeurs avec DC*) + # peut_etre avec changeTouteValeur ? + + ######################### traitement COMB_SISM_MODAL APPUI #######################"" + # attention il faut traiter d'abord DECORRELE avant CORRELE sinon CORRELE apparaît dans DECORELLE + moveMotCleFromFactToFather(jdc,"COMB_SISM_MODAL","EXCIT","MONO_APPUI") + chercheOperInsereMotCleSiRegle(jdc,"COMB_SISM_MODAL","MULTI_APPUI1='DECORRELE'",((("EXCIT","MULTI_APPUI","DECORRELE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegleAvecErreur(jdc,"COMB_SISM_MODAL","EXCIT","MULTI_APPUI",((("EXCIT","MULTI_APPUI","DECORRELE",jdc),"MCsousMCFaPourValeur"),)) + chercheOperInsereMotCleSiRegle(jdc,"COMB_SISM_MODAL","MULTI_APPUI1='CORRELE'",((("EXCIT","MULTI_APPUI","CORRELE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegleAvecErreur(jdc,"COMB_SISM_MODAL","EXCIT","MULTI_APPUI",((("EXCIT","MULTI_APPUI","CORRELE",jdc),"MCsousMCFaPourValeur"),)) + renameMotCle(jdc,"COMB_SISM_MODAL","MULTI_APPUI1","MULTI_APPUI") + removeMotCleInFact(jdc,"COMB_SISM_MODAL","COMB_MULT_APPUI","TYPE_COMBI") + renameMotCle(jdc,"COMB_SISM_MODAL","COMB_MULT_APPUI","GROUP_APPUI") + + ######################## traitement DYNA_TRAN_MODAL ################## + AjouteMotClefDansFacteurSiRegle(jdc,"DYNA_TRAN_MODAL","CHOC","FROTTEMENT='COULOMB'",((("CHOC","COULOMB"),"existeMCsousMCF"),)) + + ######################### traitement AFFE_CHAR_MECA PESANTEUR ROTATION################# + EclaMotCleToFact(jdc,"AFFE_CHAR_MECA","PESANTEUR","GRAVITE","DIRECTION") + EclaMotCleToFact(jdc,"AFFE_CHAR_MECA","ROTATION","VITESSE","AXE") + moveMotClefInOperToFact(jdc,"AFFE_CHAR_MECA","CENTRE","ROTATION") + + ######################## traitement DEFI_BASE_MODALE ############## + renameMotCleInFact(jdc,"DEFI_BASE_MODALE","RITZ","MODE_STAT","MODE_INTF") + renameMotCleInFact(jdc,"DEFI_BASE_MODALE","RITZ","MULT_ELAS","MODE_INTF") + + ####################### traitement DYNA_ISS_VARI ################# + renameMotCle(jdc,"DYNA_ISS_VARI","PAS","FREQ_PAS") + + + #####IMPRESSION + + #################### traitement IMPR_RESU ####################### + removeMotCleInFact(jdc,"IMPR_RESU","RESU","INFO_RESU") + + ######################### traitement IMPR_MATRICE #################### + removeCommande(jdc,"IMPR_MATRICE") + + ####################### traitement PROJ_CHAMP ##################### + renameMotCle(jdc,"PROJ_CHAMP","CHAM_NO","CHAM_GD",1,pasDeRegle()) + ChangementValeur(jdc,"PROJ_CHAMP","METHODE",{ "ELEM":"COLLOCATION"}) + + + ####################### traitement MACR_ADAP_MAIL ##############" + ChangementValeur(jdc,"MACR_ADAP_MAIL","TYPE_VALEUR_INDICA",{"V_ABSOLUE":"ABSOLU","V_REALTIVE":"RELATIF"}) + renameMotCle(jdc,"MACR_ADAP_MAIL","INDICATEUR","NOM_CHAM") + renameMotCle(jdc,"MACR_ADAP_MAIL","NOM_CMP_INDICA","NOM_CMP") + renameMotCle(jdc,"MACR_ADAP_MAIL","TYPE_OPER_INDICA","USAGE_CHAMP") + renameMotCle(jdc,"MACR_ADAP_MAIL","TYPE_VALEUR_INDICA","USAGE_CMP") + AjouteMotClefDansFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='BOITE'",((("ZONE","RAYON"),"nexistepasMCsousMCF"),)) + AjouteMotClefDansFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='SPHERE'",((("ZONE","RAYON"),"existeMCsousMCF"),)) + ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_5":"V9_9"}) + ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_5":"V9_9"}) + + + + + ###################### traitement de POST_CHAM_XFEM ################# + removeMotCle(jdc,"POST_CHAM_XFEM","MODELE",pasDeRegle(),0) + removeMotCle(jdc,"POST_CHAM_XFEM","MAILLAGE_FISS",pasDeRegle(),0) + removeMotCle(jdc,"POST_CHAM_XFEM","NOM_CHAM",pasDeRegle(),0) + + ##################### traitement de SIMU_POINT_MAT/SUPPORT ############# + chercheOperInsereFacteur(jdc,"SIMU_POINT_MAT","SUPPORT='POINT'",pasDeRegle(),0) + + + ###################### traitement AFFE_CARA_ELEM/UNITE_EUROPLEXUS ###### + renameMotCleInFact(jdc,"AFFE_CARA_ELEM","RIGI_PARASOL","UNITE_EUROPLEXUS","UNITE",pasDeRegle(),0) + + + #################### traitement DEFI_GLRC/IMPRESSION ############# + removeMotCle(jdc,"DEFI_GLRC","IMPRESSION",pasDeRegle(),0) + + ################### traitement AFFICHAGE ##### + removeMotCleInFact(jdc,"DYNA_NON_LINE","AFFICHAGE","LONG_I",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","AFFICHAGE","LONG_R",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","AFFICHAGE","NOM_COLONNE",pasDeRegle(),0) + removeMotCleInFact(jdc,"DYNA_NON_LINE","AFFICHAGE","PREC_R",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","AFFICHAGE","LONG_I",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","AFFICHAGE","LONG_R",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","AFFICHAGE","NOM_COLONNE",pasDeRegle(),0) + removeMotCleInFact(jdc,"STAT_NON_LINE","AFFICHAGE","PREC_R",pasDeRegle(),0) + + ################### traitement CALC_NO *RESU ######### + removeMotCle(jdc,"CALC_NO","GROUP_MA_RESU",pasDeRegle(),0) + removeMotCle(jdc,"CALC_NO","MAILLE_RESU",pasDeRegle(),0) + removeMotCle(jdc,"CALC_NO","GROUP_NO_RESU",pasDeRegle(),0) + removeMotCle(jdc,"CALC_NO","NOEUD_RESU",pasDeRegle(),0) + + ################## traitement POST_K1_K2_K3/MAILLAGE ###### + removeMotCleSiRegle(jdc,"POST_K1_K2_K3","MAILLAGE",((("RESULTAT"),"existeMCFParmi"),)) + + ######### traitement CALC_ELEM/TYPE_ESTI #### + dESTI={"ERRE_ELEM_SIGM":"ERME_ELEM","ERZ1_ELEM_SIGM":"ERZ1_ELEM","ERZ2_ELEM_SIGM":"ERZ2_ELEM", + "QIRE_ELEM_SIGM":"QIRE_ELEM","QIZ1_ELEM_SIGM":"QIZ1_ELEM","QIZ2_ELEM_SIGM":"QIZ2_ELEM"} + ChangementValeur(jdc,"CALC_ELEM","TYPE_ESTI",dESTI) + + ######### suppression CALC_ELEM/NORME ###### + removeMotCle(jdc,"CALC_ELEM","NORME",pasDeRegle(),0) + + + ########## traitement CALC_ELEM/CALC_NO OPTION + #dSENSI={"DEDE_ELNO_DLDE":"DEDE_ELNO","DEDE_NOEU_DLDE":"DEDE_NOEU","DESI_ELNO_DLSI":"DESI_ELNO","DESI_NOEU_DLSI":"DESI_NOEU", + # "DETE_ELNO_DLTE":"DETE_ELNO","DETE_NOEU_DLTE":"DETE_NOEU"} + dOPTION={"DEDE_ELNO_DLDE":"DEDE_ELNO","DEDE_NOEU_DLDE":"DEDE_NOEU","DESI_ELNO_DLSI":"DESI_ELNO","DESI_NOEU_DLSI":"DESI_NOEU", + "DETE_ELNO_DLTE":"DETE_ELNO","DETE_NOEU_DLTE":"DETE_NOEU", + "INTE_ELNO_ACTI":"INTE_ELNO","INTE_ELNO_REAC":"INTE_ELNO","INTE_NOEU_ACTI":"INTE_NOEU","INTE_NOEU_REAC":"INTE_NOEU", + "PRES_DBEL_DEPL":"PRME_ELNO","PRES_ELNO_IMAG":"PRAC_ELNO","PRES_ELNO_REEL":"PRAC_ELNO", + "PRES_NOEU_DBEL":"PRAC_NOEU","PRES_NOEU_IMAG":"PRAC_NOEU","PRES_NOEU_REEL":"PRAC_NOEU", + "ARCO_ELNO_SIGM":"SIRO_ELEM","ARCO_NOEU_SIGM":"SIRO_ELEM", + "ENDO_ELNO_ELGA":"ENDO_ELNO","ENDO_ELNO_SIGA":"ENDO_ELNO","ENDO_ELNO_SINO":"ENDO_ELNO","ENDO_NOEU_SINO":"ENDO_NOEU", + "ERRE_ELEM_SIGM":"ERME_ELEM","ERRE_ELEM_TEMP":"ERTH_ELEM", + "CRIT_ELNO_RUPT":"CRIT_ELNO","DEGE_ELNO_DEPL":"DEGE_ELNO","DEGE_NOEU_DEPL":"DEGE_NOEU", + "DURT_ELNO_META":"DURT_ELNO","DURT_NOEU_META":"DURT_NOEU","ECIN_ELEM_DEPL":"ECIN_ELEM","ENEL_ELNO_ELGA":"ENEL_ELNO", + "ENEL_NOEU_ELGA":"ENEL_NOEU","EPEQ_ELNO_TUYO":"EPTQ_ELNO","EPME_ELGA_DEPL":"EPME_ELGA","EPME_ELNO_DEPL":"EPME_ELNO", + "EPMG_ELGA_DEPL":"EPMG_ELGA","EPMG_ELNO_DEPL":"EPMG_ELNO","EPMG_NOEU_DEPL":"EPMG_NOEU","EPOT_ELEM_DEPL":"EPOT_ELEM", + "EPSG_ELGA_DEPL":"EPSG_ELGA","EPSG_ELNO_DEPL":"EPSG_ELNO","EPSG_NOEU_DEPL":"EPSG_NOEU", + "EPSI_ELGA_DEPL":"EPSI_ELGA","EPSI_NOEU_DEPL":"EPSI_NOEU","EPSI_ELNO_DEPL":"EPSI_ELNO","EPSI_ELNO_TUYO":"EPTU_ELNO", + "ERZ1_ELEM_SIGM":"ERZ1_ELEM","ERZ2_ELEM_SIGM":"ERZ2_ELEM", + "ETOT_ELNO_ELGA":"ETOT_ELNO","EXTR_ELGA_VARI":"VAEX_ELGA","EXTR_ELNO_VARI":"VAEX_ELNO","EXTR_NOEU_VARI":"VAEX_NOEU", + "FLUX_ELGA_TEMP":"FLUX_ELGA","FLUX_ELNO_TEMP":"FLUX_ELNO","FLUX_NOEU_TEMP":"FLUX_NOEU", + "HYDR_NOEU_ELGA":"HYDR_NOEU","HYDR_ELNO_ELGA":"HYDR_ELNO", + "META_ELNO_TEMP":"META_ELNO","META_NOEU_TEMP":"META_NOEU", + "PMPB_ELGA_SIEF":"PMPB_ELGA","PMPB_ELNO_SIEF":"PMPB_ELNO","PMPB_NOEU_SIEF":"PMPB_NOEU", + "QIRE_ELEM_SIGM":"QIRE_ELEM","QIRE_ELNO_ELEM":"QIRE_ELNO","QIRE_NOEU_ELEM":"QIRE_NOEU", + "QIZ1_ELEM_SIGM":"QIZ1_ELEM","QIZ2_ELEM_SIGM":"QIZ2_ELEM", + "SIEF_ELGA_DEPL":"SIEF_ELGA","SIEF_ELNO_ELGA":"SIEF_ELNO","SIEF_NOEU_ELGA":"SIEF_NOEU", + "SIEQ_ELNO_TUYO":"SITQ_ELNO","SING_ELNO_ELEM":"SING_ELNO","SIPO_ELNO_DEPL":"SIPO_ELNO","SIPO_NOEU_DEPL":"SIPO_NOEU", + "SOUR_ELGA_ELEC":"SOUR_ELGA", + "DCHA_ELGA_SIGM":"DERA_ELGA","DCHA_ELNO_SIGM":"DERA_ELNO","DCHA_NOEU_SIGM":"DERA_NOEU", + "RADI_ELGA_SIGM":"DERA_ELGA","RADI_ELNO_SIGM":"DERA_ELNO","RADI_NOEU_SIGM":"DERA_NOEU", + "EFGE_ELNO_CART":"EFCA_ELNO","EFGE_NOEU_CART":"EFCA_NOEU","EFGE_ELNO_DEPL":"EFGE_ELNO","EFGE_NOEU_DEPL":"EFGE_NOEU", + "EQUI_ELGA_EPME":"EPMQ_ELGA","EQUI_ELNO_EPME":"EPMQ_ELNO","EQUI_NOEU_EPME":"EPMQ_NOEU", + "EQUI_ELGA_EPSI":"EPEQ_ELGA","EQUI_ELNO_EPSI":"EPEQ_ELNO","EQUI_NOEU_EPSI":"EPEQ_NOEU", + "EQUI_ELGA_SIGM":"SIEQ_ELGA","EQUI_ELNO_SIGM":"SIEQ_ELNO","EQUI_NOEU_SIGM":"SIEQ_NOEU", + "SIGM_ELNO_CART":"SICA_ELNO","SIGM_NOEU_CART":"SICA_NOEU","SIGM_ELNO_COQU":"SICO_ELNO","SIGM_NOEU_COQU":"SICO_ELNO", + "SIGM_ELNO_TUYO":"SITU_ELNO", + "SIGM_ELNO_DEPL":"SIGM_ELNO","SIGM_NOEU_DEPL":"SIGM_NOEU","SIGM_NOZ1_ELGA":"SIZ1_ELGA","SIGM_NOZ2_ELGA":"SIZ2_ELGA", + "VALE_NCOU_MAXI":"SPMX_ELGA","VARI_ELNO_COQU":"VACO_ELNO","VARI_ELNO_TUYO":"VATU_ELNO", + "VARI_NOEU_ELGA":"VARI_NOEU","VARI_ELNO_ELGA":"VARI_ELNO", + "INDI_LOCA_ELGA":"INDL_ELGA"} + #"FORC_NODA":"FORC_NOEU","REAC_NODA":"REAC_NOEU" + ChangementValeur(jdc,"CALC_ELEM","OPTION",dOPTION) + ChangementValeur(jdc,"CALC_NO","OPTION",dOPTION) + ChangementValeur(jdc,"CREA_CHAMP","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"CALC_CHAM_ELEM","OPTION",dOPTION) + ChangementValeurDsMCF(jdc,"TEST_RESU","RESU","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"TEST_RESU","GENE","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"IMPR_RESU","RESU","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"EXTR_RESU","ARCHIVAGE","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"LIRE_RESU","FORMAT_MED","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"LIRE_RESU","FORMAT_IDEAS","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"LIRE_RESU","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","OPTION",dOPTION) + ChangementValeurDsMCF(jdc,"MODI_REPERE","MODI_CHAM","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"POST_ELEM","INTEGRALE","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"POST_ELEM","MINMAX","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"RECU_FONCTION","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"CALC_META","OPTION",dOPTION) + ChangementValeur(jdc,"COMB_SISM_MODAL","OPTION",dOPTION) + ChangementValeur(jdc,"REST_GENE_PHYS","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"REST_SPEC_PHYS","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"COMB_FOURIER","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"THER_NON_LINE","OPTION",dOPTION) + ChangementValeur(jdc,"MECA_STATIQUE","OPTION",dOPTION) + ChangementValeur(jdc,"MACR_ADAP_MAIL","NOM_CHAM",dOPTION) + ChangementValeur(jdc,"MACR_LIGN_COUPE","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"POST_RELEVE_T","ACTION","NOM_CHAM",dOPTION) + + ############ Message si SuppressionValeurs ou Valeurs ambigue CALC_ELEM/OPTION + rOPTION=("'DEUL_ELGA_DEPL'","'DEUL_ELGA_TEMP'","'DURT_ELGA_META'","'SIEF_NOEU'","'VARI_NOEU'","'HYDR_ELNO_ELGA'", + "'EPSP_NOEU_ZAC'","'SIGM_NOEU_ZAC'","'SIGM_ELNO_SIEF'","'SIGM_NOEU_SIEF'","'SIPO_ELNO_SIEF'","'SIPO_NOEU_SIEF'", + "'SIRE_ELNO_DEPL'","'SIRE_NOEU_DEPL'", + "'PRES_ELNO_DBEL'", "'ERRE_ELNO_DEPL'", "'ERRE_NOEU_ELEM'", "'ERRE_ELNO_ELEM'") + # Options ambigue : PRES_ELNO_DBEL --> prac_elno/prme_elno, ERRE* --> ERME_ELNO ou ERTH_ELNO selon PHENOMENE + + GenereErreurValeur(jdc,"CALC_ELEM","OPTION",rOPTION) + GenereErreurValeur(jdc,"CALC_NO","OPTION",rOPTION) + GenereErreurValeur(jdc,"CREA_CHAMP","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"CALC_CHAM_ELEM","OPTION",rOPTION) + GenereErreurValeurDsMCF(jdc,"TEST_RESU","RESU","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"TEST_RESU","GENE","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"IMPR_RESU","RESU","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"CREA_RESU","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"EXTR_RESU","ARCHIVAGE","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"LIRE_RESU","FORMAT_MED","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"LIRE_RESU","FORMAT_IDEAS","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"LIRE_RESU","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","OPTION",rOPTION) + GenereErreurValeurDsMCF(jdc,"MODI_REPERE","MODI_CHAM","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"POST_ELEM","INTEGRALE","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"POST_ELEM","MINMAX","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"RECU_FONCTION","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"CALC_META","OPTION",rOPTION) + GenereErreurValeur(jdc,"COMB_SISM_MODAL","OPTION",rOPTION) + GenereErreurValeur(jdc,"REST_GENE_PHYS","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"REST_SPEC_PHYS","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"COMB_FOURIER","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"THER_NON_LINE","OPTION",rOPTION) + GenereErreurValeur(jdc,"MECA_STATIQUE","OPTION",rOPTION) + GenereErreurValeur(jdc,"MACR_ADAP_MAIL","NOM_CHAM",rOPTION) + GenereErreurValeur(jdc,"MACR_LIGN_COUPE","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"POST_RELEVE_T","ACTION","NOM_CHAM",rOPTION) + + + ########### Message si CALC_ELEM/SENSIBILITE + GenereErreurMCF(jdc,"CALC_ELEM","SENSIBILITE") + + # non fait CALC_NO OPTION=FORC_NODA_NONL + + ################################################################# + f=open(outfile,'w') + f.write(jdc.getSource()) + f.close() + + log.ferme(hdlr) + +def main(): + parser = optparse.OptionParser(usage=usage) + + parser.add_option('-i','--infile', dest="infile", default='toto.comm', + help="Le fichier à traduire") + parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm', + help="Le fichier traduit") + + options, args = parser.parse_args() + traduc(options.infile,options.outfile) + +if __name__ == '__main__': + main() + -- 2.39.2